KT-5289 J2K: Should show progress when conversion takes time

#KT-5289 Fixed

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

@@ -16,45 +16,64 @@
 
 package org.jetbrains.kotlin.idea.actions
 
+import com.intellij.codeInsight.actions.ReformatCodeProcessor
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.fileEditor.FileEditorManager
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.ex.MessagesEx
+import com.intellij.openapi.vfs.CharsetToolkit
+import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileVisitor
+import com.intellij.psi.PsiJavaFile
+import com.intellij.psi.PsiManager
+import com.intellij.psi.codeStyle.CodeStyleManager
+import org.jetbrains.kotlin.idea.j2k.IdeaResolverForConverter
+import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.FilesConversionScope
 import org.jetbrains.kotlin.j2k.IdeaReferenceSearcher
 import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiJavaFile
-import com.intellij.psi.PsiManager
-import java.util.ArrayList
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.psi.codeStyle.CodeStyleManager
-import java.io.IOException
-import com.intellij.openapi.ui.ex.MessagesEx
-import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
-import com.intellij.openapi.vfs.CharsetToolkit
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.utils.addIfNotNull
-import com.intellij.openapi.vfs.VfsUtilCore
-import com.intellij.openapi.vfs.VirtualFileVisitor
-import org.jetbrains.kotlin.idea.j2k.IdeaResolverForConverter
+import java.io.IOException
+import java.util.ArrayList
 
 public class JavaToKotlinAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
-        val selectedJavaFiles = selectedJavaFiles(e).toList()
+        val javaFiles = selectedJavaFiles(e).toList()
         val project = CommonDataKeys.PROJECT.getData(e.getDataContext())!!
 
+        var convertedTexts: List<String>? = null
+        fun convert() {
+            val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, FilesConversionScope(javaFiles), IdeaReferenceSearcher, IdeaResolverForConverter)
+            convertedTexts = converter.elementsToKotlin(javaFiles.map { it to J2kPostProcessor(it, formatCode = true) },
+                                                        ProgressManager.getInstance().getProgressIndicator())
+        }
+
+        if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(
+                {
+                    ApplicationManager.getApplication().runReadAction(::convert)
+                },
+                "Converting Java to Kotlin",
+                true,
+                project)) return
+
+
         CommandProcessor.getInstance().executeCommand(project, object : Runnable {
             override fun run() {
-                val newFiles = convertFiles(selectedJavaFiles, project)
-                deleteFiles(selectedJavaFiles)
-                reformatFiles(newFiles, project)
+                CommandProcessor.getInstance().markCurrentCommandAsGlobal(project)
 
-                if (newFiles.size() == 1) {
-                    FileEditorManager.getInstance(project).openFile(newFiles.single(), true)
+                val newFiles = saveResults(javaFiles, convertedTexts!!, project)
+                deleteFiles(javaFiles)
+
+                newFiles.singleOrNull()?.let {
+                    FileEditorManager.getInstance(project).openFile(it, true)
                 }
             }
         }, "Convert files from Java to Kotlin", null)
@@ -65,16 +84,16 @@ public class JavaToKotlinAction : AnAction() {
         e.getPresentation().setEnabled(enabled)
     }
 
-    private fun selectedJavaFiles(e: AnActionEvent): Stream<PsiJavaFile> {
-        val virtualFiles = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY) ?: return streamOf()
-        val project = CommonDataKeys.PROJECT.getData(e.getDataContext()) ?: return streamOf()
+    private fun selectedJavaFiles(e: AnActionEvent): Sequence<PsiJavaFile> {
+        val virtualFiles = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY) ?: return sequenceOf()
+        val project = CommonDataKeys.PROJECT.getData(e.getDataContext()) ?: return sequenceOf()
         return allJavaFiles(virtualFiles, project)
     }
 
