J2K: do not convert doc comments on WebDemo

#KT-7968 Fixed

idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt

@@ -36,9 +36,7 @@ import org.jetbrains.kotlin.idea.j2k.IdeaResolverForConverter
 import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runReadAction
-import org.jetbrains.kotlin.j2k.ConverterSettings
-import org.jetbrains.kotlin.j2k.IdeaReferenceSearcher
-import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
+import org.jetbrains.kotlin.j2k.*
 import java.io.File
 import java.io.IOException
 import java.util.ArrayList
@@ -52,7 +50,7 @@ public class JavaToKotlinAction : AnAction() {
 
         var converterResult: JavaToKotlinConverter.FilesResult? = null
         fun convert() {
-            val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, IdeaReferenceSearcher, IdeaResolverForConverter)
+            val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, IdeaReferenceSearcher, IdeaResolverForConverter, IdeaDocCommentConverter)
             converterResult = converter.filesToKotlin(javaFiles, J2kPostProcessor(formatCode = true), ProgressManager.getInstance().getProgressIndicator())
         }
 

idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt

@@ -160,7 +160,8 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
                 project,
                 ConverterSettings.defaultSettings,
                 IdeaReferenceSearcher,
-                IdeaResolverForConverter
+                IdeaResolverForConverter,
+                IdeaDocCommentConverter
         )
 
         val inputElements = elementsAndTexts.filterIsInstance<PsiElement>()

idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt

@@ -67,6 +67,7 @@ import org.jetbrains.kotlin.idea.j2k.IdeaResolverForConverter
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.idea.util.string.collapseSpaces
 import org.jetbrains.kotlin.j2k.ConverterSettings
+import org.jetbrains.kotlin.j2k.IdeaDocCommentConverter
 import org.jetbrains.kotlin.j2k.IdeaReferenceSearcher
 import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
 import org.jetbrains.kotlin.psi.*
@@ -572,7 +573,8 @@ fun PsiExpression.j2k(): JetExpression? {
     val j2kConverter = JavaToKotlinConverter(project,
                                              ConverterSettings.defaultSettings,
                                              IdeaReferenceSearcher,
-                                             IdeaResolverForConverter)
+                                             IdeaResolverForConverter,
+                                             IdeaDocCommentConverter)
     val text = j2kConverter.elementsToKotlin(listOf(this)).results.single()?.text ?: return null //TODO: insert imports
     return JetPsiFactory(getProject()).createExpression(text)
 }

j2k/src/org/jetbrains/kotlin/j2k/CodeBuilder.kt

