diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
index 4d45a7c31d0..d4a7e4a6356 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
@@ -473,7 +473,7 @@ private fun findFirstLeafWhollyInRange(file: PsiFile, range: TextRange): PsiElem
     var element = file.findElementAt(range.getStartOffset()) ?: return null
     var elementRange = element.getTextRange()
     if (elementRange.getStartOffset() < range.getStartOffset()) {
-        element = file.findElementAt(elementRange.getEndOffset()) ?: return null
+        element = element.nextLeaf(skipEmptyElements = true) ?: return null
         elementRange = element.getTextRange()
     }
     assert(elementRange.getStartOffset() >= range.getStartOffset())
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
index fd217cfc90d..3b5f3474fab 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
@@ -35,6 +35,7 @@ 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.idea.util.application.runReadAction
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.IdeaReferenceSearcher
 import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
@@ -59,7 +60,7 @@ public class JavaToKotlinAction : AnAction() {
 
         if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(
                 {
-                    ApplicationManager.getApplication().runReadAction(::convert)
+                    runReadAction(::convert)
                 },
                 "Converting Java to Kotlin",
                 true,
@@ -70,7 +71,7 @@ public class JavaToKotlinAction : AnAction() {
             override fun run() {
                 CommandProcessor.getInstance().markCurrentCommandAsGlobal(project)
 
-                val newFiles = saveResults(javaFiles, convertedTexts!!, project)
+                val newFiles = saveResults(javaFiles, convertedTexts!!)
                 deleteFiles(javaFiles)
 
                 newFiles.singleOrNull()?.let {
@@ -87,7 +88,7 @@ public class JavaToKotlinAction : AnAction() {
 
     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()
+        val project = e.getProject() ?: return sequenceOf()
         return allJavaFiles(virtualFiles, project)
     }
 
@@ -112,11 +113,11 @@ public class JavaToKotlinAction : AnAction() {
         return result
     }
 
-    private fun saveResults(javaFiles: List<PsiJavaFile>, convertedTexts: List<String>, project: Project): List<VirtualFile> {
+    private fun saveResults(javaFiles: List<PsiJavaFile>, convertedTexts: List<String>): List<VirtualFile> {
         val result = ArrayList<VirtualFile>()
-        for ((i, psiFile) in javaFiles.withIndex()) {
+        for ((psiFile, text) in javaFiles.zip(convertedTexts)) {
             ApplicationManager.getApplication().runWriteAction {
-                result.addIfNotNull(saveConversionResult(psiFile.getVirtualFile(), convertedTexts[i], project))
+                result.addIfNotNull(saveConversionResult(psiFile.getVirtualFile(), text, psiFile.getProject()))
             }
         }
         return result
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
index dec423be59e..da7e20278b8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
@@ -205,16 +205,15 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         val file = PsiDocumentManager.getInstance(project).getPsiFile(document)
         if (file !is JetFile) return
 
-        assert(values.size() == 1)
         val referenceData = values.single().data
 
         processReferenceData(project, file, bounds.getStartOffset(), referenceData)
     }
 
-    public fun processReferenceData(project: Project, file: JetFile, boundStart: Int, referenceData: Array<KotlinReferenceData>) {
+    public fun processReferenceData(project: Project, file: JetFile, blockStart: Int, referenceData: Array<KotlinReferenceData>) {
         PsiDocumentManager.getInstance(project).commitAllDocuments()
 
-        val referencesPossibleToRestore = findReferencesToRestore(file, boundStart, referenceData)
+        val referencesPossibleToRestore = findReferencesToRestore(file, blockStart, referenceData)
 
         val selectedReferencesToRestore = showRestoreReferencesDialog(project, referencesPossibleToRestore)
         if (selectedReferencesToRestore.isEmpty()) return
@@ -224,11 +223,11 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         })
     }
 
-    private fun findReferencesToRestore(file: PsiFile, boundStart: Int, referenceData: Array<out KotlinReferenceData>): List<ReferenceToRestoreData> {
+    private fun findReferencesToRestore(file: PsiFile, blockStart: Int, referenceData: Array<out KotlinReferenceData>): List<ReferenceToRestoreData> {
         if (file !is JetFile) return listOf()
 
         return referenceData.map {
-            val referenceElement = findReference(it, file, boundStart)
+            val referenceElement = findReference(it, file, blockStart)
             if (referenceElement != null)
                 createReferenceToRestoreData(referenceElement, it)
             else
@@ -236,9 +235,9 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
         }.filterNotNull()
     }
 
-    private fun findReference(data: KotlinReferenceData, file: JetFile, boundStart: Int): JetElement? {
-        val startOffset = data.startOffset + boundStart
-        val endOffset = data.endOffset + boundStart
+    private fun findReference(data: KotlinReferenceData, file: JetFile, blockStart: Int): JetElement? {
+        val startOffset = data.startOffset + blockStart
+        val endOffset = data.endOffset + blockStart
         val element = file.findElementAt(startOffset)
         val desiredRange = TextRange(startOffset, endOffset)
         var expression = element
diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
index a6b777a80e3..db599b95424 100644
--- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.idea.codeInsight.KotlinReferenceData
 import org.jetbrains.kotlin.idea.editor.JetEditorOptions
 import org.jetbrains.kotlin.idea.j2k.IdeaResolverForConverter
 import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.j2k.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
@@ -66,6 +67,8 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
 
     public override fun processTransferableData(project: Project, editor: Editor, bounds: RangeMarker, caretOffset: Int, indented: Ref<Boolean>, values: List<TextBlockTransferableData>) {
         if (DumbService.getInstance(project).isDumb()) return
+        val jetEditorOptions = JetEditorOptions.getInstance()
+        if (!jetEditorOptions.isEnableJavaToKotlinConversion()) return
 
         val data = values.single()
         if (data !is CopiedJavaCode) return
@@ -94,7 +97,7 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
 
         var conversionResult: Pair<String?, Collection<KotlinReferenceData>>? = null
 
-        fun doConversionAndInsertImportsIfNoConversion(): Boolean {
+        fun doConversionAndInsertImportsIfUnchanged(): Boolean {
             conversionResult = doConversion()
 
             val text = conversionResult!!.first
@@ -106,19 +109,18 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
 
         val textLength = data.startOffsets.indices.sumBy { data.endOffsets[it] - data.startOffsets[it] }
         if (textLength < 1000) { // if the text to convert is short enough, try to do conversion without permission from user and skip the dialog if nothing converted
-            if (doConversionAndInsertImportsIfNoConversion()) return
+            if (doConversionAndInsertImportsIfUnchanged()) return
         }
 
-        val jetEditorOptions = JetEditorOptions.getInstance()!!
-        val needConvert = jetEditorOptions.isEnableJavaToKotlinConversion() && (jetEditorOptions.isDonTShowConversionDialog() || okFromDialog(project))
+        val needConvert = jetEditorOptions.isDonTShowConversionDialog() || okFromDialog(project)
         if (needConvert) {
             if (conversionResult == null) {
-                if (doConversionAndInsertImportsIfNoConversion()) return
+                if (doConversionAndInsertImportsIfUnchanged()) return
             }
             val (text, referenceData) = conversionResult!!
-            text!! // otherwise we should get true from doConversionAndInsertImportsIfNoConversion and return above
+            text!! // otherwise we should get true from doConversionAndInsertImportsIfUnchanged and return above
 
-            ApplicationManager.getApplication()!!.runWriteAction {
+            runWriteAction {
                 val startOffset = bounds.getStartOffset()
                 document.replaceString(startOffset, bounds.getEndOffset(), text)
 
@@ -168,6 +170,8 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
         for (o in list) {
             if (o is PsiElement) {
                 val originalText = o.getText()
+                originalCodeBuilder.append(originalText)
+
                 val result = results[resultIndex++]
                 if (result != null) {
                     convertedCodeBuilder.append(result.text)
@@ -178,11 +182,10 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
                 else { // failed to convert element to Kotlin, insert "as is"
                     convertedCodeBuilder.append(originalText)
                 }
-                originalCodeBuilder.append(originalText)
             }
             else {
-                convertedCodeBuilder.append(o as String)
                 originalCodeBuilder.append(o)
+                convertedCodeBuilder.append(o as String)
             }
         }
 
@@ -214,7 +217,7 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
         val fileText = StringBuilder {
             val packageName = sourceFile.getPackageName()
             if (!packageName.isEmpty()) {
-                append("package ").append(packageName).append("\n")
+                append("package $packageName\n")
             }
 
             val importList = sourceFile.getImportList()
@@ -222,37 +225,22 @@ public class ConvertJavaCopyPastePostProcessor : CopyPastePostProcessor<TextBloc
                 for (import in importList.getImportStatements()) {
                     val qualifiedName = import.getQualifiedName() ?: continue
                     if (import.isOnDemand()) {
-                        append("import ").append(qualifiedName).append(".*\n")
+                        append("import $qualifiedName.*\n")
                     }
                     else {
                         val fqName = FqNameUnsafe(qualifiedName)
                         // skip explicit imports of platform classes mapped into Kotlin classes
                         if (fqName.isSafe() && JavaToKotlinClassMap.INSTANCE.mapPlatformClass(fqName.toSafe()).isNotEmpty()) continue
-                        append("import ").append(qualifiedName).append("\n")
+                        append("import $qualifiedName\n")
                     }
                 }
                 //TODO: static imports
             }
 
 
-            val contextPrefix: String
-            val contextSuffix: String
-            when (parseContext) {
-                ParseContext.CODE_BLOCK -> {
-                    contextPrefix = "fun ${generateDummyFunctionName(text)}() {\n"
-                    contextSuffix = "\n}"
-                }
-
-                ParseContext.TOP_LEVEL -> {
-                    contextPrefix = ""
-                    contextSuffix = ""
-                }
-
-                //TODO: see KT-7264
-                else -> {
-                    contextPrefix = ""
-                    contextSuffix = ""
-                }
+            val (contextPrefix, contextSuffix) = when (parseContext) {
+                ParseContext.CODE_BLOCK -> "fun ${generateDummyFunctionName(text)}() {\n" to "\n}"
+                ParseContext.TOP_LEVEL -> "" to ""
             }
 
             append(contextPrefix)
diff --git a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
index 09cf92dcfe6..0070ca6bf01 100644
--- a/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt
@@ -88,7 +88,7 @@ public class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
             if (rangeMarker == null) return RangeFilterResult.PROCESS
             if (!rangeMarker.isValid()) return RangeFilterResult.SKIP
             val range = TextRange(rangeMarker.getStartOffset(), rangeMarker.getEndOffset())
-            val elementRange = element.getTextRange()!!
+            val elementRange = element.getTextRange()
             return when {
                 range.contains(elementRange) -> RangeFilterResult.PROCESS
                 range.intersects(elementRange) -> RangeFilterResult.GO_INSIDE
diff --git a/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
index 7a689e6c783..9bce8fd8c1d 100644
--- a/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
+++ b/j2k/src/org/jetbrains/kotlin/j2k/JavaToKotlinConverter.kt
@@ -147,7 +147,10 @@ public class JavaToKotlinConverter(private val project: Project,
                 intermediateResults[i] = null // to not hold unused objects in the heap
             }
 
-            if (postProcessor == null) return results
+            if (postProcessor == null) {
+                assert(progress is EmptyProgressIndicator, "Progress indicator not supported for postProcessor == null")
+                return results
+            }
 
             val finalResults = ArrayList<Result?>(elementCount)
             processFilesWithProgress(0.5) { i ->
@@ -156,7 +159,7 @@ public class JavaToKotlinConverter(private val project: Project,
                     try {
                         //TODO: post processing does not work correctly for ParseContext different from TOP_LEVEL
                         val kotlinFile = JetPsiFactory(project).createAnalyzableFile("dummy.kt", result.text, inputElements[i].postProcessingContext!!)
-                        AfterConversionPass(project, postProcessor).run(kotlinFile, null)
+                        AfterConversionPass(project, postProcessor).run(kotlinFile, range = null)
                         finalResults.add(Result(kotlinFile.getText(), result.parseContext))
                     }
                     catch(e: ProcessCanceledException) {