-    private fun allJavaFiles(filesOrDirs: Array<VirtualFile>, project: Project): Stream<PsiJavaFile> {
+    private fun allJavaFiles(filesOrDirs: Array<VirtualFile>, project: Project): Sequence<PsiJavaFile> {
         val manager = PsiManager.getInstance(project)
         return allFiles(filesOrDirs)
-                .stream()
+                .sequence()
                 .map { manager.findFile(it) as? PsiJavaFile }
                 .filterNotNull()
     }
@@ -92,22 +111,7 @@ public class JavaToKotlinAction : AnAction() {
         return result
     }
 
-    private fun reformatFiles(kotlinFiles: List<VirtualFile>, project: Project) {
-        for (file in kotlinFiles) {
-            ApplicationManager.getApplication().runWriteAction {
-                val jetFile = PsiManager.getInstance(project).findFile(file) as? JetFile
-                if (jetFile != null) {
-                    CodeStyleManager.getInstance(project).reformat(jetFile)
-                }
-            }
-        }
-    }
-
-    private fun convertFiles(javaFiles: List<PsiJavaFile>, project: Project): List<VirtualFile> {
-        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, FilesConversionScope(javaFiles), IdeaReferenceSearcher, IdeaResolverForConverter)
-
-        val convertedTexts = converter.elementsToKotlin(javaFiles.map { it to J2kPostProcessor(it) })
-
+    private fun saveResults(javaFiles: List<PsiJavaFile>, convertedTexts: List<String>, project: Project): List<VirtualFile> {
         val result = ArrayList<VirtualFile>()
         for ((i, psiFile) in javaFiles.withIndex()) {
             ApplicationManager.getApplication().runWriteAction {

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

@@ -127,7 +127,7 @@ public class ConvertJavaCopyPastePostProcessor() : CopyPastePostProcessor<TextBl
             val elementToConvert = findTopMostParentWhollyInRange(currentRange, leafElement)
             val unconvertedPrefix = fileText.substring(currentRange.start, elementToConvert.range.start)
             result.append(unconvertedPrefix)
-            val converted = converter.elementsToKotlin(listOf(elementToConvert to J2kPostProcessor(fileCopiedTo)))[0]
+            val converted = converter.elementsToKotlin(listOf(elementToConvert to J2kPostProcessor(fileCopiedTo, formatCode = false)))[0]
             if (converted.isNotEmpty()) {
                 result.append(converted)
             }

idea/src/org/jetbrains/kotlin/idea/formatter/JetFormattingModelBuilder.java

@@ -21,10 +21,13 @@ import com.intellij.formatting.FormattingModelBuilder;
 import com.intellij.formatting.FormattingModelProvider;
 import com.intellij.formatting.Indent;
 import com.intellij.lang.ASTNode;
+import com.intellij.openapi.editor.impl.DocumentImpl;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.formatter.FormattingDocumentModelImpl;
+import com.intellij.psi.formatter.PsiBasedFormattingModel;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.JetLanguage;
 
@@ -37,8 +40,15 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder {
                 containingFile.getNode(), NodeAlignmentStrategy.getNullStrategy(), Indent.getNoneIndent(), null, settings,
                 FormatterPackage.createSpacingBuilder(settings));
 
-        return FormattingModelProvider.createFormattingModelForPsiFile(
-                element.getContainingFile(), block, settings);
+        //TODO: this is temporary code to allow formatting non-physical files in non-UI thread (used by conversion from Java to Kotlin)
+        // it's needed until IDEA's issue with this document being created with wrong threading policy is fixed
+        if (!element.isPhysical()) {
+            FormattingDocumentModelImpl formattingDocumentModel =
+                    new FormattingDocumentModelImpl(new DocumentImpl(containingFile.getViewProvider().getContents(), true), containingFile);
+            return new PsiBasedFormattingModel(containingFile, block, formattingDocumentModel);
+        }
+
+        return FormattingModelProvider.createFormattingModelForPsiFile(element.getContainingFile(), block, settings);
     }
 
     @Override

idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt

@@ -16,7 +16,10 @@
 
 package org.jetbrains.kotlin.idea.j2k
 
+import com.intellij.openapi.editor.impl.DocumentImpl
+import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.psi.PsiElement
+import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.psi.search.LocalSearchScope
 import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.diagnostics.Diagnostic
@@ -31,9 +34,11 @@ import org.jetbrains.kotlin.idea.quickfix.RemoveRightPartOfBinaryExpressionFix
 import org.jetbrains.kotlin.j2k.PostProcessor
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
+import java.lang.reflect.Field
+import java.lang.reflect.Modifier
 import java.util.ArrayList
 
-public class J2kPostProcessor(override val contextToAnalyzeIn: PsiElement) : PostProcessor {
+public class J2kPostProcessor(override val contextToAnalyzeIn: PsiElement, private val formatCode: Boolean) : PostProcessor {
     override fun analyzeFile(file: JetFile): BindingContext {
         return file.analyzeFullyAndGetResult().bindingContext
     }
@@ -109,5 +114,9 @@ public class J2kPostProcessor(override val contextToAnalyzeIn: PsiElement) : Pos
         for (typeArgs in redundantTypeArgs) {
             typeArgs.delete()
         }
+
+        if (formatCode) {
+            CodeStyleManager.getInstance(contextToAnalyzeIn.getProject()).reformat(file)
+        }
     }
 }