@@ -53,7 +53,7 @@ fun CodeBuilder.append(elements: Collection<Element>, separator: String, prefix:
 
 class ElementCreationStackTraceRequiredException : RuntimeException()
 
-class CodeBuilder(private val topElement: PsiElement?) {
+class CodeBuilder(private val topElement: PsiElement?, private var docConverter: DocCommentConverter) {
     private val builder = StringBuilder()
     private var endOfLineCommentAtEnd = false
 
@@ -70,7 +70,7 @@ class CodeBuilder(private val topElement: PsiElement?) {
 
     private fun appendCommentOrWhiteSpace(element: PsiElement) {
         if (element is PsiDocComment) {
-            append(DocCommentConverter.convertDocComment(element), false)
+            append(docConverter.convertDocComment(element), false)
         }
         else {
             append(element.getText()!!, element.isEndOfLineComment())

j2k/src/org/jetbrains/kotlin/j2k/Converter.kt

@@ -41,6 +41,7 @@ class Converter private constructor(
         val inConversionScope: (PsiElement) -> Boolean,
         val referenceSearcher: ReferenceSearcher,
         val resolverForConverter: ResolverForConverter,
+        private val docCommentConverter: DocCommentConverter,
         private val commonState: Converter.CommonState,
         private val personalState: Converter.PersonalState
 ) {
@@ -63,17 +64,17 @@ class Converter private constructor(
     companion object {
         public fun create(elementToConvert: PsiElement, settings: ConverterSettings, inConversionScope: (PsiElement) -> Boolean,
                           referenceSearcher: ReferenceSearcher, resolverForConverter: ResolverForConverter,
-                          usageProcessingsCollector: (UsageProcessing) -> Unit): Converter {
+                          docCommentConverter: DocCommentConverter, usageProcessingsCollector: (UsageProcessing) -> Unit): Converter {
             return Converter(elementToConvert, settings, inConversionScope,
                              CachingReferenceSearcher(referenceSearcher),
-                             resolverForConverter, CommonState(usageProcessingsCollector), PersonalState(null))
+                             resolverForConverter, docCommentConverter, CommonState(usageProcessingsCollector), PersonalState(null))
         }
     }
 
     public fun withSpecialContext(context: PsiElement): Converter = withState(PersonalState(context))
 
     private fun withState(state: PersonalState): Converter
-            = Converter(elementToConvert, settings, inConversionScope, referenceSearcher, resolverForConverter, commonState, state)
+            = Converter(elementToConvert, settings, inConversionScope, referenceSearcher, resolverForConverter, docCommentConverter, commonState, state)
 
     private fun createDefaultCodeConverter() = CodeConverter(this, DefaultExpressionConverter(), DefaultStatementConverter(), null)
 
@@ -97,7 +98,7 @@ class Converter private constructor(
                 { usageProcessings ->
                     unfoldDeferredElements(usageProcessings)
 
-                    val builder = CodeBuilder(elementToConvert)
+                    val builder = CodeBuilder(elementToConvert, docCommentConverter)
                     builder.append(element)
                     Result(builder.resultText, builder.importsToAdd)
                 },

j2k/src/org/jetbrains/kotlin/j2k/DocCommentConverter.kt

@@ -29,8 +29,16 @@ import com.intellij.psi.xml.XmlText
 import com.intellij.psi.xml.XmlTokenType
 import java.util.Stack
 
-object DocCommentConverter {
-    fun convertDocComment(docComment: PsiDocComment): String {
+interface DocCommentConverter {
+    fun convertDocComment(docComment: PsiDocComment): String
+}
+
+object EmptyDocCommentConverter: DocCommentConverter {
+    override fun convertDocComment(docComment: PsiDocComment) = docComment.text
+}
+
+object IdeaDocCommentConverter : DocCommentConverter {
+    override fun convertDocComment(docComment: PsiDocComment): String {
         val html = StringBuilder {
             appendJavadocElements(docComment.getDescriptionElements())
 

j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt

@@ -84,7 +84,8 @@ public class JavaToKotlinConverter(
         private val project: Project,
         private val settings: ConverterSettings,
         private val referenceSearcher: ReferenceSearcher,
-        private val resolverForConverter: ResolverForConverter
+        private val resolverForConverter: ResolverForConverter,
+        private val docCommentConverter: DocCommentConverter
 ) {
     private val LOG = Logger.getInstance("#org.jetbrains.kotlin.j2k.JavaToKotlinConverter")
 
@@ -142,7 +143,7 @@ public class JavaToKotlinConverter(
 
 
             val intermediateResults = processor.processItems(0.25, inputElements) { inputElement ->
-                Converter.create(inputElement, settings, ::inConversionScope, referenceSearcher, resolverForConverter, usageProcessingCollector).convert()
+                Converter.create(inputElement, settings, ::inConversionScope, referenceSearcher, resolverForConverter, docCommentConverter, usageProcessingCollector).convert()
             }.toArrayList()
 
             val results = processor.processItems(0.25, intermediateResults.withIndex()) { pair ->

j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinTranslator.kt

@@ -16,34 +16,11 @@
 
 package org.jetbrains.kotlin.j2k
 
-import com.intellij.core.JavaCoreApplicationEnvironment
-import com.intellij.core.JavaCoreProjectEnvironment
 import com.intellij.lang.java.JavaLanguage
-import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.PsiJavaFile
-import org.jetbrains.kotlin.utils.PathUtil
-import java.io.File
-import java.net.URLClassLoader
-import com.intellij.codeInsight.NullableNotNullManager
-import com.intellij.psi.PsiModifierListOwner
-import com.intellij.openapi.extensions.Extensions
-import com.intellij.core.CoreApplicationEnvironment
-import com.intellij.psi.augment.PsiAugmentProvider
-import com.intellij.codeInsight.runner.JavaMainMethodProvider
-import com.intellij.codeInsight.ContainerProvider
-import com.intellij.openapi.fileTypes.FileTypeExtensionPoint
-import com.intellij.psi.stubs.BinaryFileStubBuilders
-import com.intellij.psi.FileContextProvider
-import com.intellij.psi.meta.MetaDataContributor
-import com.intellij.psi.impl.compiled.ClsCustomNavigationPolicy
-import com.intellij.psi.compiled.ClassFileDecompilers
-import com.intellij.psi.impl.PsiTreeChangePreprocessor
-import com.intellij.psi.PsiElementFinder
-import com.intellij.openapi.extensions.ExtensionsArea
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiElement
 
 public object JavaToKotlinTranslator {
     private fun createFile(text: String, project: Project): PsiFile? {
@@ -68,7 +45,7 @@ public object JavaToKotlinTranslator {
     public fun generateKotlinCode(javaCode: String, project: Project): String {
         val file = createFile(javaCode, project)
         if (file is PsiJavaFile) {
-            val converter = JavaToKotlinConverter(file.getProject(), ConverterSettings.defaultSettings, EmptyReferenceSearcher, EmptyResolverForConverter)
+            val converter = JavaToKotlinConverter(file.getProject(), ConverterSettings.defaultSettings, EmptyReferenceSearcher, EmptyResolverForConverter, EmptyDocCommentConverter)
             return prettify(converter.elementsToKotlin(listOf(file)).results.single()!!.text) //TODO: imports
         }
         return ""

j2k/src/org/jetbrains/kotlin/j2k/ast/Element.kt

@@ -62,7 +62,7 @@ data class CommentsAndSpacesInheritance(
 }
 
 fun Element.canonicalCode(): String {
-    val builder = CodeBuilder(null)
+    val builder = CodeBuilder(null, EmptyDocCommentConverter)
     builder.append(this)
     return builder.resultText
 }

j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterMultiFileTest.kt

@@ -54,7 +54,7 @@ public abstract class AbstractJavaToKotlinConverterMultiFileTest : AbstractJavaT
             assert(psiFile is PsiJavaFile || psiFile is JetFile)
         }
 
-        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, IdeaReferenceSearcher, IdeaResolverForConverter)
+        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, IdeaReferenceSearcher, IdeaResolverForConverter, EmptyDocCommentConverter)
         val (results, externalCodeProcessor) = converter.filesToKotlin(psiFilesToConvert, J2kPostProcessor(formatCode = true))
 
         val process = externalCodeProcessor?.prepareWriteOperation(EmptyProgressIndicator())

j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt

@@ -108,7 +108,7 @@ public abstract class AbstractJavaToKotlinConverterSingleFileTest : AbstractJava
     private fun fileToKotlin(text: String, settings: ConverterSettings, project: Project): String {
         val file = createJavaFile(text)
         val converter = JavaToKotlinConverter(project, settings,
-                                              IdeaReferenceSearcher, IdeaResolverForConverter)
+                                              IdeaReferenceSearcher, IdeaResolverForConverter, IdeaDocCommentConverter)
         return converter.filesToKotlin(listOf(file), J2kPostProcessor(formatCode = true)).results.single()
     }