Don't apply copyright notice to Kotlin Ultimate

This reverts commit ab206fbe63.

.idea/scopes/Apply_copyright.xml

@@ -1,3 +1,3 @@
 <component name="DependencyValidationManager">
-  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle" />
+  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle&amp;&amp;!file[kotlin.kotlin-ultimate]:*/&amp;&amp;!file[kotlin.kotlin-ultimate.*]:*/" />
 </component>

build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.JpsPersistentHashMap
+import com.intellij.util.io.PersistentHashMap
 import java.io.File
 
 
@@ -28,10 +28,10 @@ class NonCachingLazyStorage<K, V>(
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
     @Volatile
-    private var storage: JpsPersistentHashMap<K, V>? = null
+    private var storage: PersistentHashMap<K, V>? = null
 
     @Synchronized
-    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
         if (storage != null) return storage
 
         if (storageFile.exists()) {
@@ -43,7 +43,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     @Synchronized
-    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
         if (storage == null) {
             storage = createMap()
         }
@@ -69,7 +69,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendDataWithoutCache(key, value)
+        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
     }
 
     @Synchronized
@@ -79,7 +79,7 @@ class NonCachingLazyStorage<K, V>(
         } catch (ignored: Throwable) {
         }
 
-        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
         storage = null
     }
 
@@ -101,6 +101,6 @@ class NonCachingLazyStorage<K, V>(
         storage?.close()
     }
 
-    private fun createMap(): JpsPersistentHashMap<K, V> =
-        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+    private fun createMap(): PersistentHashMap<K, V> =
+        PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
 }

build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt.193

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.JpsPersistentHashMap
+import java.io.File
+
+
+class NonCachingLazyStorage<K, V>(
+    private val storageFile: File,
+    private val keyDescriptor: KeyDescriptor<K>,
+    private val valueExternalizer: DataExternalizer<V>
+) : LazyStorage<K, V> {
+    @Volatile
+    private var storage: JpsPersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    override val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    override operator fun contains(key: K): Boolean =
+        getStorageIfExists()?.containsMapping(key) ?: false
+
+    override operator fun get(key: K): V? =
+        getStorageIfExists()?.get(key)
+
+    override operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    override fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    override fun append(key: K, value: V) {
+        getStorageOrCreateNew().appendDataWithoutCache(key, value)
+    }
+
+    @Synchronized
+    override fun clean() {
+        try {
+            storage?.close()
+        } catch (ignored: Throwable) {
+        }
+
+        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
+    }
+
+    @Synchronized
+    override fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        } else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    override fun close() {
+        storage?.close()
+    }
+
+    private fun createMap(): JpsPersistentHashMap<K, V> =
+        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java

@@ -4,147 +4,52 @@
  */
 package org.jetbrains.kotlin.cli.jvm.compiler;
 
+import com.intellij.DynamicBundle;
 import com.intellij.codeInsight.ContainerProvider;
-import com.intellij.codeInsight.JavaContainerProvider;
-import com.intellij.codeInsight.folding.JavaCodeFoldingSettings;
-import com.intellij.codeInsight.folding.impl.JavaCodeFoldingSettingsBase;
-import com.intellij.codeInsight.folding.impl.JavaFoldingBuilderBase;
 import com.intellij.codeInsight.runner.JavaMainMethodProvider;
-import com.intellij.core.CoreApplicationEnvironment;
-import com.intellij.core.CoreJavaDirectoryService;
-import com.intellij.core.CorePsiPackageImplementationHelper;
-import com.intellij.ide.highlighter.ArchiveFileType;
-import com.intellij.ide.highlighter.JavaClassFileType;
-import com.intellij.ide.highlighter.JavaFileType;
-import com.intellij.lang.LanguageASTFactory;
+import com.intellij.core.JavaCoreApplicationEnvironment;
 import com.intellij.lang.MetaLanguage;
-import com.intellij.lang.folding.LanguageFolding;
-import com.intellij.lang.java.JavaLanguage;
-import com.intellij.lang.java.JavaParserDefinition;
-import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.extensions.ExtensionsArea;
-import com.intellij.openapi.fileTypes.FileTypeExtensionPoint;
-import com.intellij.openapi.fileTypes.PlainTextFileType;
-import com.intellij.openapi.fileTypes.PlainTextLanguage;
-import com.intellij.openapi.fileTypes.PlainTextParserDefinition;
-import com.intellij.openapi.projectRoots.JavaVersionService;
 import com.intellij.openapi.vfs.VirtualFileSystem;
-import com.intellij.psi.*;
+import com.intellij.psi.FileContextProvider;
 import com.intellij.psi.augment.PsiAugmentProvider;
-import com.intellij.psi.augment.TypeAnnotationModifier;
 import com.intellij.psi.compiled.ClassFileDecompilers;
-import com.intellij.psi.impl.LanguageConstantExpressionEvaluator;
-import com.intellij.psi.impl.PsiExpressionEvaluator;
-import com.intellij.psi.impl.PsiSubstitutorFactoryImpl;
-import com.intellij.psi.impl.compiled.ClassFileStubBuilder;
-import com.intellij.psi.impl.file.PsiPackageImplementationHelper;
-import com.intellij.psi.impl.search.MethodSuperSearcher;
-import com.intellij.psi.impl.source.tree.JavaASTFactory;
-import com.intellij.psi.impl.source.tree.PlainTextASTFactory;
 import com.intellij.psi.meta.MetaDataContributor;
-import com.intellij.psi.presentation.java.*;
-import com.intellij.psi.search.searches.SuperMethodsSearch;
-import com.intellij.psi.stubs.BinaryFileStubBuilders;
-import com.intellij.util.QueryExecutor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
 
-/**
- * adapted from com.intellij.core.JavaCoreApplicationEnvironment
- * TODO: initiate removal original from com.intellij.core since it seems that there are no usages left
- */
-public class KotlinCoreApplicationEnvironment extends CoreApplicationEnvironment {
+public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+        registerExtensionPoints();
+        return environment;
+    }
 
-  public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
-  }
+    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        super(parentDisposable, unitTestMode);
+    }
 
-  private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-    super(parentDisposable, unitTestMode);
+    private static void registerExtensionPoints() {
+        registerApplicationExtensionPoint(DynamicBundle.LanguageBundleEP.EP_NAME, DynamicBundle.LanguageBundleEP.class);
+        registerApplicationExtensionPoint(FileContextProvider.EP_NAME, FileContextProvider.class);
 
-    registerExtensionPoints();
+        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
+        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
 
-    registerExtensions();
-  }
+        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
 
-  private void registerExtensionPoints() {
-    ExtensionsArea area = Extensions.getRootArea();
+        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
 
-    CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider.class);
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+    }
 
-    CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
-
-    CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
-
-    CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage.class);
-
-    IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(area);
-  }
-
-  private void registerExtensions() {
-    registerFileType(JavaClassFileType.INSTANCE, "class");
-    registerFileType(JavaFileType.INSTANCE, "java");
-    registerFileType(ArchiveFileType.INSTANCE, "jar;zip");
-    registerFileType(PlainTextFileType.INSTANCE, "txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");
-
-    addExplicitExtension(LanguageASTFactory.INSTANCE, PlainTextLanguage.INSTANCE, new PlainTextASTFactory());
-    registerParserDefinition(new PlainTextParserDefinition());
-
-    addExplicitExtension(FileTypeFileViewProviders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileViewProviderFactory());
-    addExplicitExtension(BinaryFileStubBuilders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileStubBuilder());
-
-    addExplicitExtension(LanguageASTFactory.INSTANCE, JavaLanguage.INSTANCE, new JavaASTFactory());
-    registerParserDefinition(new JavaParserDefinition());
-    addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE, JavaLanguage.INSTANCE, new PsiExpressionEvaluator());
-
-    addExtension(ContainerProvider.EP_NAME, new JavaContainerProvider());
-
-    myApplication.registerService(PsiPackageImplementationHelper.class, new CorePsiPackageImplementationHelper());
-    myApplication.registerService(PsiSubstitutorFactory.class, new PsiSubstitutorFactoryImpl());
-
-    myApplication.registerService(JavaDirectoryService.class, createJavaDirectoryService());
-    myApplication.registerService(JavaVersionService.class, new JavaVersionService());
-
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiPackage.class, new PackagePresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiClass.class, new ClassPresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiMethod.class, new MethodPresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiField.class, new FieldPresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiLocalVariable.class, new VariablePresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiParameter.class, new VariablePresentationProvider());
-
-    registerApplicationService(JavaCodeFoldingSettings.class, new JavaCodeFoldingSettingsBase());
-    addExplicitExtension(LanguageFolding.INSTANCE, JavaLanguage.INSTANCE, new JavaFoldingBuilderBase() {
-      @Override
-      protected boolean shouldShowExplicitLambdaType(@NotNull PsiAnonymousClass anonymousClass, @NotNull PsiNewExpression expression) {
-        return false;
-      }
-
-      @Override
-      protected boolean isBelowRightMargin(@NotNull PsiFile file, int lineLength) {
-        return false;
-      }
-    });
-
-    registerApplicationExtensionPoint(SuperMethodsSearch.EP_NAME, QueryExecutor.class);
-    addExtension(SuperMethodsSearch.EP_NAME, new MethodSuperSearcher());
-  }
-
-  // overridden in upsource
-  protected CoreJavaDirectoryService createJavaDirectoryService() {
-    return new CoreJavaDirectoryService();
-  }
-
-  @Nullable
-  @Override
-  protected VirtualFileSystem createJrtFileSystem() {
-    return new CoreJrtFileSystem();
-  }
+    @Nullable
+    @Override
+    protected VirtualFileSystem createJrtFileSystem() {
+        return new CoreJrtFileSystem();
+    }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java.193

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.cli.jvm.compiler;
+
+import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.JavaContainerProvider;
+import com.intellij.codeInsight.folding.JavaCodeFoldingSettings;
+import com.intellij.codeInsight.folding.impl.JavaCodeFoldingSettingsBase;
+import com.intellij.codeInsight.folding.impl.JavaFoldingBuilderBase;
+import com.intellij.codeInsight.runner.JavaMainMethodProvider;
+import com.intellij.core.CoreApplicationEnvironment;
+import com.intellij.core.CoreJavaDirectoryService;
+import com.intellij.core.CorePsiPackageImplementationHelper;
+import com.intellij.ide.highlighter.ArchiveFileType;
+import com.intellij.ide.highlighter.JavaClassFileType;
+import com.intellij.ide.highlighter.JavaFileType;
+import com.intellij.lang.LanguageASTFactory;
+import com.intellij.lang.MetaLanguage;
+import com.intellij.lang.folding.LanguageFolding;
+import com.intellij.lang.java.JavaLanguage;
+import com.intellij.lang.java.JavaParserDefinition;
+import com.intellij.navigation.ItemPresentationProviders;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.extensions.ExtensionsArea;
+import com.intellij.openapi.fileTypes.FileTypeExtensionPoint;
+import com.intellij.openapi.fileTypes.PlainTextFileType;
+import com.intellij.openapi.fileTypes.PlainTextLanguage;
+import com.intellij.openapi.fileTypes.PlainTextParserDefinition;
+import com.intellij.openapi.projectRoots.JavaVersionService;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.*;
+import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.augment.TypeAnnotationModifier;
+import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.impl.LanguageConstantExpressionEvaluator;
+import com.intellij.psi.impl.PsiExpressionEvaluator;
+import com.intellij.psi.impl.PsiSubstitutorFactoryImpl;
+import com.intellij.psi.impl.compiled.ClassFileStubBuilder;
+import com.intellij.psi.impl.file.PsiPackageImplementationHelper;
+import com.intellij.psi.impl.search.MethodSuperSearcher;
+import com.intellij.psi.impl.source.tree.JavaASTFactory;
+import com.intellij.psi.impl.source.tree.PlainTextASTFactory;
+import com.intellij.psi.meta.MetaDataContributor;
+import com.intellij.psi.presentation.java.*;
+import com.intellij.psi.search.searches.SuperMethodsSearch;
+import com.intellij.psi.stubs.BinaryFileStubBuilders;
+import com.intellij.util.QueryExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
+
+/**
+ * adapted from com.intellij.core.JavaCoreApplicationEnvironment
+ * TODO: initiate removal original from com.intellij.core since it seems that there are no usages left
+ */
+public class KotlinCoreApplicationEnvironment extends CoreApplicationEnvironment {
+
+  public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+  }
+
+  private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    super(parentDisposable, unitTestMode);
+
+    registerExtensionPoints();
+
+    registerExtensions();
+  }
+
+  private void registerExtensionPoints() {
+    ExtensionsArea area = Extensions.getRootArea();
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage.class);
+
+    IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(area);
+  }
+
+  private void registerExtensions() {
+    registerFileType(JavaClassFileType.INSTANCE, "class");
+    registerFileType(JavaFileType.INSTANCE, "java");
+    registerFileType(ArchiveFileType.INSTANCE, "jar;zip");
+    registerFileType(PlainTextFileType.INSTANCE, "txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");
+
+    addExplicitExtension(LanguageASTFactory.INSTANCE, PlainTextLanguage.INSTANCE, new PlainTextASTFactory());
+    registerParserDefinition(new PlainTextParserDefinition());
+
+    addExplicitExtension(FileTypeFileViewProviders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileViewProviderFactory());
+    addExplicitExtension(BinaryFileStubBuilders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileStubBuilder());
+
+    addExplicitExtension(LanguageASTFactory.INSTANCE, JavaLanguage.INSTANCE, new JavaASTFactory());
+    registerParserDefinition(new JavaParserDefinition());
+    addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE, JavaLanguage.INSTANCE, new PsiExpressionEvaluator());
+
+    addExtension(ContainerProvider.EP_NAME, new JavaContainerProvider());
+
+    myApplication.registerService(PsiPackageImplementationHelper.class, new CorePsiPackageImplementationHelper());
+    myApplication.registerService(PsiSubstitutorFactory.class, new PsiSubstitutorFactoryImpl());
+
+    myApplication.registerService(JavaDirectoryService.class, createJavaDirectoryService());
+    myApplication.registerService(JavaVersionService.class, new JavaVersionService());
+
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiPackage.class, new PackagePresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiClass.class, new ClassPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiMethod.class, new MethodPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiField.class, new FieldPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiLocalVariable.class, new VariablePresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiParameter.class, new VariablePresentationProvider());
+
+    registerApplicationService(JavaCodeFoldingSettings.class, new JavaCodeFoldingSettingsBase());
+    addExplicitExtension(LanguageFolding.INSTANCE, JavaLanguage.INSTANCE, new JavaFoldingBuilderBase() {
+      @Override
+      protected boolean shouldShowExplicitLambdaType(@NotNull PsiAnonymousClass anonymousClass, @NotNull PsiNewExpression expression) {
+        return false;
+      }
+
+      @Override
+      protected boolean isBelowRightMargin(@NotNull PsiFile file, int lineLength) {
+        return false;
+      }
+    });
+
+    registerApplicationExtensionPoint(SuperMethodsSearch.EP_NAME, QueryExecutor.class);
+    addExtension(SuperMethodsSearch.EP_NAME, new MethodSuperSearcher());
+  }
+
+  // overridden in upsource
+  protected CoreJavaDirectoryService createJavaDirectoryService() {
+    return new CoreJavaDirectoryService();
+  }
+
+  @Nullable
+  @Override
+  protected VirtualFileSystem createJrtFileSystem() {
+    return new CoreJrtFileSystem();
+  }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockExternalAnnotationsManager.kt

@@ -22,6 +22,7 @@ import com.intellij.psi.*
 
 class MockExternalAnnotationsManager : ExternalAnnotationsManager() {
     override fun chooseAnnotationsPlace(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+    override fun chooseAnnotationsPlaceNoUi(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
 
     override fun isExternalAnnotationWritable(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean = false
     override fun isExternalAnnotation(annotation: PsiAnnotation): Boolean = false

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockExternalAnnotationsManager.kt.193

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+import com.intellij.codeInsight.ExternalAnnotationsManager
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.*
+
+class MockExternalAnnotationsManager : ExternalAnnotationsManager() {
+    override fun chooseAnnotationsPlace(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+
+    override fun isExternalAnnotationWritable(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean = false
+    override fun isExternalAnnotation(annotation: PsiAnnotation): Boolean = false
+
+    override fun findExternalAnnotationsFiles(listOwner: PsiModifierListOwner): List<PsiFile>? = null
+    override fun findExternalAnnotation(listOwner: PsiModifierListOwner, annotationFQN: String): PsiAnnotation? = null
+    override fun findExternalAnnotations(listOwner: PsiModifierListOwner): Array<out PsiAnnotation>? = null
+
+    override fun annotateExternally(
+        listOwner: PsiModifierListOwner,
+        annotationFQName: String,
+        fromFile: PsiFile,
+        value: Array<out PsiNameValuePair>?
+    ) {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun deannotate(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun editExternalAnnotation(
+        listOwner: PsiModifierListOwner,
+        annotationFQN: String,
+        value: Array<out PsiNameValuePair>?
+    ): Boolean {
+        throw UnsupportedOperationException("not implemented")
+    }
+
+    override fun hasAnnotationRootsForFile(file: VirtualFile): Boolean = false
+
+    override fun findDefaultConstructorExternalAnnotations(aClass: PsiClass, annotationFQN: String): List<PsiAnnotation> = emptyList()
+
+    override fun findDefaultConstructorExternalAnnotations(aClass: PsiClass): List<PsiAnnotation> = emptyList()
+
+    override fun findExternalAnnotations(listOwner: PsiModifierListOwner, annotationFQN: String): List<PsiAnnotation> = emptyList()
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/compat.kt

@@ -6,4 +6,10 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 fun setupIdeaStandaloneExecution() {
+    System.getProperties().setProperty("idea.plugins.compatible.build", "201.6668.13")
+    System.getProperties().setProperty("project.structure.add.tools.jar.to.new.jdk", "false")
+    System.getProperties().setProperty("psi.track.invalidation", "true")
+    System.getProperties().setProperty("psi.incremental.reparse.depth.limit", "1000")
+    System.getProperties().setProperty("ide.hide.excluded.files", "false")
+    System.getProperties().setProperty("ast.loading.filter", "false")
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/compat.kt.193

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+fun setupIdeaStandaloneExecution() {
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/coreApplicationEnvironmentCompat.kt

@@ -8,9 +8,11 @@ package org.jetbrains.kotlin.cli.jvm.compiler
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.openapi.extensions.ExtensionsArea
 import java.io.File
+import java.nio.file.FileSystems
 
 // BUNCH: 193
 fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
+    val pluginRoot = FileSystems.getDefault().getPath(pluginFile.path)
     @Suppress("MissingRecentApi")
-    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, fileName, area)
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/coreApplicationEnvironmentCompat.kt.193

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler
+
+import com.intellij.core.CoreApplicationEnvironment
+import com.intellij.openapi.extensions.ExtensionsArea
+import java.io.File
+
+// BUNCH: 193
+fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
+    @Suppress("MissingRecentApi")
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
+}

compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.test.testFramework;
 
+import com.intellij.codeInsight.CodeInsightSettings;
+import com.intellij.concurrency.IdeaForkJoinWorkerThreadFactory;
 import com.intellij.diagnostic.PerformanceWatcher;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.Application;
@@ -23,20 +25,33 @@ import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.application.impl.ApplicationInfoImpl;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.fileTypes.StdFileTypes;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.IconLoader;
 import com.intellij.openapi.util.JDOMUtil;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.*;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VfsUtilCore;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileVisitor;
+import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.impl.DocumentCommitProcessor;
+import com.intellij.psi.impl.DocumentCommitThread;
+import com.intellij.psi.impl.source.PostprocessReformattingAspect;
 import com.intellij.rt.execution.junit.FileComparisonFailure;
 import com.intellij.testFramework.*;
 import com.intellij.testFramework.exceptionCases.AbstractExceptionCase;
-import com.intellij.util.Consumer;
-import com.intellij.util.ReflectionUtil;
+import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
+import com.intellij.util.*;
 import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.containers.hash.HashMap;
+import com.intellij.util.containers.PeekableIterator;
+import com.intellij.util.containers.PeekableIteratorWrapper;
+import com.intellij.util.indexing.FileBasedIndex;
+import com.intellij.util.indexing.FileBasedIndexImpl;
 import com.intellij.util.lang.CompoundRuntimeException;
 import com.intellij.util.ui.UIUtil;
 import gnu.trove.Equality;
@@ -47,11 +62,11 @@ import org.jdom.Element;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.test.IdeaSystemPropertiesForParallelRunConfigurator;
 import org.jetbrains.kotlin.testFramework.MockComponentManagerCreationTracer;
 import org.jetbrains.kotlin.types.AbstractTypeChecker;
 import org.jetbrains.kotlin.types.FlexibleTypeImpl;
 import org.junit.Assert;
+import org.junit.ComparisonFailure;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -61,14 +76,19 @@ import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
 
-@SuppressWarnings("UseOfSystemOutOrSystemErr")
+/**
+ * @author peter
+ */
+@SuppressWarnings("ALL")
 public abstract class KtUsefulTestCase extends TestCase {
     public static final boolean IS_UNDER_TEAMCITY = System.getenv("TEAMCITY_VERSION") != null;
-    private static final String TEMP_DIR_MARKER = "unitTest_";
+    public static final String TEMP_DIR_MARKER = "unitTest_";
     public static final boolean OVERWRITE_TESTDATA = Boolean.getBoolean("idea.tests.overwrite.data");
 
     private static final String ORIGINAL_TEMP_DIR = FileUtil.getTempDirectory();
@@ -79,24 +99,34 @@ public abstract class KtUsefulTestCase extends TestCase {
     private Application application;
 
     static {
-        IdeaSystemPropertiesForParallelRunConfigurator.setProperties();
-        //TODO: investigate and enable
-        //IdeaForkJoinWorkerThreadFactory.setupPoisonFactory();
+        IdeaForkJoinWorkerThreadFactory.setupPoisonFactory();
         Logger.setFactory(TestLoggerFactory.class);
     }
+    protected static final Logger LOG = Logger.getInstance(KtUsefulTestCase.class);
 
     @NotNull
-    protected final Disposable myTestRootDisposable = new TestDisposable();
+    private final Disposable myTestRootDisposable = new TestDisposable();
 
-    private static final String ourPathToKeep = null;
+    static Path ourPathToKeep;
     private final List<String> myPathsToKeep = new ArrayList<>();
 
-    private File myTempDir;
+    private String myTempDir;
 
+    private static final String DEFAULT_SETTINGS_EXTERNALIZED;
+    private static final CodeInsightSettings defaultSettings = new CodeInsightSettings();
     static {
         // Radar #5755208: Command line Java applications need a way to launch without a Dock icon.
         System.setProperty("apple.awt.UIElement", "true");
 
+        try {
+            Element oldS = new Element("temp");
+            defaultSettings.writeExternal(oldS);
+            DEFAULT_SETTINGS_EXTERNALIZED = JDOMUtil.writeElement(oldS);
+        }
+        catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
         // -- KOTLIN ADDITIONAL START --
 
         FlexibleTypeImpl.RUN_SLOW_ASSERTIONS = true;
@@ -105,6 +135,42 @@ public abstract class KtUsefulTestCase extends TestCase {
         // -- KOTLIN ADDITIONAL END --
     }
 
+    /**
+     * Pass here the exception you want to be thrown first
+     * E.g.<pre>
+     * {@code
+     *   void tearDown() {
+     *     try {
+     *       doTearDowns();
+     *     }
+     *     catch(Exception e) {
+     *       addSuppressedException(e);
+     *     }
+     *     finally {
+     *       super.tearDown();
+     *     }
+     *   }
+     * }
+     * </pre>
+     *
+     */
+    protected void addSuppressedException(@NotNull Throwable e) {
+        List<Throwable> list = mySuppressedExceptions;
+        if (list == null) {
+            mySuppressedExceptions = list = new SmartList<>();
+        }
+        list.add(e);
+    }
+    private List<Throwable> mySuppressedExceptions;
+
+
+    public KtUsefulTestCase() {
+    }
+
+    public KtUsefulTestCase(@NotNull String name) {
+        super(name);
+    }
+
     protected boolean shouldContainTempFiles() {
         return true;
     }
@@ -122,11 +188,17 @@ public abstract class KtUsefulTestCase extends TestCase {
         super.setUp();
 
         if (shouldContainTempFiles()) {
-            String testName =  FileUtil.sanitizeFileName(getTestName(true));
-            if (StringUtil.isEmptyOrSpaces(testName)) testName = "";
+            IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
+            String testName = null;
+            if (policy != null) {
+                testName = policy.getPerTestTempDirName();
+            }
+            if (testName == null) {
+                testName = FileUtil.sanitizeFileName(getTestName(true));
+            }
             testName = new File(testName).getName(); // in case the test name contains file separators
-            myTempDir = FileUtil.createTempDirectory(TEMP_DIR_MARKER, testName, false);
-            FileUtil.resetCanonicalTempPathCache(myTempDir.getPath());
+            myTempDir = FileUtil.createTempDirectory(TEMP_DIR_MARKER + testName, "", false).getPath();
+            FileUtil.resetCanonicalTempPathCache(myTempDir);
         }
 
         boolean isStressTest = isStressTest();
@@ -137,6 +209,16 @@ public abstract class KtUsefulTestCase extends TestCase {
 
         // turn off Disposer debugging for performance tests
         Disposer.setDebugMode(!isStressTest);
+
+        if (isIconRequired()) {
+            // ensure that IconLoader will use dummy empty icon
+            IconLoader.deactivate();
+            //IconManager.activate();
+        }
+    }
+
+    protected boolean isIconRequired() {
+        return false;
     }
 
     @Override
@@ -145,6 +227,11 @@ public abstract class KtUsefulTestCase extends TestCase {
             // don't use method references here to make stack trace reading easier
             //noinspection Convert2MethodRef
             new RunAll(
+                    () -> {
+                        if (isIconRequired()) {
+                            //IconManager.deactivate();
+                        }
+                    },
                     () -> disposeRootDisposable(),
                     () -> cleanupSwingDataStructures(),
                     () -> cleanupDeleteOnExitHookList(),
@@ -153,7 +240,7 @@ public abstract class KtUsefulTestCase extends TestCase {
                         if (shouldContainTempFiles()) {
                             FileUtil.resetCanonicalTempPathCache(ORIGINAL_TEMP_DIR);
                             if (hasTmpFilesToKeep()) {
-                                File[] files = myTempDir.listFiles();
+                                File[] files = new File(myTempDir).listFiles();
                                 if (files != null) {
                                     for (File file : files) {
                                         if (!shouldKeepTmpFile(file)) {
@@ -163,15 +250,14 @@ public abstract class KtUsefulTestCase extends TestCase {
                                 }
                             }
                             else {
-                                FileUtil.delete(myTempDir);
+                                FileUtil.delete(new File(myTempDir));
                             }
                         }
                     },
-                    () -> UIUtil.removeLeakingAppleListeners()
-            ).run();
+                    () -> waitForAppLeakingThreads(10, TimeUnit.SECONDS)
+            ).run(ObjectUtils.notNull(mySuppressedExceptions, Collections.emptyList()));
         }
         finally {
-            super.tearDown();
             // -- KOTLIN ADDITIONAL START --
             TestApplicationUtilKt.resetApplicationToNull(application);
             application = null;
@@ -188,12 +274,12 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     private boolean hasTmpFilesToKeep() {
-        return ourPathToKeep != null && FileUtil.isAncestor(myTempDir.getPath(), ourPathToKeep, false) || !myPathsToKeep.isEmpty();
+        return ourPathToKeep != null && FileUtil.isAncestor(myTempDir, ourPathToKeep.toString(), false) || !myPathsToKeep.isEmpty();
     }
 
     private boolean shouldKeepTmpFile(@NotNull File file) {
         String path = file.getPath();
-        if (FileUtil.pathsEqual(path, ourPathToKeep)) return true;
+        if (FileUtil.pathsEqual(path, ourPathToKeep.toString())) return true;
         for (String pathToKeep : myPathsToKeep) {
             if (FileUtil.pathsEqual(path, pathToKeep)) return true;
         }
@@ -201,7 +287,7 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     private static final Set<String> DELETE_ON_EXIT_HOOK_DOT_FILES;
-    private static final Class DELETE_ON_EXIT_HOOK_CLASS;
+    private static final Class<?> DELETE_ON_EXIT_HOOK_CLASS;
     static {
         Class<?> aClass;
         try {
@@ -237,12 +323,45 @@ public abstract class KtUsefulTestCase extends TestCase {
     @SuppressWarnings("ConstantConditions")
     private static void cleanupSwingDataStructures() throws Exception {
         Object manager = ReflectionUtil.getDeclaredMethod(Class.forName("javax.swing.KeyboardManager"), "getCurrentManager").invoke(null);
-        Map componentKeyStrokeMap = ReflectionUtil.getField(manager.getClass(), manager, Hashtable.class, "componentKeyStrokeMap");
+        Map<?, ?> componentKeyStrokeMap = ReflectionUtil.getField(manager.getClass(), manager, Hashtable.class, "componentKeyStrokeMap");
         componentKeyStrokeMap.clear();
-        Map containerMap = ReflectionUtil.getField(manager.getClass(), manager, Hashtable.class, "containerMap");
+        Map<?, ?> containerMap = ReflectionUtil.getField(manager.getClass(), manager, Hashtable.class, "containerMap");
         containerMap.clear();
     }
 
+    static void doCheckForSettingsDamage(@NotNull CodeStyleSettings oldCodeStyleSettings, @NotNull CodeStyleSettings currentCodeStyleSettings) {
+        final CodeInsightSettings settings = CodeInsightSettings.getInstance();
+        // don't use method references here to make stack trace reading easier
+        //noinspection Convert2MethodRef
+        new RunAll()
+                .append(() -> {
+                    try {
+                        checkCodeInsightSettingsEqual(defaultSettings, settings);
+                    }
+                    catch (AssertionError error) {
+                        CodeInsightSettings clean = new CodeInsightSettings();
+                        for (Field field : clean.getClass().getFields()) {
+                            try {
+                                ReflectionUtil.copyFieldValue(clean, settings, field);
+                            }
+                            catch (Exception ignored) {
+                            }
+                        }
+                        throw error;
+                    }
+                })
+                .append(() -> {
+                    currentCodeStyleSettings.getIndentOptions(StdFileTypes.JAVA);
+                    try {
+                        checkCodeStyleSettingsEqual(oldCodeStyleSettings, currentCodeStyleSettings);
+                    }
+                    finally {
+                        currentCodeStyleSettings.clearCodeStyleSettings();
+                    }
+                })
+                .run();
+    }
+
     @NotNull
     public Disposable getTestRootDisposable() {
         return myTestRootDisposable;
@@ -252,13 +371,11 @@ public abstract class KtUsefulTestCase extends TestCase {
     protected void runTest() throws Throwable {
         final Throwable[] throwables = new Throwable[1];
 
-        AtomicBoolean completed = new AtomicBoolean(false);
         Runnable runnable = () -> {
             try {
-                //TestLoggerFactory.onTestStarted();
+                TestLoggerFactory.onTestStarted();
                 super.runTest();
                 TestLoggerFactory.onTestFinished(true);
-                completed.set(true);
             }
             catch (InvocationTargetException e) {
                 TestLoggerFactory.onTestFinished(false);
@@ -281,9 +398,6 @@ public abstract class KtUsefulTestCase extends TestCase {
         if (throwables[0] != null) {
             throw throwables[0];
         }
-        if (!completed.get()) {
-            throw new IllegalStateException("test didn't start");
-        }
     }
 
     protected boolean shouldRunTest() {
@@ -291,19 +405,18 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     protected void invokeTestRunnable(@NotNull Runnable runnable) throws Exception {
-        //IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
-        //if (policy != null && !policy.runInDispatchThread()) {
-        //    runnable.run();
-        //}
-        //else {
+        if (runInDispatchThread()) {
             EdtTestUtilKt.runInEdtAndWait(() -> {
                 runnable.run();
                 return null;
             });
-        //}
+        }
+        else {
+            runnable.run();
+        }
     }
 
-    private void defaultRunBare() throws Throwable {
+    protected void defaultRunBare() throws Throwable {
         Throwable exception = null;
         try {
             long setupStart = System.nanoTime();
@@ -324,11 +437,17 @@ public abstract class KtUsefulTestCase extends TestCase {
                 logPerClassCost(teardownCost, TOTAL_TEARDOWN_COST_MILLIS);
             }
             catch (Throwable tearingDown) {
-                if (exception == null) exception = tearingDown;
-                else exception = new CompoundRuntimeException(Arrays.asList(exception, tearingDown));
+                if (exception == null) {
+                    exception = tearingDown;
+                }
+                else {
+                    exception = new CompoundRuntimeException(Arrays.asList(exception, tearingDown));
+                }
             }
         }
-        if (exception != null) throw exception;
+        if (exception != null) {
+            throw exception;
+        }
     }
 
     /**
@@ -368,7 +487,7 @@ public abstract class KtUsefulTestCase extends TestCase {
 
         if (runInDispatchThread()) {
             TestRunnerUtil.replaceIdeEventQueueSafely();
-            com.intellij.testFramework.EdtTestUtil.runInEdtAndWait(this::defaultRunBare);
+            EdtTestUtil.runInEdtAndWait(this::defaultRunBare);
         }
         else {
             defaultRunBare();
@@ -376,13 +495,20 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     protected boolean runInDispatchThread() {
-        //IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
-        //if (policy != null) {
-        //    return policy.runInDispatchThread();
-        //}
+        IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
+        if (policy != null) {
+            return policy.runInDispatchThread();
+        }
         return true;
     }
 
+    /**
+     * If you want a more shorter name than runInEdtAndWait.
+     */
+    protected void edt(@NotNull ThrowableRunnable<Throwable> runnable) {
+        EdtTestUtil.runInEdtAndWait(runnable);
+    }
+
     @NotNull
     public static String toString(@NotNull Iterable<?> collection) {
         if (!collection.iterator().hasNext()) {
@@ -515,9 +641,20 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     public static <T> void assertContainsOrdered(@NotNull Collection<? extends T> collection, @NotNull Collection<? extends T> expected) {
-        ArrayList<T> copy = new ArrayList<>(collection);
-        copy.retainAll(expected);
-        assertOrderedEquals(toString(collection), copy, expected);
+        PeekableIterator<T> expectedIt = new PeekableIteratorWrapper<>(expected.iterator());
+        PeekableIterator<T> actualIt = new PeekableIteratorWrapper<>(collection.iterator());
+
+        while (actualIt.hasNext() && expectedIt.hasNext()) {
+            T expectedElem = expectedIt.peek();
+            T actualElem = actualIt.peek();
+            if (expectedElem.equals(actualElem)) {
+                expectedIt.next();
+            }
+            actualIt.next();
+        }
+        if (expectedIt.hasNext()) {
+            throw new ComparisonFailure("", toString(expected), toString(collection));
+        }
     }
 
     @SafeVarargs
@@ -592,7 +729,7 @@ public abstract class KtUsefulTestCase extends TestCase {
         if (collection.size() != checkers.length) {
             Assert.fail(toString(collection));
         }
-        Set<Consumer<T>> checkerSet = new HashSet<>(Arrays.asList(checkers));
+        Set<Consumer<T>> checkerSet = ContainerUtil.set(checkers);
         int i = 0;
         Throwable lastError = null;
         for (final T actual : collection) {
@@ -767,7 +904,7 @@ public abstract class KtUsefulTestCase extends TestCase {
                 //noinspection UseOfSystemOutOrSystemErr
                 System.out.println("File " + filePath + " created.");
             }
-            fileText = FileUtil.loadFile(new File(filePath), CharsetToolkit.UTF8_CHARSET);
+            fileText = FileUtil.loadFile(new File(filePath), StandardCharsets.UTF_8);
         }
         catch (FileNotFoundException e) {
             VfsTestUtil.overwriteTestData(filePath, actualText);
@@ -784,14 +921,14 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     protected static void clearFields(@NotNull Object test) throws IllegalAccessException {
-        Class aClass = test.getClass();
+        Class<?> aClass = test.getClass();
         while (aClass != null) {
             clearDeclaredFields(test, aClass);
             aClass = aClass.getSuperclass();
         }
     }
 
-    public static void clearDeclaredFields(@NotNull Object test, @NotNull Class aClass) throws IllegalAccessException {
+    public static void clearDeclaredFields(@NotNull Object test, @NotNull Class<?> aClass) throws IllegalAccessException {
         for (final Field field : aClass.getDeclaredFields()) {
             final String name = field.getDeclaringClass().getName();
             if (!name.startsWith("junit.framework.") && !name.startsWith("com.intellij.testFramework.")) {
@@ -817,6 +954,14 @@ public abstract class KtUsefulTestCase extends TestCase {
         }
     }
 
+    private static void checkCodeInsightSettingsEqual(@NotNull CodeInsightSettings oldSettings, @NotNull CodeInsightSettings settings) {
+        if (!oldSettings.equals(settings)) {
+            Element newS = new Element("temp");
+            settings.writeExternal(newS);
+            Assert.assertEquals("Code insight settings damaged", DEFAULT_SETTINGS_EXTERNALIZED, JDOMUtil.writeElement(newS));
+        }
+    }
+
     public boolean isPerformanceTest() {
         String testName = getName();
         String className = getClass().getSimpleName();
@@ -843,6 +988,21 @@ public abstract class KtUsefulTestCase extends TestCase {
         return name != null && (name.contains("Stress") || name.contains("Slow"));
     }
 
+    public static void doPostponedFormatting(@NotNull Project project) {
+        DocumentUtil.writeInRunUndoTransparentAction(() -> {
+            PsiDocumentManager.getInstance(project).commitAllDocuments();
+            PostprocessReformattingAspect.getInstance(project).doPostponedFormatting();
+        });
+    }
+
+    /**
+     * Checks that code block throw corresponding exception.
+     *
+     * @param exceptionCase Block annotated with some exception type
+     */
+    protected void assertException(@NotNull AbstractExceptionCase<?> exceptionCase) {
+        assertException(exceptionCase, null);
+    }
 
     /**
      * Checks that code block throw corresponding exception with expected error msg.
@@ -856,6 +1016,42 @@ public abstract class KtUsefulTestCase extends TestCase {
         assertExceptionOccurred(true, exceptionCase, expectedErrorMsg);
     }
 
+    /**
+     * Checks that the code block throws an exception of the specified class.
+     *
+     * @param exceptionClass   Expected exception type
+     * @param runnable         Block annotated with some exception type
+     */
+    public static <T extends Throwable> void assertThrows(@NotNull Class<? extends Throwable> exceptionClass,
+            @NotNull ThrowableRunnable<T> runnable) {
+        assertThrows(exceptionClass, null, runnable);
+    }
+
+    /**
+     * Checks that the code block throws an exception of the specified class with expected error msg.
+     * If expected error message is null it will not be checked.
+     *
+     * @param exceptionClass   Expected exception type
+     * @param expectedErrorMsgPart expected error message, of any
+     * @param runnable         Block annotated with some exception type
+     */
+    @SuppressWarnings({"unchecked", "SameParameterValue"})
+    public static <T extends Throwable> void assertThrows(@NotNull Class<? extends Throwable> exceptionClass,
+            @Nullable String expectedErrorMsgPart,
+            @NotNull ThrowableRunnable<T> runnable) {
+        assertExceptionOccurred(true, new AbstractExceptionCase() {
+            @Override
+            public Class<Throwable> getExpectedExceptionClass() {
+                return (Class<Throwable>)exceptionClass;
+            }
+
+            @Override
+            public void tryClosure() throws Throwable {
+                runnable.run();
+            }
+        }, expectedErrorMsgPart);
+    }
+
     /**
      * Checks that code block doesn't throw corresponding exception.
      *
@@ -878,21 +1074,23 @@ public abstract class KtUsefulTestCase extends TestCase {
 
     private static <T extends Throwable> void assertExceptionOccurred(boolean shouldOccur,
             @NotNull AbstractExceptionCase<T> exceptionCase,
-            String expectedErrorMsg) throws T {
+            String expectedErrorMsgPart) throws T {
         boolean wasThrown = false;
         try {
             exceptionCase.tryClosure();
         }
         catch (Throwable e) {
+            Throwable cause = e;
+
             if (shouldOccur) {
                 wasThrown = true;
                 final String errorMessage = exceptionCase.getAssertionErrorMessage();
-                assertEquals(errorMessage, exceptionCase.getExpectedExceptionClass(), e.getClass());
-                if (expectedErrorMsg != null) {
-                    assertEquals("Compare error messages", expectedErrorMsg, e.getMessage());
+                assertEquals(errorMessage, exceptionCase.getExpectedExceptionClass(), cause.getClass());
+                if (expectedErrorMsgPart != null) {
+                    assertTrue(cause.getMessage(), cause.getMessage().contains(expectedErrorMsgPart));
                 }
             }
-            else if (exceptionCase.getExpectedExceptionClass().equals(e.getClass())) {
+            else if (exceptionCase.getExpectedExceptionClass().equals(cause.getClass())) {
                 wasThrown = true;
 
                 //noinspection UseOfSystemOutOrSystemErr
@@ -900,7 +1098,7 @@ public abstract class KtUsefulTestCase extends TestCase {
                 //noinspection UseOfSystemOutOrSystemErr
                 e.printStackTrace(System.out);
 
-                fail("Exception isn't expected here. Exception message: " + e.getMessage());
+                fail("Exception isn't expected here. Exception message: " + cause.getMessage());
             }
             else {
                 throw e;
@@ -937,7 +1135,7 @@ public abstract class KtUsefulTestCase extends TestCase {
     }
 
     public static void refreshRecursively(@NotNull VirtualFile file) {
-        VfsUtilCore.visitChildrenRecursively(file, new VirtualFileVisitor() {
+        VfsUtilCore.visitChildrenRecursively(file, new VirtualFileVisitor<Void>() {
             @Override
             public boolean visitFile(@NotNull VirtualFile file) {
                 file.getChildren();
@@ -947,11 +1145,27 @@ public abstract class KtUsefulTestCase extends TestCase {
         file.refresh(false, true);
     }
 
-    @Nullable
     public static VirtualFile refreshAndFindFile(@NotNull final File file) {
         return UIUtil.invokeAndWaitIfNeeded(() -> LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file));
     }
 
+    public static void waitForAppLeakingThreads(long timeout, @NotNull TimeUnit timeUnit) {
+        EdtTestUtil.runInEdtAndWait(() -> {
+            Application app = ApplicationManager.getApplication();
+            if (app != null && !app.isDisposed()) {
+                FileBasedIndexImpl index = (FileBasedIndexImpl)app.getServiceIfCreated(FileBasedIndex.class);
+                if (index != null) {
+                    index.getChangedFilesCollector().waitForVfsEventsExecuted(timeout, timeUnit);
+                }
+
+                DocumentCommitThread commitThread = (DocumentCommitThread)app.getServiceIfCreated(DocumentCommitProcessor.class);
+                if (commitThread != null) {
+                    commitThread.waitForAllCommits(timeout, timeUnit);
+                }
+            }
+        });
+    }
+
     protected class TestDisposable implements Disposable {
         private volatile boolean myDisposed;
 
@@ -972,5 +1186,5 @@ public abstract class KtUsefulTestCase extends TestCase {
             String testName = getTestName(false);
             return KtUsefulTestCase.this.getClass() + (StringUtil.isEmpty(testName) ? "" : ".test" + testName);
         }
-    };
-}
+    }
+}

compiler/tests-common/tests/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java.193

@@ -0,0 +1,976 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.test.testFramework;
+
+import com.intellij.diagnostic.PerformanceWatcher;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.Application;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.PathManager;
+import com.intellij.openapi.application.impl.ApplicationInfoImpl;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.JDOMUtil;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.*;
+import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.rt.execution.junit.FileComparisonFailure;
+import com.intellij.testFramework.*;
+import com.intellij.testFramework.exceptionCases.AbstractExceptionCase;
+import com.intellij.util.Consumer;
+import com.intellij.util.ReflectionUtil;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.hash.HashMap;
+import com.intellij.util.lang.CompoundRuntimeException;
+import com.intellij.util.ui.UIUtil;
+import gnu.trove.Equality;
+import gnu.trove.THashSet;
+import junit.framework.AssertionFailedError;
+import junit.framework.TestCase;
+import org.jdom.Element;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.test.IdeaSystemPropertiesForParallelRunConfigurator;
+import org.jetbrains.kotlin.testFramework.MockComponentManagerCreationTracer;
+import org.jetbrains.kotlin.types.AbstractTypeChecker;
+import org.jetbrains.kotlin.types.FlexibleTypeImpl;
+import org.junit.Assert;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+
+@SuppressWarnings("UseOfSystemOutOrSystemErr")
+public abstract class KtUsefulTestCase extends TestCase {
+    public static final boolean IS_UNDER_TEAMCITY = System.getenv("TEAMCITY_VERSION") != null;
+    private static final String TEMP_DIR_MARKER = "unitTest_";
+    public static final boolean OVERWRITE_TESTDATA = Boolean.getBoolean("idea.tests.overwrite.data");
+
+    private static final String ORIGINAL_TEMP_DIR = FileUtil.getTempDirectory();
+
+    private static final Map<String, Long> TOTAL_SETUP_COST_MILLIS = new HashMap<>();
+    private static final Map<String, Long> TOTAL_TEARDOWN_COST_MILLIS = new HashMap<>();
+
+    private Application application;
+
+    static {
+        IdeaSystemPropertiesForParallelRunConfigurator.setProperties();
+        //TODO: investigate and enable
+        //IdeaForkJoinWorkerThreadFactory.setupPoisonFactory();
+        Logger.setFactory(TestLoggerFactory.class);
+    }
+
+    @NotNull
+    protected final Disposable myTestRootDisposable = new TestDisposable();
+
+    private static final String ourPathToKeep = null;
+    private final List<String> myPathsToKeep = new ArrayList<>();
+
+    private File myTempDir;
+
+    static {
+        // Radar #5755208: Command line Java applications need a way to launch without a Dock icon.
+        System.setProperty("apple.awt.UIElement", "true");
+
+        // -- KOTLIN ADDITIONAL START --
+
+        FlexibleTypeImpl.RUN_SLOW_ASSERTIONS = true;
+        AbstractTypeChecker.RUN_SLOW_ASSERTIONS = true;
+
+        // -- KOTLIN ADDITIONAL END --
+    }
+
+    protected boolean shouldContainTempFiles() {
+        return true;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        // -- KOTLIN ADDITIONAL START --
+        application = ApplicationManager.getApplication();
+
+        if (application != null && application.isDisposed()) {
+            MockComponentManagerCreationTracer.diagnoseDisposedButNotClearedApplication(application);
+        }
+        // -- KOTLIN ADDITIONAL END --
+
+        super.setUp();
+
+        if (shouldContainTempFiles()) {
+            String testName =  FileUtil.sanitizeFileName(getTestName(true));
+            if (StringUtil.isEmptyOrSpaces(testName)) testName = "";
+            testName = new File(testName).getName(); // in case the test name contains file separators
+            myTempDir = FileUtil.createTempDirectory(TEMP_DIR_MARKER, testName, false);
+            FileUtil.resetCanonicalTempPathCache(myTempDir.getPath());
+        }
+
+        boolean isStressTest = isStressTest();
+        ApplicationInfoImpl.setInStressTest(isStressTest);
+        if (isPerformanceTest()) {
+            Timings.getStatistics();
+        }
+
+        // turn off Disposer debugging for performance tests
+        Disposer.setDebugMode(!isStressTest);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        try {
+            // don't use method references here to make stack trace reading easier
+            //noinspection Convert2MethodRef
+            new RunAll(
+                    () -> disposeRootDisposable(),
+                    () -> cleanupSwingDataStructures(),
+                    () -> cleanupDeleteOnExitHookList(),
+                    () -> Disposer.setDebugMode(true),
+                    () -> {
+                        if (shouldContainTempFiles()) {
+                            FileUtil.resetCanonicalTempPathCache(ORIGINAL_TEMP_DIR);
+                            if (hasTmpFilesToKeep()) {
+                                File[] files = myTempDir.listFiles();
+                                if (files != null) {
+                                    for (File file : files) {
+                                        if (!shouldKeepTmpFile(file)) {
+                                            FileUtil.delete(file);
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                FileUtil.delete(myTempDir);
+                            }
+                        }
+                    },
+                    () -> UIUtil.removeLeakingAppleListeners()
+            ).run();
+        }
+        finally {
+            super.tearDown();
+            // -- KOTLIN ADDITIONAL START --
+            TestApplicationUtilKt.resetApplicationToNull(application);
+            application = null;
+            // -- KOTLIN ADDITIONAL END --
+        }
+    }
+
+    protected final void disposeRootDisposable() {
+        Disposer.dispose(getTestRootDisposable());
+    }
+
+    protected void addTmpFileToKeep(@NotNull File file) {
+        myPathsToKeep.add(file.getPath());
+    }
+
+    private boolean hasTmpFilesToKeep() {
+        return ourPathToKeep != null && FileUtil.isAncestor(myTempDir.getPath(), ourPathToKeep, false) || !myPathsToKeep.isEmpty();
+    }
+
+    private boolean shouldKeepTmpFile(@NotNull File file) {
+        String path = file.getPath();
+        if (FileUtil.pathsEqual(path, ourPathToKeep)) return true;
+        for (String pathToKeep : myPathsToKeep) {
+            if (FileUtil.pathsEqual(path, pathToKeep)) return true;
+        }
+        return false;
+    }
+
+    private static final Set<String> DELETE_ON_EXIT_HOOK_DOT_FILES;
+    private static final Class DELETE_ON_EXIT_HOOK_CLASS;
+    static {
+        Class<?> aClass;
+        try {
+            aClass = Class.forName("java.io.DeleteOnExitHook");
+        }
+        catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+        @SuppressWarnings("unchecked") Set<String> files = ReflectionUtil.getStaticFieldValue(aClass, Set.class, "files");
+        DELETE_ON_EXIT_HOOK_CLASS = aClass;
+        DELETE_ON_EXIT_HOOK_DOT_FILES = files;
+    }
+
+    @SuppressWarnings("SynchronizeOnThis")
+    private static void cleanupDeleteOnExitHookList() {
+        // try to reduce file set retained by java.io.DeleteOnExitHook
+        List<String> list;
+        synchronized (DELETE_ON_EXIT_HOOK_CLASS) {
+            if (DELETE_ON_EXIT_HOOK_DOT_FILES.isEmpty()) return;
+            list = new ArrayList<>(DELETE_ON_EXIT_HOOK_DOT_FILES);
+        }
+        for (int i = list.size() - 1; i >= 0; i--) {
+            String path = list.get(i);
+            File file = new File(path);
+            if (file.delete() || !file.exists()) {
+                synchronized (DELETE_ON_EXIT_HOOK_CLASS) {
+                    DELETE_ON_EXIT_HOOK_DOT_FILES.remove(path);
+                }
+            }
+        }
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    private static void cleanupSwingDataStructures() throws Exception {
+        Object manager = ReflectionUtil.getDeclaredMethod(Class.forName("javax.swing.KeyboardManager"), "getCurrentManager").invoke(null);
+        Map componentKeyStrokeMap = ReflectionUtil.getField(manager.getClass(), manager, Hashtable.class, "componentKeyStrokeMap");
+        componentKeyStrokeMap.clear();
+        Map containerMap = ReflectionUtil.getField(manager.getClass(), manager, Hashtable.class, "containerMap");
+        containerMap.clear();
+    }
+
+    @NotNull
+    public Disposable getTestRootDisposable() {
+        return myTestRootDisposable;
+    }
+
+    @Override
+    protected void runTest() throws Throwable {
+        final Throwable[] throwables = new Throwable[1];
+
+        AtomicBoolean completed = new AtomicBoolean(false);
+        Runnable runnable = () -> {
+            try {
+                //TestLoggerFactory.onTestStarted();
+                super.runTest();
+                TestLoggerFactory.onTestFinished(true);
+                completed.set(true);
+            }
+            catch (InvocationTargetException e) {
+                TestLoggerFactory.onTestFinished(false);
+                e.fillInStackTrace();
+                throwables[0] = e.getTargetException();
+            }
+            catch (IllegalAccessException e) {
+                TestLoggerFactory.onTestFinished(false);
+                e.fillInStackTrace();
+                throwables[0] = e;
+            }
+            catch (Throwable e) {
+                TestLoggerFactory.onTestFinished(false);
+                throwables[0] = e;
+            }
+        };
+
+        invokeTestRunnable(runnable);
+
+        if (throwables[0] != null) {
+            throw throwables[0];
+        }
+        if (!completed.get()) {
+            throw new IllegalStateException("test didn't start");
+        }
+    }
+
+    protected boolean shouldRunTest() {
+        return TestFrameworkUtil.canRunTest(getClass());
+    }
+
+    protected void invokeTestRunnable(@NotNull Runnable runnable) throws Exception {
+        //IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
+        //if (policy != null && !policy.runInDispatchThread()) {
+        //    runnable.run();
+        //}
+        //else {
+            EdtTestUtilKt.runInEdtAndWait(() -> {
+                runnable.run();
+                return null;
+            });
+        //}
+    }
+
+    private void defaultRunBare() throws Throwable {
+        Throwable exception = null;
+        try {
+            long setupStart = System.nanoTime();
+            setUp();
+            long setupCost = (System.nanoTime() - setupStart) / 1000000;
+            logPerClassCost(setupCost, TOTAL_SETUP_COST_MILLIS);
+
+            runTest();
+        }
+        catch (Throwable running) {
+            exception = running;
+        }
+        finally {
+            try {
+                long teardownStart = System.nanoTime();
+                tearDown();
+                long teardownCost = (System.nanoTime() - teardownStart) / 1000000;
+                logPerClassCost(teardownCost, TOTAL_TEARDOWN_COST_MILLIS);
+            }
+            catch (Throwable tearingDown) {
+                if (exception == null) exception = tearingDown;
+                else exception = new CompoundRuntimeException(Arrays.asList(exception, tearingDown));
+            }
+        }
+        if (exception != null) throw exception;
+    }
+
+    /**
+     * Logs the setup cost grouped by test fixture class (superclass of the current test class).
+     *
+     * @param cost setup cost in milliseconds
+     */
+    private void logPerClassCost(long cost, @NotNull Map<String, Long> costMap) {
+        Class<?> superclass = getClass().getSuperclass();
+        Long oldCost = costMap.get(superclass.getName());
+        long newCost = oldCost == null ? cost : oldCost + cost;
+        costMap.put(superclass.getName(), newCost);
+    }
+
+    @SuppressWarnings("UseOfSystemOutOrSystemErr")
+    static void logSetupTeardownCosts() {
+        System.out.println("Setup costs");
+        long totalSetup = 0;
+        for (Map.Entry<String, Long> entry : TOTAL_SETUP_COST_MILLIS.entrySet()) {
+            System.out.println(String.format("  %s: %d ms", entry.getKey(), entry.getValue()));
+            totalSetup += entry.getValue();
+        }
+        System.out.println("Teardown costs");
+        long totalTeardown = 0;
+        for (Map.Entry<String, Long> entry : TOTAL_TEARDOWN_COST_MILLIS.entrySet()) {
+            System.out.println(String.format("  %s: %d ms", entry.getKey(), entry.getValue()));
+            totalTeardown += entry.getValue();
+        }
+        System.out.println(String.format("Total overhead: setup %d ms, teardown %d ms", totalSetup, totalTeardown));
+        System.out.println(String.format("##teamcity[buildStatisticValue key='ideaTests.totalSetupMs' value='%d']", totalSetup));
+        System.out.println(String.format("##teamcity[buildStatisticValue key='ideaTests.totalTeardownMs' value='%d']", totalTeardown));
+    }
+
+    @Override
+    public void runBare() throws Throwable {
+        if (!shouldRunTest()) return;
+
+        if (runInDispatchThread()) {
+            TestRunnerUtil.replaceIdeEventQueueSafely();
+            com.intellij.testFramework.EdtTestUtil.runInEdtAndWait(this::defaultRunBare);
+        }
+        else {
+            defaultRunBare();
+        }
+    }
+
+    protected boolean runInDispatchThread() {
+        //IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
+        //if (policy != null) {
+        //    return policy.runInDispatchThread();
+        //}
+        return true;
+    }
+
+    @NotNull
+    public static String toString(@NotNull Iterable<?> collection) {
+        if (!collection.iterator().hasNext()) {
+            return "<empty>";
+        }
+
+        final StringBuilder builder = new StringBuilder();
+        for (final Object o : collection) {
+            if (o instanceof THashSet) {
+                builder.append(new TreeSet<>((THashSet<?>)o));
+            }
+            else {
+                builder.append(o);
+            }
+            builder.append('\n');
+        }
+        return builder.toString();
+    }
+
+    @SafeVarargs
+    public static <T> void assertOrderedEquals(@NotNull T[] actual, @NotNull T... expected) {
+        assertOrderedEquals(Arrays.asList(actual), expected);
+    }
+
+    @SafeVarargs
+    public static <T> void assertOrderedEquals(@NotNull Iterable<? extends T> actual, @NotNull T... expected) {
+        assertOrderedEquals("", actual, expected);
+    }
+
+    public static void assertOrderedEquals(@NotNull byte[] actual, @NotNull byte[] expected) {
+        assertEquals(expected.length, actual.length);
+        for (int i = 0; i < actual.length; i++) {
+            byte a = actual[i];
+            byte e = expected[i];
+            assertEquals("not equals at index: "+i, e, a);
+        }
+    }
+
+    public static void assertOrderedEquals(@NotNull int[] actual, @NotNull int[] expected) {
+        if (actual.length != expected.length) {
+            fail("Expected size: "+expected.length+"; actual: "+actual.length+"\nexpected: "+Arrays.toString(expected)+"\nactual  : "+Arrays.toString(actual));
+        }
+        for (int i = 0; i < actual.length; i++) {
+            int a = actual[i];
+            int e = expected[i];
+            assertEquals("not equals at index: "+i, e, a);
+        }
+    }
+
+    @SafeVarargs
+    public static <T> void assertOrderedEquals(@NotNull String errorMsg, @NotNull Iterable<? extends T> actual, @NotNull T... expected) {
+        assertOrderedEquals(errorMsg, actual, Arrays.asList(expected));
+    }
+
+    public static <T> void assertOrderedEquals(@NotNull Iterable<? extends T> actual, @NotNull Iterable<? extends T> expected) {
+        assertOrderedEquals("", actual, expected);
+    }
+
+    public static <T> void assertOrderedEquals(@NotNull String errorMsg,
+            @NotNull Iterable<? extends T> actual,
+            @NotNull Iterable<? extends T> expected) {
+        //noinspection unchecked
+        assertOrderedEquals(errorMsg, actual, expected, Equality.CANONICAL);
+    }
+
+    public static <T> void assertOrderedEquals(@NotNull String errorMsg,
+            @NotNull Iterable<? extends T> actual,
+            @NotNull Iterable<? extends T> expected,
+            @NotNull Equality<? super T> comparator) {
+        if (!equals(actual, expected, comparator)) {
+            String expectedString = toString(expected);
+            String actualString = toString(actual);
+            Assert.assertEquals(errorMsg, expectedString, actualString);
+            Assert.fail("Warning! 'toString' does not reflect the difference.\nExpected: " + expectedString + "\nActual: " + actualString);
+        }
+    }
+
+    private static <T> boolean equals(@NotNull Iterable<? extends T> a1,
+            @NotNull Iterable<? extends T> a2,
+            @NotNull Equality<? super T> comparator) {
+        Iterator<? extends T> it1 = a1.iterator();
+        Iterator<? extends T> it2 = a2.iterator();
+        while (it1.hasNext() || it2.hasNext()) {
+            if (!it1.hasNext() || !it2.hasNext()) return false;
+            if (!comparator.equals(it1.next(), it2.next())) return false;
+        }
+        return true;
+    }
+
+    @SafeVarargs
+    public static <T> void assertOrderedCollection(@NotNull T[] collection, @NotNull Consumer<T>... checkers) {
+        assertOrderedCollection(Arrays.asList(collection), checkers);
+    }
+
+    /**
+     * Checks {@code actual} contains same elements (in {@link #equals(Object)} meaning) as {@code expected} irrespective of their order
+     */
+    @SafeVarargs
+    public static <T> void assertSameElements(@NotNull T[] actual, @NotNull T... expected) {
+        assertSameElements(Arrays.asList(actual), expected);
+    }
+
+    /**
+     * Checks {@code actual} contains same elements (in {@link #equals(Object)} meaning) as {@code expected} irrespective of their order
+     */
+    @SafeVarargs
+    public static <T> void assertSameElements(@NotNull Collection<? extends T> actual, @NotNull T... expected) {
+        assertSameElements(actual, Arrays.asList(expected));
+    }
+
+    /**
+     * Checks {@code actual} contains same elements (in {@link #equals(Object)} meaning) as {@code expected} irrespective of their order
+     */
+    public static <T> void assertSameElements(@NotNull Collection<? extends T> actual, @NotNull Collection<? extends T> expected) {
+        assertSameElements("", actual, expected);
+    }
+
+    /**
+     * Checks {@code actual} contains same elements (in {@link #equals(Object)} meaning) as {@code expected} irrespective of their order
+     */
+    public static <T> void assertSameElements(@NotNull String message, @NotNull Collection<? extends T> actual, @NotNull Collection<? extends T> expected) {
+        if (actual.size() != expected.size() || !new HashSet<>(expected).equals(new HashSet<T>(actual))) {
+            Assert.assertEquals(message, new HashSet<>(expected), new HashSet<T>(actual));
+        }
+    }
+
+    @SafeVarargs
+    public static <T> void assertContainsOrdered(@NotNull Collection<? extends T> collection, @NotNull T... expected) {
+        assertContainsOrdered(collection, Arrays.asList(expected));
+    }
+
+    public static <T> void assertContainsOrdered(@NotNull Collection<? extends T> collection, @NotNull Collection<? extends T> expected) {
+        ArrayList<T> copy = new ArrayList<>(collection);
+        copy.retainAll(expected);
+        assertOrderedEquals(toString(collection), copy, expected);
+    }
+
+    @SafeVarargs
+    public static <T> void assertContainsElements(@NotNull Collection<? extends T> collection, @NotNull T... expected) {
+        assertContainsElements(collection, Arrays.asList(expected));
+    }
+
+    public static <T> void assertContainsElements(@NotNull Collection<? extends T> collection, @NotNull Collection<? extends T> expected) {
+        ArrayList<T> copy = new ArrayList<>(collection);
+        copy.retainAll(expected);
+        assertSameElements(toString(collection), copy, expected);
+    }
+
+    @NotNull
+    public static String toString(@NotNull Object[] collection, @NotNull String separator) {
+        return toString(Arrays.asList(collection), separator);
+    }
+
+    @SafeVarargs
+    public static <T> void assertDoesntContain(@NotNull Collection<? extends T> collection, @NotNull T... notExpected) {
+        assertDoesntContain(collection, Arrays.asList(notExpected));
+    }
+
+    public static <T> void assertDoesntContain(@NotNull Collection<? extends T> collection, @NotNull Collection<? extends T> notExpected) {
+        ArrayList<T> expected = new ArrayList<>(collection);
+        expected.removeAll(notExpected);
+        assertSameElements(collection, expected);
+    }
+
+    @NotNull
+    public static String toString(@NotNull Collection<?> collection, @NotNull String separator) {
+        List<String> list = ContainerUtil.map2List(collection, String::valueOf);
+        Collections.sort(list);
+        StringBuilder builder = new StringBuilder();
+        boolean flag = false;
+        for (final String o : list) {
+            if (flag) {
+                builder.append(separator);
+            }
+            builder.append(o);
+            flag = true;
+        }
+        return builder.toString();
+    }
+
+    @SafeVarargs
+    public static <T> void assertOrderedCollection(@NotNull Collection<? extends T> collection, @NotNull Consumer<T>... checkers) {
+        if (collection.size() != checkers.length) {
+            Assert.fail(toString(collection));
+        }
+        int i = 0;
+        for (final T actual : collection) {
+            try {
+                checkers[i].consume(actual);
+            }
+            catch (AssertionFailedError e) {
+                //noinspection UseOfSystemOutOrSystemErr
+                System.out.println(i + ": " + actual);
+                throw e;
+            }
+            i++;
+        }
+    }
+
+    @SafeVarargs
+    public static <T> void assertUnorderedCollection(@NotNull T[] collection, @NotNull Consumer<T>... checkers) {
+        assertUnorderedCollection(Arrays.asList(collection), checkers);
+    }
+
+    @SafeVarargs
+    public static <T> void assertUnorderedCollection(@NotNull Collection<? extends T> collection, @NotNull Consumer<T>... checkers) {
+        if (collection.size() != checkers.length) {
+            Assert.fail(toString(collection));
+        }
+        Set<Consumer<T>> checkerSet = new HashSet<>(Arrays.asList(checkers));
+        int i = 0;
+        Throwable lastError = null;
+        for (final T actual : collection) {
+            boolean flag = true;
+            for (final Consumer<T> condition : checkerSet) {
+                Throwable error = accepts(condition, actual);
+                if (error == null) {
+                    checkerSet.remove(condition);
+                    flag = false;
+                    break;
+                }
+                else {
+                    lastError = error;
+                }
+            }
+            if (flag) {
+                //noinspection ConstantConditions,CallToPrintStackTrace
+                lastError.printStackTrace();
+                Assert.fail("Incorrect element(" + i + "): " + actual);
+            }
+            i++;
+        }
+    }
+
+    private static <T> Throwable accepts(@NotNull Consumer<? super T> condition, final T actual) {
+        try {
+            condition.consume(actual);
+            return null;
+        }
+        catch (Throwable e) {
+            return e;
+        }
+    }
+
+    @Contract("null, _ -> fail")
+    @NotNull
+    public static <T> T assertInstanceOf(Object o, @NotNull Class<T> aClass) {
+        Assert.assertNotNull("Expected instance of: " + aClass.getName() + " actual: " + null, o);
+        Assert.assertTrue("Expected instance of: " + aClass.getName() + " actual: " + o.getClass().getName(), aClass.isInstance(o));
+        @SuppressWarnings("unchecked") T t = (T)o;
+        return t;
+    }
+
+    public static <T> T assertOneElement(@NotNull Collection<? extends T> collection) {
+        Iterator<? extends T> iterator = collection.iterator();
+        String toString = toString(collection);
+        Assert.assertTrue(toString, iterator.hasNext());
+        T t = iterator.next();
+        Assert.assertFalse(toString, iterator.hasNext());
+        return t;
+    }
+
+    public static <T> T assertOneElement(@NotNull T[] ts) {
+        Assert.assertEquals(Arrays.asList(ts).toString(), 1, ts.length);
+        return ts[0];
+    }
+
+    @SafeVarargs
+    public static <T> void assertOneOf(T value, @NotNull T... values) {
+        for (T v : values) {
+            if (Objects.equals(value, v)) {
+                return;
+            }
+        }
+        Assert.fail(value + " should be equal to one of " + Arrays.toString(values));
+    }
+
+    public static void printThreadDump() {
+        PerformanceWatcher.dumpThreadsToConsole("Thread dump:");
+    }
+
+    public static void assertEmpty(@NotNull Object[] array) {
+        assertOrderedEquals(array);
+    }
+
+    public static void assertNotEmpty(final Collection<?> collection) {
+        assertNotNull(collection);
+        assertFalse(collection.isEmpty());
+    }
+
+    public static void assertEmpty(@NotNull Collection<?> collection) {
+        assertEmpty(collection.toString(), collection);
+    }
+
+    public static void assertNullOrEmpty(@Nullable Collection<?> collection) {
+        if (collection == null) return;
+        assertEmpty("", collection);
+    }
+
+    public static void assertEmpty(final String s) {
+        assertTrue(s, StringUtil.isEmpty(s));
+    }
+
+    public static <T> void assertEmpty(@NotNull String errorMsg, @NotNull Collection<? extends T> collection) {
+        assertOrderedEquals(errorMsg, collection, Collections.emptyList());
+    }
+
+    public static void assertSize(int expectedSize, @NotNull Object[] array) {
+        if (array.length != expectedSize) {
+            assertEquals(toString(Arrays.asList(array)), expectedSize, array.length);
+        }
+    }
+
+    public static void assertSize(int expectedSize, @NotNull Collection<?> c) {
+        if (c.size() != expectedSize) {
+            assertEquals(toString(c), expectedSize, c.size());
+        }
+    }
+
+    @NotNull
+    protected <T extends Disposable> T disposeOnTearDown(@NotNull T disposable) {
+        Disposer.register(getTestRootDisposable(), disposable);
+        return disposable;
+    }
+
+    public static void assertSameLines(@NotNull String expected, @NotNull String actual) {
+        assertSameLines(null, expected, actual);
+    }
+
+    public static void assertSameLines(@Nullable String message, @NotNull String expected, @NotNull String actual) {
+        String expectedText = StringUtil.convertLineSeparators(expected.trim());
+        String actualText = StringUtil.convertLineSeparators(actual.trim());
+        Assert.assertEquals(message, expectedText, actualText);
+    }
+
+    public static void assertExists(@NotNull File file){
+        assertTrue("File should exist " + file, file.exists());
+    }
+
+    public static void assertDoesntExist(@NotNull File file){
+        assertFalse("File should not exist " + file, file.exists());
+    }
+
+    @NotNull
+    protected String getTestName(boolean lowercaseFirstLetter) {
+        return getTestName(getName(), lowercaseFirstLetter);
+    }
+
+    @NotNull
+    public static String getTestName(@Nullable String name, boolean lowercaseFirstLetter) {
+        return name == null ? "" : PlatformTestUtil.getTestName(name, lowercaseFirstLetter);
+    }
+
+    @NotNull
+    protected String getTestDirectoryName() {
+        final String testName = getTestName(true);
+        return testName.replaceAll("_.*", "");
+    }
+
+    public static void assertSameLinesWithFile(@NotNull String filePath, @NotNull String actualText) {
+        assertSameLinesWithFile(filePath, actualText, true);
+    }
+
+    public static void assertSameLinesWithFile(@NotNull String filePath,
+            @NotNull String actualText,
+            @NotNull Supplier<String> messageProducer) {
+        assertSameLinesWithFile(filePath, actualText, true, messageProducer);
+    }
+
+    public static void assertSameLinesWithFile(@NotNull String filePath, @NotNull String actualText, boolean trimBeforeComparing) {
+        assertSameLinesWithFile(filePath, actualText, trimBeforeComparing, null);
+    }
+
+    public static void assertSameLinesWithFile(@NotNull String filePath,
+            @NotNull String actualText,
+            boolean trimBeforeComparing,
+            @Nullable Supplier<String> messageProducer) {
+        String fileText;
+        try {
+            if (OVERWRITE_TESTDATA) {
+                VfsTestUtil.overwriteTestData(filePath, actualText);
+                //noinspection UseOfSystemOutOrSystemErr
+                System.out.println("File " + filePath + " created.");
+            }
+            fileText = FileUtil.loadFile(new File(filePath), CharsetToolkit.UTF8_CHARSET);
+        }
+        catch (FileNotFoundException e) {
+            VfsTestUtil.overwriteTestData(filePath, actualText);
+            throw new AssertionFailedError("No output text found. File " + filePath + " created.");
+        }
+        catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        String expected = StringUtil.convertLineSeparators(trimBeforeComparing ? fileText.trim() : fileText);
+        String actual = StringUtil.convertLineSeparators(trimBeforeComparing ? actualText.trim() : actualText);
+        if (!Comparing.equal(expected, actual)) {
+            throw new FileComparisonFailure(messageProducer == null ? null : messageProducer.get(), expected, actual, filePath);
+        }
+    }
+
+    protected static void clearFields(@NotNull Object test) throws IllegalAccessException {
+        Class aClass = test.getClass();
+        while (aClass != null) {
+            clearDeclaredFields(test, aClass);
+            aClass = aClass.getSuperclass();
+        }
+    }
+
+    public static void clearDeclaredFields(@NotNull Object test, @NotNull Class aClass) throws IllegalAccessException {
+        for (final Field field : aClass.getDeclaredFields()) {
+            final String name = field.getDeclaringClass().getName();
+            if (!name.startsWith("junit.framework.") && !name.startsWith("com.intellij.testFramework.")) {
+                final int modifiers = field.getModifiers();
+                if ((modifiers & Modifier.FINAL) == 0 && (modifiers & Modifier.STATIC) == 0 && !field.getType().isPrimitive()) {
+                    field.setAccessible(true);
+                    field.set(test, null);
+                }
+            }
+        }
+    }
+
+    private static void checkCodeStyleSettingsEqual(@NotNull CodeStyleSettings expected, @NotNull CodeStyleSettings settings) {
+        if (!expected.equals(settings)) {
+            Element oldS = new Element("temp");
+            expected.writeExternal(oldS);
+            Element newS = new Element("temp");
+            settings.writeExternal(newS);
+
+            String newString = JDOMUtil.writeElement(newS);
+            String oldString = JDOMUtil.writeElement(oldS);
+            Assert.assertEquals("Code style settings damaged", oldString, newString);
+        }
+    }
+
+    public boolean isPerformanceTest() {
+        String testName = getName();
+        String className = getClass().getSimpleName();
+        return TestFrameworkUtil.isPerformanceTest(testName, className);
+    }
+
+    /**
+     * @return true for a test which performs A LOT of computations.
+     * Such test should typically avoid performing expensive checks, e.g. data structure consistency complex validations.
+     * If you want your test to be treated as "Stress", please mention one of these words in its name: "Stress", "Slow".
+     * For example: {@code public void testStressPSIFromDifferentThreads()}
+     */
+    public boolean isStressTest() {
+        return isStressTest(getName(), getClass().getName());
+    }
+
+    private static boolean isStressTest(String testName, String className) {
+        return TestFrameworkUtil.isPerformanceTest(testName, className) ||
+               containsStressWords(testName) ||
+               containsStressWords(className);
+    }
+
+    private static boolean containsStressWords(@Nullable String name) {
+        return name != null && (name.contains("Stress") || name.contains("Slow"));
+    }
+
+
+    /**
+     * Checks that code block throw corresponding exception with expected error msg.
+     * If expected error message is null it will not be checked.
+     *
+     * @param exceptionCase    Block annotated with some exception type
+     * @param expectedErrorMsg expected error message
+     */
+    protected void assertException(@NotNull AbstractExceptionCase exceptionCase, @Nullable String expectedErrorMsg) {
+        //noinspection unchecked
+        assertExceptionOccurred(true, exceptionCase, expectedErrorMsg);
+    }
+
+    /**
+     * Checks that code block doesn't throw corresponding exception.
+     *
+     * @param exceptionCase Block annotated with some exception type
+     */
+    protected <T extends Throwable> void assertNoException(@NotNull AbstractExceptionCase<T> exceptionCase) throws T {
+        assertExceptionOccurred(false, exceptionCase, null);
+    }
+
+    protected void assertNoThrowable(@NotNull Runnable closure) {
+        String throwableName = null;
+        try {
+            closure.run();
+        }
+        catch (Throwable thr) {
+            throwableName = thr.getClass().getName();
+        }
+        assertNull(throwableName);
+    }
+
+    private static <T extends Throwable> void assertExceptionOccurred(boolean shouldOccur,
+            @NotNull AbstractExceptionCase<T> exceptionCase,
+            String expectedErrorMsg) throws T {
+        boolean wasThrown = false;
+        try {
+            exceptionCase.tryClosure();
+        }
+        catch (Throwable e) {
+            if (shouldOccur) {
+                wasThrown = true;
+                final String errorMessage = exceptionCase.getAssertionErrorMessage();
+                assertEquals(errorMessage, exceptionCase.getExpectedExceptionClass(), e.getClass());
+                if (expectedErrorMsg != null) {
+                    assertEquals("Compare error messages", expectedErrorMsg, e.getMessage());
+                }
+            }
+            else if (exceptionCase.getExpectedExceptionClass().equals(e.getClass())) {
+                wasThrown = true;
+
+                //noinspection UseOfSystemOutOrSystemErr
+                System.out.println();
+                //noinspection UseOfSystemOutOrSystemErr
+                e.printStackTrace(System.out);
+
+                fail("Exception isn't expected here. Exception message: " + e.getMessage());
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            if (shouldOccur && !wasThrown) {
+                fail(exceptionCase.getAssertionErrorMessage());
+            }
+        }
+    }
+
+    protected boolean annotatedWith(@NotNull Class<? extends Annotation> annotationClass) {
+        Class<?> aClass = getClass();
+        String methodName = "test" + getTestName(false);
+        boolean methodChecked = false;
+        while (aClass != null && aClass != Object.class) {
+            if (aClass.getAnnotation(annotationClass) != null) return true;
+            if (!methodChecked) {
+                Method method = ReflectionUtil.getDeclaredMethod(aClass, methodName);
+                if (method != null) {
+                    if (method.getAnnotation(annotationClass) != null) return true;
+                    methodChecked = true;
+                }
+            }
+            aClass = aClass.getSuperclass();
+        }
+        return false;
+    }
+
+    @NotNull
+    protected String getHomePath() {
+        return PathManager.getHomePath().replace(File.separatorChar, '/');
+    }
+
+    public static void refreshRecursively(@NotNull VirtualFile file) {
+        VfsUtilCore.visitChildrenRecursively(file, new VirtualFileVisitor() {
+            @Override
+            public boolean visitFile(@NotNull VirtualFile file) {
+                file.getChildren();
+                return true;
+            }
+        });
+        file.refresh(false, true);
+    }
+
+    @Nullable
+    public static VirtualFile refreshAndFindFile(@NotNull final File file) {
+        return UIUtil.invokeAndWaitIfNeeded(() -> LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file));
+    }
+
+    protected class TestDisposable implements Disposable {
+        private volatile boolean myDisposed;
+
+        public TestDisposable() {
+        }
+
+        @Override
+        public void dispose() {
+            myDisposed = true;
+        }
+
+        public boolean isDisposed() {
+            return myDisposed;
+        }
+
+        @Override
+        public String toString() {
+            String testName = getTestName(false);
+            return KtUsefulTestCase.this.getClass() + (StringUtil.isEmpty(testName) ? "" : ".test" + testName);
+        }
+    };
+}

gradle/versions.properties

@@ -1,18 +1,18 @@
-versions.intellijSdk=193.6494.35
+versions.intellijSdk=201.7846.76
 versions.androidBuildTools=r23.0.1
-versions.idea.NodeJS=181.3494.12
+versions.idea.NodeJS=193.6494.7
 versions.jar.asm-all=7.0.1
-versions.jar.guava=27.1-jre
+versions.jar.guava=28.2-jre
 versions.jar.groovy-all=2.4.17
 versions.jar.lombok-ast=0.2.3
 versions.jar.swingx-core=1.6.2-2
 versions.jar.kxml2=2.3.0
-versions.jar.streamex=0.6.8
-versions.jar.gson=2.8.5
+versions.jar.streamex=0.7.2
+versions.jar.gson=2.8.6
 versions.jar.oro=2.0.8
 versions.jar.picocontainer=1.2
 versions.jar.serviceMessages=2019.1.4
-versions.jar.lz4-java=1.6.0
+versions.jar.lz4-java=1.7.1
 ignore.jar.snappy-in-java=true
 versions.gradle-api=4.5.1
 versions.shadow=5.2.0

gradle/versions.properties.193

@@ -0,0 +1,18 @@
+versions.intellijSdk=193.6494.35
+versions.androidBuildTools=r23.0.1
+versions.idea.NodeJS=181.3494.12
+versions.jar.asm-all=7.0.1
+versions.jar.guava=27.1-jre
+versions.jar.groovy-all=2.4.17
+versions.jar.lombok-ast=0.2.3
+versions.jar.swingx-core=1.6.2-2
+versions.jar.kxml2=2.3.0
+versions.jar.streamex=0.6.8
+versions.jar.gson=2.8.5
+versions.jar.oro=2.0.8
+versions.jar.picocontainer=1.2
+versions.jar.serviceMessages=2019.1.4
+versions.jar.lz4-java=1.6.0
+ignore.jar.snappy-in-java=true
+versions.gradle-api=4.5.1
+versions.shadow=5.2.0

idea/ide-common/src/org/jetbrains/kotlin/util/AbstractKotlinBundle.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.util
 
-import com.intellij.AbstractBundle
+import com.intellij.DynamicBundle
 
-abstract class AbstractKotlinBundle protected constructor(pathToBundle: String) : AbstractBundle(pathToBundle) {
+abstract class AbstractKotlinBundle protected constructor(pathToBundle: String) : DynamicBundle(pathToBundle) {
     protected fun String.withHtml(): String = "<html>$this</html>"
 }

idea/ide-common/src/org/jetbrains/kotlin/util/AbstractKotlinBundle.kt.193

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.util
+
+import com.intellij.AbstractBundle
+
+abstract class AbstractKotlinBundle protected constructor(pathToBundle: String) : AbstractBundle(pathToBundle) {
+    protected fun String.withHtml(): String = "<html>$this</html>"
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/compat.kt

@@ -9,6 +9,6 @@ import com.intellij.psi.PsiMethod
 import com.intellij.util.Processor
 
 // BUNCH 193
-typealias StringProcessor = Processor<String>
-typealias PsiMethodProcessor = Processor<PsiMethod>
+typealias StringProcessor = Processor<in String>
+typealias PsiMethodProcessor = Processor<in PsiMethod>
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/compat.kt.193

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.caches
+
+import com.intellij.psi.PsiMethod
+import com.intellij.util.Processor
+
+// BUNCH 193
+typealias StringProcessor = Processor<String>
+typealias PsiMethodProcessor = Processor<PsiMethod>
+

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/trackers/KotlinCodeBlockModificationListener.kt

@@ -28,6 +28,7 @@ import com.intellij.psi.impl.PsiTreeChangePreprocessor
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.idea.KotlinLanguage
+import org.jetbrains.kotlin.idea.util.application.getServiceSafe
 import org.jetbrains.kotlin.kdoc.psi.api.KDoc
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getTopmostParentOfType
@@ -38,33 +39,16 @@ val KOTLIN_CONSOLE_KEY = Key.create<Boolean>("kotlin.console")
 /**
  * Tested in OutOfBlockModificationTestGenerated
  */
-class KotlinCodeBlockModificationListener(
-    modificationTracker: PsiModificationTracker,
-    project: Project,
-    private val treeAspect: TreeAspect
-) : PsiTreeChangePreprocessor {
-    private val modificationTrackerImpl = modificationTracker as PsiModificationTrackerImpl
+class KotlinCodeBlockModificationListener(project: Project) : PsiTreeChangePreprocessor {
+    private val treeAspect: TreeAspect = TreeAspect.getInstance(project)
 
-    @Suppress("UnstableApiUsage")
-    private val isLanguageTrackerEnabled = modificationTrackerImpl.isEnableLanguageTrackerCompat
-
-    // BUNCH: 191
-    // When there're we no per-language trackers we had to increment global tracker first and process result afterward
-    private val customIncrement = if (isLanguageTrackerEnabled) 0 else 1
+    private val modificationTrackerImpl: PsiModificationTrackerImpl =
+        PsiModificationTracker.SERVICE.getInstance(project) as PsiModificationTrackerImpl
 
     @Volatile
     private var kotlinModificationTracker: Long = 0
 
-    private val kotlinOutOfCodeBlockTrackerImpl: SimpleModificationTracker = if (isLanguageTrackerEnabled) {
-        SimpleModificationTracker()
-    } else {
-        object : SimpleModificationTracker() {
-            override fun getModificationCount(): Long {
-                @Suppress("DEPRECATION")
-                return modificationTracker.outOfCodeBlockModificationCount
-            }
-        }
-    }
+    private val kotlinOutOfCodeBlockTrackerImpl: SimpleModificationTracker = SimpleModificationTracker()
 
     val kotlinOutOfCodeBlockTracker: ModificationTracker = kotlinOutOfCodeBlockTrackerImpl
 
@@ -74,9 +58,8 @@ class KotlinCodeBlockModificationListener(
         val model = PomManager.getModel(project)
         val messageBusConnection = project.messageBus.connect(project)
 
-        if (isLanguageTrackerEnabled) {
-            (PsiManager.getInstance(project) as PsiManagerImpl).addTreeChangePreprocessor(this)
-        }
+        val psiManager = PsiManager.getInstance(project) as PsiManagerImpl
+        psiManager.addTreeChangePreprocessor(this)
 
         model.addModelListener(object : PomModelListener {
             override fun isAspectChangeInteresting(aspect: PomModelAspect): Boolean {
@@ -104,14 +87,8 @@ class KotlinCodeBlockModificationListener(
                     messageBusConnection.deliverImmediately()
 
                     if (physical && !isReplLine(ktFile.virtualFile) && ktFile !is KtTypeCodeFragment) {
-                        if (isLanguageTrackerEnabled) {
-                            kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
-                            perModuleOutOfCodeBlockTrackerUpdater.onKotlinPhysicalFileOutOfBlockChange(ktFile, true)
-                        } else {
-                            perModuleOutOfCodeBlockTrackerUpdater.onKotlinPhysicalFileOutOfBlockChange(ktFile, false)
-                            // Increment counter and process changes in PsiModificationTracker.Listener
-                            modificationTrackerImpl.incCounter()
-                        }
+                        kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
+                        perModuleOutOfCodeBlockTrackerUpdater.onKotlinPhysicalFileOutOfBlockChange(ktFile, true)
                     }
 
                     ktFile.incOutOfBlockModificationCount()
@@ -123,24 +100,20 @@ class KotlinCodeBlockModificationListener(
 
         @Suppress("UnstableApiUsage")
         messageBusConnection.subscribe(PsiModificationTracker.TOPIC, PsiModificationTracker.Listener {
-            if (isLanguageTrackerEnabled) {
-                val kotlinTrackerInternalIDECount =
-                    modificationTrackerImpl.forLanguage(KotlinLanguage.INSTANCE).modificationCount
-                if (kotlinModificationTracker == kotlinTrackerInternalIDECount) {
-                    // Some update that we are not sure is from Kotlin language, as Kotlin language tracker wasn't changed
-                    kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
-                } else {
-                    kotlinModificationTracker = kotlinTrackerInternalIDECount
-                }
+            val kotlinTrackerInternalIDECount =
+                modificationTrackerImpl.forLanguage(KotlinLanguage.INSTANCE).modificationCount
+            if (kotlinModificationTracker == kotlinTrackerInternalIDECount) {
+                // Some update that we are not sure is from Kotlin language, as Kotlin language tracker wasn't changed
+                kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
+            } else {
+                kotlinModificationTracker = kotlinTrackerInternalIDECount
             }
 
-            perModuleOutOfCodeBlockTrackerUpdater.onPsiModificationTrackerUpdate(customIncrement)
+            perModuleOutOfCodeBlockTrackerUpdater.onPsiModificationTrackerUpdate()
         })
     }
 
     override fun treeChanged(event: PsiTreeChangeEventImpl) {
-        assert(isLanguageTrackerEnabled)
-
         if (!PsiModificationTrackerImpl.canAffectPsi(event)) {
             return
         }
@@ -335,8 +308,7 @@ class KotlinCodeBlockModificationListener(
             KtScriptInitializer::class.java
         )
 
-        fun getInstance(project: Project): KotlinCodeBlockModificationListener =
-            project.getComponent(KotlinCodeBlockModificationListener::class.java)
+        fun getInstance(project: Project): KotlinCodeBlockModificationListener = project.getServiceSafe()
     }
 }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/trackers/KotlinCodeBlockModificationListener.kt.193

@@ -0,0 +1,389 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.caches.trackers
+
+import com.intellij.lang.ASTNode
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Key
+import com.intellij.openapi.util.ModificationTracker
+import com.intellij.openapi.util.SimpleModificationTracker
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.pom.PomManager
+import com.intellij.pom.PomModelAspect
+import com.intellij.pom.event.PomModelEvent
+import com.intellij.pom.event.PomModelListener
+import com.intellij.pom.tree.TreeAspect
+import com.intellij.pom.tree.events.TreeChangeEvent
+import com.intellij.pom.tree.events.impl.ChangeInfoImpl
+import com.intellij.psi.*
+import com.intellij.psi.impl.PsiManagerImpl
+import com.intellij.psi.impl.PsiModificationTrackerImpl
+import com.intellij.psi.impl.PsiTreeChangeEventImpl
+import com.intellij.psi.impl.PsiTreeChangeEventImpl.PsiEventType.CHILD_MOVED
+import com.intellij.psi.impl.PsiTreeChangeEventImpl.PsiEventType.PROPERTY_CHANGED
+import com.intellij.psi.impl.PsiTreeChangePreprocessor
+import com.intellij.psi.util.PsiModificationTracker
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.idea.KotlinLanguage
+import org.jetbrains.kotlin.kdoc.psi.api.KDoc
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getTopmostParentOfType
+import org.jetbrains.kotlin.psi.psiUtil.isAncestor
+
+val KOTLIN_CONSOLE_KEY = Key.create<Boolean>("kotlin.console")
+
+/**
+ * Tested in OutOfBlockModificationTestGenerated
+ */
+class KotlinCodeBlockModificationListener(
+    modificationTracker: PsiModificationTracker,
+    project: Project,
+    private val treeAspect: TreeAspect
+) : PsiTreeChangePreprocessor {
+    private val modificationTrackerImpl = modificationTracker as PsiModificationTrackerImpl
+
+    @Suppress("UnstableApiUsage")
+    private val isLanguageTrackerEnabled = modificationTrackerImpl.isEnableLanguageTrackerCompat
+
+    // BUNCH: 191
+    // When there're we no per-language trackers we had to increment global tracker first and process result afterward
+    private val customIncrement = if (isLanguageTrackerEnabled) 0 else 1
+
+    @Volatile
+    private var kotlinModificationTracker: Long = 0
+
+    private val kotlinOutOfCodeBlockTrackerImpl: SimpleModificationTracker = if (isLanguageTrackerEnabled) {
+        SimpleModificationTracker()
+    } else {
+        object : SimpleModificationTracker() {
+            override fun getModificationCount(): Long {
+                @Suppress("DEPRECATION")
+                return modificationTracker.outOfCodeBlockModificationCount
+            }
+        }
+    }
+
+    val kotlinOutOfCodeBlockTracker: ModificationTracker = kotlinOutOfCodeBlockTrackerImpl
+
+    internal val perModuleOutOfCodeBlockTrackerUpdater = KotlinModuleOutOfCodeBlockModificationTracker.Updater(project)
+
+    init {
+        val model = PomManager.getModel(project)
+        val messageBusConnection = project.messageBus.connect(project)
+
+        if (isLanguageTrackerEnabled) {
+            (PsiManager.getInstance(project) as PsiManagerImpl).addTreeChangePreprocessor(this)
+        }
+
+        model.addModelListener(object : PomModelListener {
+            override fun isAspectChangeInteresting(aspect: PomModelAspect): Boolean {
+                return aspect == treeAspect
+            }
+
+            override fun modelChanged(event: PomModelEvent) {
+                val changeSet = event.getChangeSet(treeAspect) as TreeChangeEvent? ?: return
+                val ktFile = changeSet.rootElement.psi.containingFile as? KtFile ?: return
+
+                incFileModificationCount(ktFile)
+
+                val changedElements = changeSet.changedElements
+
+                // skip change if it contains only virtual/fake change
+                if (changedElements.isNotEmpty()) {
+                    // ignore formatting (whitespaces etc)
+                    if (isFormattingChange(changeSet) || isCommentChange(changeSet)) return
+                }
+
+                val inBlockElements = inBlockModifications(changedElements)
+
+                val physical = ktFile.isPhysical
+                if (inBlockElements.isEmpty()) {
+                    messageBusConnection.deliverImmediately()
+
+                    if (physical && !isReplLine(ktFile.virtualFile) && ktFile !is KtTypeCodeFragment) {
+                        if (isLanguageTrackerEnabled) {
+                            kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
+                            perModuleOutOfCodeBlockTrackerUpdater.onKotlinPhysicalFileOutOfBlockChange(ktFile, true)
+                        } else {
+                            perModuleOutOfCodeBlockTrackerUpdater.onKotlinPhysicalFileOutOfBlockChange(ktFile, false)
+                            // Increment counter and process changes in PsiModificationTracker.Listener
+                            modificationTrackerImpl.incCounter()
+                        }
+                    }
+
+                    ktFile.incOutOfBlockModificationCount()
+                } else if (physical) {
+                    inBlockElements.forEach { it.containingKtFile.addInBlockModifiedItem(it) }
+                }
+            }
+        })
+
+        @Suppress("UnstableApiUsage")
+        messageBusConnection.subscribe(PsiModificationTracker.TOPIC, PsiModificationTracker.Listener {
+            if (isLanguageTrackerEnabled) {
+                val kotlinTrackerInternalIDECount =
+                    modificationTrackerImpl.forLanguage(KotlinLanguage.INSTANCE).modificationCount
+                if (kotlinModificationTracker == kotlinTrackerInternalIDECount) {
+                    // Some update that we are not sure is from Kotlin language, as Kotlin language tracker wasn't changed
+                    kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
+                } else {
+                    kotlinModificationTracker = kotlinTrackerInternalIDECount
+                }
+            }
+
+            perModuleOutOfCodeBlockTrackerUpdater.onPsiModificationTrackerUpdate(customIncrement)
+        })
+    }
+
+    override fun treeChanged(event: PsiTreeChangeEventImpl) {
+        assert(isLanguageTrackerEnabled)
+
+        if (!PsiModificationTrackerImpl.canAffectPsi(event)) {
+            return
+        }
+
+        // Copy logic from PsiModificationTrackerImpl.treeChanged(). Some out-of-code-block events are written to language modification
+        // tracker in PsiModificationTrackerImpl but don't have correspondent PomModelEvent. Increase kotlinOutOfCodeBlockTracker
+        // manually if needed.
+        val outOfCodeBlock = when (event.code) {
+            PROPERTY_CHANGED ->
+                event.propertyName === PsiTreeChangeEvent.PROP_UNLOADED_PSI || event.propertyName === PsiTreeChangeEvent.PROP_ROOTS
+            CHILD_MOVED -> event.oldParent is PsiDirectory || event.newParent is PsiDirectory
+            else -> event.parent is PsiDirectory
+        }
+
+        if (outOfCodeBlock) {
+            kotlinOutOfCodeBlockTrackerImpl.incModificationCount()
+        }
+    }
+
+    companion object {
+        private fun isReplLine(file: VirtualFile): Boolean {
+            return file.getUserData(KOTLIN_CONSOLE_KEY) == true
+        }
+
+        private fun incFileModificationCount(file: KtFile) {
+            val tracker = file.getUserData(PER_FILE_MODIFICATION_TRACKER)
+                ?: file.putUserDataIfAbsent(PER_FILE_MODIFICATION_TRACKER, SimpleModificationTracker())
+            tracker.incModificationCount()
+        }
+
+        private fun inBlockModifications(elements: Array<ASTNode>): List<KtElement> {
+            // When a code fragment is reparsed, Intellij doesn't do an AST diff and considers the entire
+            // contents to be replaced, which is represented in a POM event as an empty list of changed elements
+
+            return elements.map { element ->
+                val modificationScope = getInsideCodeBlockModificationScope(element.psi) ?: return emptyList()
+                modificationScope.blockDeclaration
+            }
+        }
+
+        private fun isSpecificChange(changeSet: TreeChangeEvent, precondition: (ASTNode?) -> Boolean): Boolean =
+            changeSet.changedElements.all { changedElement ->
+                val changesByElement = changeSet.getChangesByElement(changedElement)
+                changesByElement.affectedChildren.all { affectedChild ->
+                    if (!precondition(affectedChild)) return@all false
+                    val changeByChild = changesByElement.getChangeByChild(affectedChild)
+                    return@all if (changeByChild is ChangeInfoImpl) {
+                        val oldChild = changeByChild.oldChild
+                        precondition(oldChild)
+                    } else false
+                }
+            }
+
+        private fun isCommentChange(changeSet: TreeChangeEvent): Boolean =
+            isSpecificChange(changeSet) { it is PsiComment || it is KDoc }
+
+        private fun isFormattingChange(changeSet: TreeChangeEvent): Boolean =
+            isSpecificChange(changeSet) { it is PsiWhiteSpace }
+
+        /**
+         * Has to be aligned with [getInsideCodeBlockModificationScope] :
+         *
+         * result of analysis has to be reflected in dirty scope,
+         * the only difference is whitespaces and comments
+         */
+        fun getInsideCodeBlockModificationDirtyScope(element: PsiElement): PsiElement? {
+            if (!element.isPhysical) return null
+            // dirty scope for whitespaces and comments is the element itself
+            if (element is PsiWhiteSpace || element is PsiComment || element is KDoc) return element
+
+            return getInsideCodeBlockModificationScope(element)?.blockDeclaration ?: null
+        }
+
+        fun getInsideCodeBlockModificationScope(element: PsiElement): BlockModificationScopeElement? {
+            val lambda = element.getTopmostParentOfType<KtLambdaExpression>()
+            if (lambda is KtLambdaExpression) {
+                lambda.getTopmostParentOfType<KtSuperTypeCallEntry>()?.getTopmostParentOfType<KtClassOrObject>()?.let {
+                    return BlockModificationScopeElement(it, it)
+                }
+            }
+
+            val blockDeclaration =
+                KtPsiUtil.getTopmostParentOfTypes(element, *BLOCK_DECLARATION_TYPES) as? KtDeclaration ?: return null
+//                KtPsiUtil.getTopmostParentOfType<KtClassOrObject>(element) as? KtDeclaration ?: return null
+
+            // should not be local declaration
+            if (KtPsiUtil.isLocal(blockDeclaration))
+                return null
+
+            when (blockDeclaration) {
+                is KtNamedFunction -> {
+//                    if (blockDeclaration.visibilityModifierType()?.toVisibility() == Visibilities.PRIVATE) {
+//                        topClassLikeDeclaration(blockDeclaration)?.let {
+//                            return BlockModificationScopeElement(it, it)
+//                        }
+//                    }
+                    if (blockDeclaration.hasBlockBody()) {
+                        // case like `fun foo(): String {...<caret>...}`
+                        return blockDeclaration.bodyExpression
+                            ?.takeIf { it.isAncestor(element) }
+                            ?.let { BlockModificationScopeElement(blockDeclaration, it) }
+                    } else if (blockDeclaration.hasDeclaredReturnType()) {
+                        // case like `fun foo(): String = b<caret>labla`
+                        return blockDeclaration.initializer
+                            ?.takeIf { it.isAncestor(element) }
+                            ?.let { BlockModificationScopeElement(blockDeclaration, it) }
+                    }
+                }
+
+                is KtProperty -> {
+//                    if (blockDeclaration.visibilityModifierType()?.toVisibility() == Visibilities.PRIVATE) {
+//                        topClassLikeDeclaration(blockDeclaration)?.let {
+//                            return BlockModificationScopeElement(it, it)
+//                        }
+//                    }
+                    if (blockDeclaration.typeReference != null) {
+                        val accessors =
+                            blockDeclaration.accessors.map { it.initializer ?: it.bodyExpression } + blockDeclaration.initializer
+                        for (accessor in accessors) {
+                            accessor?.takeIf {
+                                    it.isAncestor(element) &&
+                                            // adding annotations to accessor is the same as change contract of property
+                                            (element !is KtAnnotated || element.annotationEntries.isEmpty())
+                                }
+                                ?.let { expression ->
+                                    val declaration =
+                                        KtPsiUtil.getTopmostParentOfTypes(blockDeclaration, KtClassOrObject::class.java) as? KtElement ?:
+                                        // ktFile to check top level property declarations
+                                        return null
+                                    return BlockModificationScopeElement(declaration, expression)
+                                }
+                        }
+                    }
+                }
+
+                is KtScriptInitializer -> {
+                    return (blockDeclaration.body as? KtCallExpression)
+                        ?.lambdaArguments
+                        ?.lastOrNull()
+                        ?.getLambdaExpression()
+                        ?.takeIf { it.isAncestor(element) }
+                        ?.let { BlockModificationScopeElement(blockDeclaration, it) }
+                }
+
+                is KtClassInitializer -> {
+                    blockDeclaration
+                        .takeIf { it.isAncestor(element) }
+                        ?.let { ktClassInitializer ->
+                            (PsiTreeUtil.getParentOfType(blockDeclaration, KtClassOrObject::class.java))?.let {
+                                return BlockModificationScopeElement(it, ktClassInitializer)
+                            }
+                        }
+                }
+
+                is KtSecondaryConstructor -> {
+                    blockDeclaration
+                        ?.takeIf {
+                            it.bodyExpression?.isAncestor(element) ?: false || it.getDelegationCallOrNull()?.isAncestor(element) ?: false
+                        }?.let { ktConstructor ->
+                            PsiTreeUtil.getParentOfType(blockDeclaration, KtClassOrObject::class.java)?.let {
+                                return BlockModificationScopeElement(it, ktConstructor)
+                            }
+                        }
+                }
+//                is KtClassOrObject -> {
+//                    return when (element) {
+//                        is KtProperty, is KtNamedFunction -> {
+//                            if ((element as? KtModifierListOwner)?.visibilityModifierType()?.toVisibility() == Visibilities.PRIVATE)
+//                                BlockModificationScopeElement(blockDeclaration, blockDeclaration) else null
+//                        }
+//                        else -> null
+//                    }
+//                }
+
+                else -> throw IllegalStateException()
+            }
+
+            return null
+        }
+
+        data class BlockModificationScopeElement(val blockDeclaration: KtElement, val element: KtElement)
+
+        fun isBlockDeclaration(declaration: KtDeclaration): Boolean {
+            return BLOCK_DECLARATION_TYPES.any { it.isInstance(declaration) }
+        }
+
+        private val BLOCK_DECLARATION_TYPES = arrayOf<Class<out KtDeclaration>>(
+            KtProperty::class.java,
+            KtNamedFunction::class.java,
+            KtClassInitializer::class.java,
+            KtSecondaryConstructor::class.java,
+            KtScriptInitializer::class.java
+        )
+
+        fun getInstance(project: Project): KotlinCodeBlockModificationListener =
+            project.getComponent(KotlinCodeBlockModificationListener::class.java)
+    }
+}
+
+private val PER_FILE_MODIFICATION_TRACKER = Key<SimpleModificationTracker>("FILE_OUT_OF_BLOCK_MODIFICATION_COUNT")
+
+val KtFile.perFileModificationTracker: ModificationTracker
+    get() = putUserDataIfAbsent(PER_FILE_MODIFICATION_TRACKER, SimpleModificationTracker())
+
+private val FILE_OUT_OF_BLOCK_MODIFICATION_COUNT = Key<Long>("FILE_OUT_OF_BLOCK_MODIFICATION_COUNT")
+
+val KtFile.outOfBlockModificationCount: Long by NotNullableUserDataProperty(FILE_OUT_OF_BLOCK_MODIFICATION_COUNT, 0)
+
+private fun KtFile.incOutOfBlockModificationCount() {
+    clearInBlockModifications()
+
+    val count = getUserData(FILE_OUT_OF_BLOCK_MODIFICATION_COUNT) ?: 0
+    putUserData(FILE_OUT_OF_BLOCK_MODIFICATION_COUNT, count + 1)
+}
+
+/**
+ * inBlockModifications is a collection of block elements those have in-block modifications
+ */
+private val IN_BLOCK_MODIFICATIONS = Key<MutableCollection<KtElement>>("IN_BLOCK_MODIFICATIONS")
+private val FILE_IN_BLOCK_MODIFICATION_COUNT = Key<Long>("FILE_IN_BLOCK_MODIFICATION_COUNT")
+
+val KtFile.inBlockModificationCount: Long by NotNullableUserDataProperty(FILE_IN_BLOCK_MODIFICATION_COUNT, 0)
+
+val KtFile.inBlockModifications: Collection<KtElement>
+    get() {
+        val collection = getUserData(IN_BLOCK_MODIFICATIONS)
+        return collection ?: emptySet()
+    }
+
+private fun KtFile.addInBlockModifiedItem(element: KtElement) {
+    val collection = putUserDataIfAbsent(IN_BLOCK_MODIFICATIONS, mutableSetOf())
+    synchronized(collection) {
+        collection.add(element)
+    }
+    val count = getUserData(FILE_IN_BLOCK_MODIFICATION_COUNT) ?: 0
+    putUserData(FILE_IN_BLOCK_MODIFICATION_COUNT, count + 1)
+}
+
+fun KtFile.clearInBlockModifications() {
+    val collection = getUserData(IN_BLOCK_MODIFICATIONS)
+    collection?.let {
+        synchronized(it) {
+            it.clear()
+        }
+    }
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/AnnotationPresentationInfo.kt

@@ -8,8 +8,9 @@ package org.jetbrains.kotlin.idea.highlighter
 import com.intellij.codeInsight.intention.EmptyIntentionAction
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.codeInspection.ProblemHighlightType
-import com.intellij.lang.annotation.Annotation
+import com.intellij.lang.annotation.AnnotationBuilder
 import com.intellij.lang.annotation.AnnotationHolder
+import com.intellij.lang.annotation.HighlightSeverity
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.editor.colors.TextAttributesKey
 import com.intellij.openapi.util.TextRange
@@ -31,53 +32,43 @@ class AnnotationPresentationInfo(
         for (range in ranges) {
             for (diagnostic in diagnostics) {
                 val fixes = fixesMap[diagnostic]
-                val annotation = create(diagnostic, range, holder)
-
-                fixes.forEach {
-                    when (it) {
-                        is KotlinUniversalQuickFix -> annotation.registerUniversalFix(it, null, null)
-                        is IntentionAction -> annotation.registerFix(it)
+                create(diagnostic, range, holder) { annotation ->
+                    fixes.forEach {
+                        when (it) {
+                            is KotlinUniversalQuickFix -> annotation.newFix(it).universal().registerFix()
+                            is IntentionAction -> annotation.newFix(it).registerFix()
+                        }
                     }
-                }
 
-                if (diagnostic.severity == Severity.WARNING) {
-                    annotation.problemGroup = KotlinSuppressableWarningProblemGroup(diagnostic.factory)
+                    if (diagnostic.severity == Severity.WARNING) {
+                        annotation.problemGroup(KotlinSuppressableWarningProblemGroup(diagnostic.factory))
 
-                    if (fixes.isEmpty()) {
-                        // if there are no quick fixes we need to register an EmptyIntentionAction to enable 'suppress' actions
-                        annotation.registerFix(EmptyIntentionAction(diagnostic.factory.name))
+                        if (fixes.isEmpty()) {
+                            // if there are no quick fixes we need to register an EmptyIntentionAction to enable 'suppress' actions
+                            annotation.newFix(EmptyIntentionAction(diagnostic.factory.name)).registerFix()
+                        }
                     }
                 }
             }
         }
     }
 
-    private fun create(diagnostic: Diagnostic, range: TextRange, holder: AnnotationHolder): Annotation {
-        val defaultMessage = nonDefaultMessage ?: getDefaultMessage(diagnostic)
-
-        val annotation = when (diagnostic.severity) {
-            Severity.ERROR -> holder.createErrorAnnotation(range, defaultMessage)
-            Severity.WARNING -> {
-                if (highlightType == ProblemHighlightType.WEAK_WARNING) {
-                    holder.createWeakWarningAnnotation(range, defaultMessage)
-                } else {
-                    holder.createWarningAnnotation(range, defaultMessage)
-                }
-            }
-            Severity.INFO -> holder.createInfoAnnotation(range, defaultMessage)
+    private fun create(diagnostic: Diagnostic, range: TextRange, holder: AnnotationHolder, consumer: (AnnotationBuilder) -> Unit) {
+        val severity = when (diagnostic.severity) {
+            Severity.ERROR -> HighlightSeverity.ERROR
+            Severity.WARNING -> if (highlightType == ProblemHighlightType.WEAK_WARNING) {
+                HighlightSeverity.WEAK_WARNING
+            } else HighlightSeverity.WARNING
+            Severity.INFO -> HighlightSeverity.WEAK_WARNING
         }
 
-        annotation.tooltip = getMessage(diagnostic)
-
-        if (highlightType != null) {
-            annotation.highlightType = highlightType
-        }
-
-        if (textAttributes != null) {
-            annotation.textAttributes = textAttributes
-        }
-
-        return annotation
+        holder.newAnnotation(severity, nonDefaultMessage ?: getDefaultMessage(diagnostic))
+            .range(range)
+            .tooltip(getMessage(diagnostic))
+            .also { builder -> highlightType?.let { builder.highlightType(it) } }
+            .also { builder -> textAttributes?.let { builder.textAttributes(it) } }
+            .also { consumer(it) }
+            .create()
     }
 
     private fun getMessage(diagnostic: Diagnostic): String {
@@ -103,4 +94,5 @@ class AnnotationPresentationInfo(
         }
         return message
     }
+
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/AnnotationPresentationInfo.kt.193

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.highlighter
+
+import com.intellij.codeInsight.intention.EmptyIntentionAction
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.codeInspection.ProblemHighlightType
+import com.intellij.lang.annotation.Annotation
+import com.intellij.lang.annotation.AnnotationHolder
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.editor.colors.TextAttributesKey
+import com.intellij.openapi.util.TextRange
+import com.intellij.util.containers.MultiMap
+import com.intellij.xml.util.XmlStringUtil
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
+import org.jetbrains.kotlin.idea.inspections.KotlinUniversalQuickFix
+
+class AnnotationPresentationInfo(
+    val ranges: List<TextRange>,
+    val nonDefaultMessage: String? = null,
+    val highlightType: ProblemHighlightType? = null,
+    val textAttributes: TextAttributesKey? = null
+) {
+
+    fun processDiagnostics(holder: AnnotationHolder, diagnostics: List<Diagnostic>, fixesMap: MultiMap<Diagnostic, IntentionAction>) {
+        for (range in ranges) {
+            for (diagnostic in diagnostics) {
+                val fixes = fixesMap[diagnostic]
+                val annotation = create(diagnostic, range, holder)
+
+                fixes.forEach {
+                    when (it) {
+                        is KotlinUniversalQuickFix -> annotation.registerUniversalFix(it, null, null)
+                        is IntentionAction -> annotation.registerFix(it)
+                    }
+                }
+
+                if (diagnostic.severity == Severity.WARNING) {
+                    annotation.problemGroup = KotlinSuppressableWarningProblemGroup(diagnostic.factory)
+
+                    if (fixes.isEmpty()) {
+                        // if there are no quick fixes we need to register an EmptyIntentionAction to enable 'suppress' actions
+                        annotation.registerFix(EmptyIntentionAction(diagnostic.factory.name))
+                    }
+                }
+            }
+        }
+    }
+
+    private fun create(diagnostic: Diagnostic, range: TextRange, holder: AnnotationHolder): Annotation {
+        val defaultMessage = nonDefaultMessage ?: getDefaultMessage(diagnostic)
+
+        val annotation = when (diagnostic.severity) {
+            Severity.ERROR -> holder.createErrorAnnotation(range, defaultMessage)
+            Severity.WARNING -> {
+                if (highlightType == ProblemHighlightType.WEAK_WARNING) {
+                    holder.createWeakWarningAnnotation(range, defaultMessage)
+                } else {
+                    holder.createWarningAnnotation(range, defaultMessage)
+                }
+            }
+            Severity.INFO -> holder.createInfoAnnotation(range, defaultMessage)
+        }
+
+        annotation.tooltip = getMessage(diagnostic)
+
+        if (highlightType != null) {
+            annotation.highlightType = highlightType
+        }
+
+        if (textAttributes != null) {
+            annotation.textAttributes = textAttributes
+        }
+
+        return annotation
+    }
+
+    private fun getMessage(diagnostic: Diagnostic): String {
+        var message = IdeErrorMessages.render(diagnostic)
+        if (ApplicationManager.getApplication().isInternal || ApplicationManager.getApplication().isUnitTestMode) {
+            val factoryName = diagnostic.factory.name
+            message = if (message.startsWith("<html>")) {
+                "<html>[$factoryName] ${message.substring("<html>".length)}"
+            } else {
+                "[$factoryName] $message"
+            }
+        }
+        if (!message.startsWith("<html>")) {
+            message = "<html><body>${XmlStringUtil.escapeString(message)}</body></html>"
+        }
+        return message
+    }
+
+    private fun getDefaultMessage(diagnostic: Diagnostic): String {
+        val message = DefaultErrorMessages.render(diagnostic)
+        if (ApplicationManager.getApplication().isInternal || ApplicationManager.getApplication().isUnitTestMode) {
+            return "[${diagnostic.factory.name}] $message"
+        }
+        return message
+    }
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/modules/ModuleHighlightUtil2.java

@@ -64,7 +64,7 @@ public class ModuleHighlightUtil2 {
                     }
                 }
                 else if (root.getFileSystem() instanceof JarFileSystem && "jar".equalsIgnoreCase(root.getExtension())) {
-                    return LightJavaModule.getModule(PsiManager.getInstance(project), root);
+                    return LightJavaModule.findModule(PsiManager.getInstance(project), root);
                 }
             }
             else if ((root = index.getSourceRootForFile(file)) != null) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/modules/ModuleHighlightUtil2.java.193

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.modules;
+
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.ProjectFileIndex;
+import com.intellij.openapi.vfs.JarFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiJavaFile;
+import com.intellij.psi.PsiJavaModule;
+import com.intellij.psi.PsiManager;
+import com.intellij.psi.impl.light.LightJavaModule;
+import kotlin.collections.ArraysKt;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.idea.core.FileIndexUtilsKt;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.jar.Attributes;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+
+import static com.intellij.psi.PsiJavaModule.MODULE_INFO_FILE;
+
+// Copied from com.intellij.codeInsight.daemon.impl.analysis.ModuleHighlightUtil
+public class ModuleHighlightUtil2 {
+    private static final Attributes.Name MULTI_RELEASE = new Attributes.Name("Multi-Release");
+
+    @Nullable
+    static PsiJavaModule getModuleDescriptor(@NotNull VirtualFile file, @NotNull Project project) {
+        ProjectFileIndex index = ProjectFileIndex.SERVICE.getInstance(project);
+        if (index.isInLibrary(file)) {
+            VirtualFile root;
+            if ((root = index.getClassRootForFile(file)) != null) {
+                VirtualFile descriptorFile = root.findChild(PsiJavaModule.MODULE_INFO_CLS_FILE);
+                if (descriptorFile == null) {
+                    VirtualFile alt = root.findFileByRelativePath("META-INF/versions/9/" + PsiJavaModule.MODULE_INFO_CLS_FILE);
+                    if (alt != null && isMultiReleaseJar(root)) {
+                        descriptorFile = alt;
+                    }
+                }
+                if (descriptorFile != null) {
+                    PsiFile psiFile = PsiManager.getInstance(project).findFile(descriptorFile);
+                    if (psiFile instanceof PsiJavaFile) {
+                        return ((PsiJavaFile) psiFile).getModuleDeclaration();
+                    }
+                }
+                else if (root.getFileSystem() instanceof JarFileSystem && "jar".equalsIgnoreCase(root.getExtension())) {
+                    return LightJavaModule.getModule(PsiManager.getInstance(project), root);
+                }
+            }
+            else if ((root = index.getSourceRootForFile(file)) != null) {
+                VirtualFile descriptorFile = root.findChild(MODULE_INFO_FILE);
+                if (descriptorFile != null) {
+                    PsiFile psiFile = PsiManager.getInstance(project).findFile(descriptorFile);
+                    if (psiFile instanceof PsiJavaFile) {
+                        return ((PsiJavaFile) psiFile).getModuleDeclaration();
+                    }
+                }
+            }
+        }
+        else {
+            Module module = index.getModuleForFile(file);
+            if (module != null) {
+                boolean isTest = FileIndexUtilsKt.isInTestSourceContentKotlinAware(index, file);
+                VirtualFile modularRoot = ArraysKt.singleOrNull(ModuleRootManager.getInstance(module).getSourceRoots(isTest),
+                                                                root -> root.findChild(MODULE_INFO_FILE) != null);
+                if (modularRoot != null) {
+                    VirtualFile moduleInfo = modularRoot.findChild(MODULE_INFO_FILE);
+                    assert moduleInfo != null : modularRoot;
+                    PsiFile psiFile = PsiManager.getInstance(project).findFile(moduleInfo);
+                    if (psiFile instanceof PsiJavaFile) {
+                        return ((PsiJavaFile) psiFile).getModuleDeclaration();
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private static boolean isMultiReleaseJar(VirtualFile root) {
+        if (root.getFileSystem() instanceof JarFileSystem) {
+            VirtualFile manifest = root.findFileByRelativePath(JarFile.MANIFEST_NAME);
+            if (manifest != null) {
+                try (InputStream stream = manifest.getInputStream()) {
+                    return Boolean.valueOf(new Manifest(stream).getMainAttributes().getValue(MULTI_RELEASE));
+                }
+                catch (IOException ignored) {
+                }
+            }
+        }
+
+        return false;
+    }
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ApplicationUtils.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.idea.util.application
 
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.command.CommandProcessor
+import com.intellij.openapi.progress.impl.CancellationCheck
 import com.intellij.openapi.project.Project
-import org.jetbrains.annotations.Nls
 
 fun <T> runReadAction(action: () -> T): T {
     return ApplicationManager.getApplication().runReadAction<T>(action)
@@ -29,22 +29,22 @@ fun <T> runWriteAction(action: () -> T): T {
     return ApplicationManager.getApplication().runWriteAction<T>(action)
 }
 
-fun Project.executeWriteCommand(@Nls name: String, command: () -> Unit) {
+fun Project.executeWriteCommand(name: String, command: () -> Unit) {
     CommandProcessor.getInstance().executeCommand(this, { runWriteAction(command) }, name, null)
 }
 
-fun <T> Project.executeWriteCommand(@Nls name: String, groupId: Any? = null, command: () -> T): T {
+fun <T> Project.executeWriteCommand(name: String, groupId: Any? = null, command: () -> T): T {
     return executeCommand<T>(name, groupId) { runWriteAction(command) }
 }
 
-fun <T> Project.executeCommand(@Nls name: String, groupId: Any? = null, command: () -> T): T {
+fun <T> Project.executeCommand(name: String, groupId: Any? = null, command: () -> T): T {
     @Suppress("UNCHECKED_CAST") var result: T = null as T
     CommandProcessor.getInstance().executeCommand(this, { result = command() }, name, groupId)
     @Suppress("USELESS_CAST")
     return result as T
 }
 
-fun <T> runWithCancellationCheck(block: () -> T): T = block()
+fun <T> runWithCancellationCheck(block: () -> T): T = CancellationCheck.runWithCancellationCheck(block)
 
 inline fun executeOnPooledThread(crossinline action: () -> Unit) =
     ApplicationManager.getApplication().executeOnPooledThread { action() }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ApplicationUtils.kt.193

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.util.application
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.command.CommandProcessor
+import com.intellij.openapi.project.Project
+import org.jetbrains.annotations.Nls
+
+fun <T> runReadAction(action: () -> T): T {
+    return ApplicationManager.getApplication().runReadAction<T>(action)
+}
+
+fun <T> runWriteAction(action: () -> T): T {
+    return ApplicationManager.getApplication().runWriteAction<T>(action)
+}
+
+fun Project.executeWriteCommand(@Nls name: String, command: () -> Unit) {
+    CommandProcessor.getInstance().executeCommand(this, { runWriteAction(command) }, name, null)
+}
+
+fun <T> Project.executeWriteCommand(@Nls name: String, groupId: Any? = null, command: () -> T): T {
+    return executeCommand<T>(name, groupId) { runWriteAction(command) }
+}
+
+fun <T> Project.executeCommand(@Nls name: String, groupId: Any? = null, command: () -> T): T {
+    @Suppress("UNCHECKED_CAST") var result: T = null as T
+    CommandProcessor.getInstance().executeCommand(this, { result = command() }, name, groupId)
+    @Suppress("USELESS_CAST")
+    return result as T
+}
+
+fun <T> runWithCancellationCheck(block: () -> T): T = block()
+
+inline fun executeOnPooledThread(crossinline action: () -> Unit) =
+    ApplicationManager.getApplication().executeOnPooledThread { action() }
+
+inline fun invokeLater(crossinline action: () -> Unit) =
+    ApplicationManager.getApplication().invokeLater { action() }
+
+inline fun isUnitTestMode(): Boolean = ApplicationManager.getApplication().isUnitTestMode
+
+inline fun <reified T : Any> Project.getServiceSafe(): T =
+    this.getService(T::class.java) ?: error("Unable to locate service ${T::class.java.name}")

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/compat.kt

@@ -5,9 +5,10 @@
 
 package org.jetbrains.kotlin.idea.completion.test.handlers
 
+import com.intellij.codeInsight.lookup.LookupFocusDegree
 import com.intellij.codeInsight.lookup.impl.LookupImpl
 
 // BUNCH: 193
 fun LookupImpl.setFocusedFocusDegree() {
-    focusDegree = LookupImpl.FocusDegree.FOCUSED
+    this.lookupFocusDegree = LookupFocusDegree.FOCUSED
 }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/compat.kt.193

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.completion.test.handlers
+
+import com.intellij.codeInsight.lookup.impl.LookupImpl
+
+// BUNCH: 193
+fun LookupImpl.setFocusedFocusDegree() {
+    focusDegree = LookupImpl.FocusDegree.FOCUSED
+}

idea/idea-gradle/src/org/jetbrains/kotlin/idea/configuration/AbstractProjectResolverExtensionCompat.kt

@@ -13,8 +13,8 @@ import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExten
 
 // BUNCH: 193
 abstract class AbstractProjectResolverExtensionCompat : AbstractProjectResolverExtension() {
-    override fun createModule(gradleModule: IdeaModule, projectDataNode: DataNode<ProjectData>): DataNode<ModuleData> {
-        return super.createModule(gradleModule, projectDataNode).also {
+    override fun createModule(gradleModule: IdeaModule, projectDataNode: DataNode<ProjectData>): DataNode<ModuleData>? {
+        return super.createModule(gradleModule, projectDataNode)?.also {
             initializeModuleNode(gradleModule, it, projectDataNode)
         }
     }

idea/idea-gradle/src/org/jetbrains/kotlin/idea/configuration/AbstractProjectResolverExtensionCompat.kt.193

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.configuration
+
+import com.intellij.openapi.externalSystem.model.DataNode
+import com.intellij.openapi.externalSystem.model.project.ModuleData
+import com.intellij.openapi.externalSystem.model.project.ProjectData
+import org.gradle.tooling.model.idea.IdeaModule
+import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
+
+// BUNCH: 193
+abstract class AbstractProjectResolverExtensionCompat : AbstractProjectResolverExtension() {
+    override fun createModule(gradleModule: IdeaModule, projectDataNode: DataNode<ProjectData>): DataNode<ModuleData> {
+        return super.createModule(gradleModule, projectDataNode).also {
+            initializeModuleNode(gradleModule, it, projectDataNode)
+        }
+    }
+
+    // Inline after class remove
+    abstract fun initializeModuleNode(
+        gradleModule: IdeaModule,
+        moduleDataNode: DataNode<ModuleData>,
+        projectDataNode: DataNode<ProjectData>,
+    )
+}

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/AsyncFileChangeListenerHelper.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.idea.scripting.gradle
 
-import com.intellij.openapi.externalSystem.service.project.autoimport.AsyncFileChangeListenerBase
+import com.intellij.openapi.externalSystem.autoimport.AsyncFileChangeListenerBase
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.openapi.vfs.newvfs.events.VFileEvent
@@ -22,9 +22,8 @@ fun addVfsListener(watcher: GradleScriptInputsWatcher) {
             }
 
             // do nothing
-            override fun prepareFileDeletion(file: VirtualFile) {}
             override fun apply() {}
-            override fun reset() {}
+            override fun init() {}
 
         },
         watcher.project

idea/idea-gradle/src/org/jetbrains/kotlin/idea/scripting/gradle/AsyncFileChangeListenerHelper.kt.193

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.scripting.gradle
+
+import com.intellij.openapi.externalSystem.service.project.autoimport.AsyncFileChangeListenerBase
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.openapi.vfs.newvfs.events.VFileEvent
+
+fun addVfsListener(watcher: GradleScriptInputsWatcher) {
+    VirtualFileManager.getInstance().addAsyncFileListener(
+        object : AsyncFileChangeListenerBase() {
+            override fun isRelevant(path: String): Boolean {
+                return isInAffectedGradleProjectFiles(watcher.project, path)
+            }
+
+            override fun updateFile(file: VirtualFile, event: VFileEvent) {
+                watcher.fileChanged(event.path, file.timeStamp)
+            }
+
+            // do nothing
+            override fun prepareFileDeletion(file: VirtualFile) {}
+            override fun apply() {}
+            override fun reset() {}
+
+        },
+        watcher.project
+    )
+}

idea/idea-gradle/tests/org/jetbrains/kotlin/idea/codeInsight/gradle/AbstractModelBuilderTest.java

@@ -147,8 +147,8 @@ public abstract class AbstractModelBuilderTest {
     }
 
     @NotNull
-    private static Set<Class> getToolingExtensionClasses() {
-        Set<Class> classes = ContainerUtil.<Class>set(
+    private static Set<Class<?>> getToolingExtensionClasses() {
+        Set<Class<?>> classes = ContainerUtil.set(
                 ExternalProject.class,
                 // gradle-tooling-extension-api jar
                 ProjectImportAction.class,
@@ -163,7 +163,7 @@ public abstract class AbstractModelBuilderTest {
     }
 
     @NotNull
-    private static Set<Class> doGetToolingExtensionClasses() {
+    private static Set<Class<?>> doGetToolingExtensionClasses() {
         return Collections.emptySet();
     }
 
@@ -174,7 +174,7 @@ public abstract class AbstractModelBuilderTest {
         }
     }
 
-    protected abstract Set<Class> getModels();
+    protected abstract Set<Class<?>> getModels();
 
 
     private static void ensureTempDirCreated() throws IOException {

idea/idea-gradle/tests/org/jetbrains/kotlin/idea/codeInsight/gradle/AbstractModelBuilderTest.java.193

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.idea.codeInsight.gradle;
+
+import com.google.common.collect.Multimap;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.io.StreamUtil;
+import com.intellij.testFramework.IdeaTestUtil;
+import com.intellij.util.containers.ContainerUtil;
+import org.codehaus.groovy.runtime.typehandling.ShortTypeHandling;
+import org.gradle.tooling.BuildActionExecuter;
+import org.gradle.tooling.GradleConnector;
+import org.gradle.tooling.ProjectConnection;
+import org.gradle.tooling.internal.consumer.DefaultGradleConnector;
+import org.gradle.util.GradleVersion;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.gradle.model.ClassSetProjectImportModelProvider;
+import org.jetbrains.plugins.gradle.model.ExternalProject;
+import org.jetbrains.plugins.gradle.model.ProjectImportAction;
+import org.jetbrains.plugins.gradle.service.execution.GradleExecutionHelper;
+import org.jetbrains.plugins.gradle.tooling.builder.ModelBuildScriptClasspathBuilderImpl;
+import org.jetbrains.plugins.gradle.util.GradleConstants;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assume.assumeThat;
+
+// part of org.jetbrains.plugins.gradle.tooling.builder.AbstractModelBuilderTest
+@RunWith(value = Parameterized.class)
+public abstract class AbstractModelBuilderTest {
+
+    public static final Object[][] SUPPORTED_GRADLE_VERSIONS = {{"4.9"}, {"5.6.4"}};
+
+    private static final Pattern TEST_METHOD_NAME_PATTERN = Pattern.compile("(.*)\\[(\\d*: with Gradle-.*)\\]");
+
+    private static File ourTempDir;
+
+    @NotNull
+    private final String gradleVersion;
+    private File testDir;
+    private ProjectImportAction.AllModels allModels;
+
+    @Rule public TestName name = new TestName();
+    @Rule public VersionMatcherRule versionMatcherRule = new VersionMatcherRule();
+
+    public AbstractModelBuilderTest(@NotNull String gradleVersion) {
+        this.gradleVersion = gradleVersion;
+    }
+
+    @Parameterized.Parameters(name = "{index}: with Gradle-{0}")
+    public static Collection<Object[]> data() {
+        return Arrays.asList(SUPPORTED_GRADLE_VERSIONS);
+    }
+
+
+    @Before
+    public void setUp() throws Exception {
+        assumeThat(gradleVersion, versionMatcherRule.getMatcher());
+
+        ensureTempDirCreated();
+
+        String methodName = name.getMethodName();
+        Matcher m = TEST_METHOD_NAME_PATTERN.matcher(methodName);
+        if (m.matches()) {
+            methodName = m.group(1);
+        }
+
+        testDir = new File(ourTempDir, methodName);
+        FileUtil.ensureExists(testDir);
+
+        InputStream buildScriptStream = getClass().getResourceAsStream("/" + methodName + "/" + GradleConstants.DEFAULT_SCRIPT_NAME);
+        try {
+            FileUtil.writeToFile(
+                    new File(testDir, GradleConstants.DEFAULT_SCRIPT_NAME),
+                    FileUtil.loadTextAndClose(buildScriptStream)
+            );
+        }
+        finally {
+            StreamUtil.closeStream(buildScriptStream);
+        }
+
+        InputStream settingsStream = getClass().getResourceAsStream("/" + methodName + "/" + GradleConstants.SETTINGS_FILE_NAME);
+        try {
+            if (settingsStream != null) {
+                FileUtil.writeToFile(
+                        new File(testDir, GradleConstants.SETTINGS_FILE_NAME),
+                        FileUtil.loadTextAndClose(settingsStream)
+                );
+            }
+        }
+        finally {
+            StreamUtil.closeStream(settingsStream);
+        }
+
+        GradleConnector connector = GradleConnector.newConnector();
+
+        URI distributionUri = new DistributionLocator().getDistributionFor(GradleVersion.version(gradleVersion));
+        connector.useDistribution(distributionUri);
+        connector.forProjectDirectory(testDir);
+        int daemonMaxIdleTime = 10;
+        try {
+            daemonMaxIdleTime = Integer.parseInt(System.getProperty("gradleDaemonMaxIdleTime", "10"));
+        }
+        catch (NumberFormatException ignore) {
+        }
+
+        ((DefaultGradleConnector) connector).daemonMaxIdleTime(daemonMaxIdleTime, TimeUnit.SECONDS);
+        ProjectConnection connection = connector.connect();
+
+        try {
+            ProjectImportAction projectImportAction = new ProjectImportAction(false);
+            projectImportAction.addProjectImportModelProvider(new ClassSetProjectImportModelProvider(getModels()));
+            BuildActionExecuter<ProjectImportAction.AllModels> buildActionExecutor = connection.action(projectImportAction);
+            File initScript = GradleExecutionHelper.generateInitScript(false, getToolingExtensionClasses());
+            assertNotNull(initScript);
+            String jdkHome = IdeaTestUtil.requireRealJdkHome();
+            buildActionExecutor.setJavaHome(new File(jdkHome));
+            buildActionExecutor.setJvmArguments("-Xmx128m", "-XX:MaxPermSize=64m");
+            buildActionExecutor
+                    .withArguments("--info", "--recompile-scripts", GradleConstants.INIT_SCRIPT_CMD_OPTION, initScript.getAbsolutePath());
+            allModels = buildActionExecutor.run();
+            assertNotNull(allModels);
+        }
+        finally {
+            connection.close();
+        }
+    }
+
+    @NotNull
+    private static Set<Class> getToolingExtensionClasses() {
+        Set<Class> classes = ContainerUtil.<Class>set(
+                ExternalProject.class,
+                // gradle-tooling-extension-api jar
+                ProjectImportAction.class,
+                // gradle-tooling-extension-impl jar
+                ModelBuildScriptClasspathBuilderImpl.class,
+                Multimap.class,
+                ShortTypeHandling.class
+        );
+
+        ContainerUtil.addAllNotNull(classes, doGetToolingExtensionClasses());
+        return classes;
+    }
+
+    @NotNull
+    private static Set<Class> doGetToolingExtensionClasses() {
+        return Collections.emptySet();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        if (testDir != null) {
+            FileUtil.delete(testDir);
+        }
+    }
+
+    protected abstract Set<Class> getModels();
+
+
+    private static void ensureTempDirCreated() throws IOException {
+        if (ourTempDir != null) return;
+
+        ourTempDir = new File(FileUtil.getTempDirectory(), "gradleTests");
+        FileUtil.delete(ourTempDir);
+        FileUtil.ensureExists(ourTempDir);
+    }
+
+    public static class DistributionLocator {
+        private static final String RELEASE_REPOSITORY_ENV = "GRADLE_RELEASE_REPOSITORY";
+        private static final String SNAPSHOT_REPOSITORY_ENV = "GRADLE_SNAPSHOT_REPOSITORY";
+        private static final String GRADLE_RELEASE_REPO = "https://services.gradle.org/distributions";
+        private static final String GRADLE_SNAPSHOT_REPO = "https://services.gradle.org/distributions-snapshots";
+
+        @NotNull private final String myReleaseRepoUrl;
+        @NotNull private final String mySnapshotRepoUrl;
+
+        public DistributionLocator() {
+            this(DistributionLocator.getRepoUrl(false), DistributionLocator.getRepoUrl(true));
+        }
+
+        public DistributionLocator(@NotNull String releaseRepoUrl, @NotNull String snapshotRepoUrl) {
+            myReleaseRepoUrl = releaseRepoUrl;
+            mySnapshotRepoUrl = snapshotRepoUrl;
+        }
+
+        @NotNull
+        public URI getDistributionFor(@NotNull GradleVersion version) throws URISyntaxException {
+            return getDistribution(getDistributionRepository(version), version, "gradle", "bin");
+        }
+
+        @NotNull
+        private String getDistributionRepository(@NotNull GradleVersion version) {
+            return version.isSnapshot() ? mySnapshotRepoUrl : myReleaseRepoUrl;
+        }
+
+        private static URI getDistribution(
+                @NotNull String repositoryUrl,
+                @NotNull GradleVersion version,
+                @NotNull String archiveName,
+                @NotNull String archiveClassifier
+        ) throws URISyntaxException {
+            return new URI(String.format("%s/%s-%s-%s.zip", repositoryUrl, archiveName, version.getVersion(), archiveClassifier));
+        }
+
+        @NotNull
+        public static String getRepoUrl(boolean isSnapshotUrl) {
+            String envRepoUrl = System.getenv(isSnapshotUrl ? SNAPSHOT_REPOSITORY_ENV : RELEASE_REPOSITORY_ENV);
+            if (envRepoUrl != null) return envRepoUrl;
+
+            return isSnapshotUrl ? GRADLE_SNAPSHOT_REPO : GRADLE_RELEASE_REPO;
+        }
+    }
+}

idea/idea-jvm/src/org/jetbrains/kotlin/idea/actions/ShowKotlinBytecodeAction.kt

@@ -30,15 +30,18 @@ class ShowKotlinBytecodeAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
         val project = e.project ?: return
         val toolWindowManager = ToolWindowManager.getInstance(project)
-        var toolWindow = toolWindowManager.getToolWindow(TOOLWINDOW_ID)
-        if (toolWindow == null) {
-            toolWindow = toolWindowManager.registerToolWindow(TOOLWINDOW_ID, false, ToolWindowAnchor.RIGHT)
-            toolWindow.icon = KotlinIcons.SMALL_LOGO_13
 
-            val contentManager = toolWindow.contentManager
-            val contentFactory = ContentFactory.SERVICE.getInstance()
-            contentManager.addContent(contentFactory.createContent(KotlinBytecodeToolWindow(project, toolWindow), "", false))
-        }
+        val toolWindow = toolWindowManager.getToolWindow(TOOLWINDOW_ID) ?: toolWindowManager.registerToolWindow(
+            TOOLWINDOW_ID,
+            false,
+            ToolWindowAnchor.RIGHT,
+        )
+            .apply {
+                setIcon(KotlinIcons.SMALL_LOGO_13)
+                val contentFactory = ContentFactory.SERVICE.getInstance()
+                contentManager.addContent(contentFactory.createContent(KotlinBytecodeToolWindow(project, this), "", false))
+            }
+
         toolWindow.activate(null)
     }
 

idea/idea-jvm/src/org/jetbrains/kotlin/idea/actions/ShowKotlinBytecodeAction.kt.193

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.actions
+
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.wm.ToolWindowAnchor
+import com.intellij.openapi.wm.ToolWindowManager
+import com.intellij.ui.content.ContentFactory
+import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.idea.KotlinIcons
+import org.jetbrains.kotlin.idea.internal.KotlinBytecodeToolWindow
+
+class ShowKotlinBytecodeAction : AnAction() {
+    override fun actionPerformed(e: AnActionEvent) {
+        val project = e.project ?: return
+        val toolWindowManager = ToolWindowManager.getInstance(project)
+        var toolWindow = toolWindowManager.getToolWindow(TOOLWINDOW_ID)
+        if (toolWindow == null) {
+            toolWindow = toolWindowManager.registerToolWindow(TOOLWINDOW_ID, false, ToolWindowAnchor.RIGHT)
+            toolWindow.icon = KotlinIcons.SMALL_LOGO_13
+
+            val contentManager = toolWindow.contentManager
+            val contentFactory = ContentFactory.SERVICE.getInstance()
+            contentManager.addContent(contentFactory.createContent(KotlinBytecodeToolWindow(project, toolWindow), "", false))
+        }
+        toolWindow.activate(null)
+    }
+
+    override fun update(e: AnActionEvent) {
+        val file = e.getData(CommonDataKeys.PSI_FILE)
+        e.presentation.isEnabled = e.project != null && file?.fileType == KotlinFileType.INSTANCE
+    }
+
+    companion object {
+        const val TOOLWINDOW_ID = "Kotlin Bytecode"
+    }
+}

idea/idea-jvm/src/org/jetbrains/kotlin/idea/scratch/output/ToolWindowScratchOutputHandler.kt

@@ -20,12 +20,12 @@ import com.intellij.execution.filters.OpenFileHyperlinkInfo
 import com.intellij.execution.impl.ConsoleViewImpl
 import com.intellij.execution.runners.ExecutionUtil
 import com.intellij.execution.ui.ConsoleViewContentType
+import com.intellij.ide.scratch.ScratchFileType
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.TransactionGuard
 import com.intellij.openapi.command.WriteCommandAction
 import com.intellij.openapi.editor.ex.EditorEx
-import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.wm.ToolWindow
@@ -113,8 +113,8 @@ private class ToolWindowScratchOutputHandler(private val parentDisposable: Dispo
                     OpenFileHyperlinkInfo(
                         project,
                         psiFile.virtualFile,
-                        expression.lineStart,
-                    ),
+                        expression.lineStart
+                    )
                 )
                 print(" ", ConsoleViewContentType.NORMAL_OUTPUT)
             }
@@ -149,7 +149,7 @@ private class ToolWindowScratchOutputHandler(private val parentDisposable: Dispo
                 toolWindow.show(null)
             }
 
-            toolWindow.icon = ExecutionUtil.getLiveIndicator(scratchIcon())
+            toolWindow.setIcon(ExecutionUtil.getLiveIndicator(ScratchFileType.INSTANCE.icon))
         }
     }
 
@@ -168,7 +168,7 @@ private class ToolWindowScratchOutputHandler(private val parentDisposable: Dispo
                 toolWindow.hide(null)
             }
 
-            toolWindow.icon = scratchIcon()
+            toolWindow.setIcon(ScratchFileType.INSTANCE.icon ?: error("Text icon is expected to be present"))
         }
     }
 
@@ -187,22 +187,18 @@ private class ToolWindowScratchOutputHandler(private val parentDisposable: Dispo
         val project = file.project
         val toolWindowManager = ToolWindowManager.getInstance(project)
         toolWindowManager.registerToolWindow(ScratchToolWindowFactory.ID, true, ToolWindowAnchor.BOTTOM)
-        val window = toolWindowManager.getToolWindow(ScratchToolWindowFactory.ID)
+        val window =
+            toolWindowManager.getToolWindow(ScratchToolWindowFactory.ID) ?: error("ScratchToolWindowFactory.ID should be registered")
         ScratchToolWindowFactory().createToolWindowContent(project, window)
 
-        Disposer.register(
-            parentDisposable,
-            Disposable {
-                toolWindowManager.unregisterToolWindow(ScratchToolWindowFactory.ID)
-            },
-        )
+        Disposer.register(parentDisposable, Disposable {
+            toolWindowManager.unregisterToolWindow(ScratchToolWindowFactory.ID)
+        })
 
         return window
     }
 }
 
-private fun scratchIcon() = PlainTextFileType.INSTANCE.icon
-
 private fun getLineInfo(psiFile: PsiFile, expression: ScratchExpression) =
     "${psiFile.name}:${expression.lineStart + 1}"
 
@@ -213,8 +209,8 @@ private class ScratchToolWindowFactory : ToolWindowFactory {
 
     override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
         val consoleView = ConsoleViewImpl(project, true)
-        toolWindow.isToHideOnEmptyContent = true
-        toolWindow.icon = scratchIcon()
+        toolWindow.setToHideOnEmptyContent(true)
+        toolWindow.setIcon(ScratchFileType.INSTANCE.icon ?: error("Text icon should be present"))
         toolWindow.hide(null)
 
         val contentManager = toolWindow.contentManager
@@ -242,33 +238,27 @@ private object TestOutputHandler : ScratchOutputHandlerAdapter() {
     }
 
     override fun onFinish(file: ScratchFile) {
-        TransactionGuard.submitTransaction(
-            file.project,
-            Runnable {
-                val psiFile = file.getPsiFile()
-                    ?: error(
-                        "PsiFile cannot be found for scratch to render inlays in tests:\n" +
-                                "project.isDisposed = ${file.project.isDisposed}\n" +
-                                "inlays = ${inlays.joinToString { it.second }}\n" +
-                                "errors = ${errors.joinToString()}",
-                    )
+        TransactionGuard.submitTransaction(file.project, Runnable {
+            val psiFile = file.getPsiFile()
+                ?: error(
+                    "PsiFile cannot be found for scratch to render inlays in tests:\n" +
+                            "project.isDisposed = ${file.project.isDisposed}\n" +
+                            "inlays = ${inlays.joinToString { it.second }}\n" +
+                            "errors = ${errors.joinToString()}"
+                )
 
-                if (inlays.isNotEmpty()) {
-                    testPrint(
-                        psiFile,
-                        inlays.map { (expression, text) ->
-                            "/** ${getLineInfo(psiFile, expression)} $text */"
-                        },
-                    )
-                    inlays.clear()
-                }
+            if (inlays.isNotEmpty()) {
+                testPrint(psiFile, inlays.map { (expression, text) ->
+                    "/** ${getLineInfo(psiFile, expression)} $text */"
+                })
+                inlays.clear()
+            }
 
-                if (errors.isNotEmpty()) {
-                    testPrint(psiFile, listOf(errors.joinToString(prefix = "/** ", postfix = " */")))
-                    errors.clear()
-                }
-            },
-        )
+            if (errors.isNotEmpty()) {
+                testPrint(psiFile, listOf(errors.joinToString(prefix = "/** ", postfix = " */")))
+                errors.clear()
+            }
+        })
     }
 
     private fun testPrint(file: PsiFile, comments: List<String>) {
@@ -276,7 +266,7 @@ private object TestOutputHandler : ScratchOutputHandlerAdapter() {
             for (comment in comments) {
                 file.addAfter(
                     KtPsiFactory(file.project).createComment(comment),
-                    file.lastChild,
+                    file.lastChild
                 )
             }
         }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/scratch/output/ToolWindowScratchOutputHandler.kt.193

@@ -0,0 +1,284 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.scratch.output
+
+import com.intellij.execution.filters.OpenFileHyperlinkInfo
+import com.intellij.execution.impl.ConsoleViewImpl
+import com.intellij.execution.runners.ExecutionUtil
+import com.intellij.execution.ui.ConsoleViewContentType
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.TransactionGuard
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.editor.ex.EditorEx
+import com.intellij.openapi.fileTypes.PlainTextFileType
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.wm.ToolWindow
+import com.intellij.openapi.wm.ToolWindowAnchor
+import com.intellij.openapi.wm.ToolWindowFactory
+import com.intellij.openapi.wm.ToolWindowManager
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.idea.scratch.ScratchExpression
+import org.jetbrains.kotlin.idea.scratch.ScratchFile
+import org.jetbrains.kotlin.psi.KtPsiFactory
+
+/**
+ * Method to retrieve shared instance of scratches ToolWindow output handler.
+ *
+ * [releaseToolWindowHandler] must be called for every output handler received from this method.
+ *
+ * Can be called from EDT only.
+ *
+ * @return new toolWindow output handler if one does not exist, otherwise returns the existing one. When application in test mode,
+ * returns [TestOutputHandler].
+ */
+fun requestToolWindowHandler(): ScratchOutputHandler {
+    return if (ApplicationManager.getApplication().isUnitTestMode) {
+        TestOutputHandler
+    } else {
+        ScratchToolWindowHandlerKeeper.requestOutputHandler()
+    }
+}
+
+/**
+ * Should be called once with the output handler received from the [requestToolWindowHandler] call.
+ *
+ * When release is called for every request, the output handler is actually disposed.
+ *
+ * When application in test mode, does nothing.
+ *
+ * Can be called from EDT only.
+ */
+fun releaseToolWindowHandler(scratchOutputHandler: ScratchOutputHandler) {
+    if (!ApplicationManager.getApplication().isUnitTestMode) {
+        ScratchToolWindowHandlerKeeper.releaseOutputHandler(scratchOutputHandler)
+    }
+}
+
+/**
+ * Implements logic of shared pointer for the toolWindow output handler.
+ *
+ * Not thread safe! Can be used only from the EDT.
+ */
+private object ScratchToolWindowHandlerKeeper {
+    private var toolWindowHandler: ScratchOutputHandler? = null
+    private var toolWindowDisposable = Disposer.newDisposable()
+    private var counter = 0
+
+    fun requestOutputHandler(): ScratchOutputHandler {
+        if (counter == 0) {
+            toolWindowHandler = ToolWindowScratchOutputHandler(toolWindowDisposable)
+        }
+
+        counter += 1
+        return toolWindowHandler!!
+    }
+
+    fun releaseOutputHandler(scratchOutputHandler: ScratchOutputHandler) {
+        require(counter > 0) { "Counter is $counter, nothing to release!" }
+        require(toolWindowHandler === scratchOutputHandler) { "$scratchOutputHandler differs from stored $toolWindowHandler" }
+
+        counter -= 1
+        if (counter == 0) {
+            Disposer.dispose(toolWindowDisposable)
+            toolWindowDisposable = Disposer.newDisposable()
+            toolWindowHandler = null
+        }
+    }
+}
+
+private class ToolWindowScratchOutputHandler(private val parentDisposable: Disposable) : ScratchOutputHandlerAdapter() {
+
+    override fun handle(file: ScratchFile, expression: ScratchExpression, output: ScratchOutput) {
+        printToConsole(file) {
+            val psiFile = file.getPsiFile()
+            if (psiFile != null) {
+                printHyperlink(
+                    getLineInfo(psiFile, expression),
+                    OpenFileHyperlinkInfo(
+                        project,
+                        psiFile.virtualFile,
+                        expression.lineStart,
+                    ),
+                )
+                print(" ", ConsoleViewContentType.NORMAL_OUTPUT)
+            }
+            print(output.text, output.type.convert())
+        }
+    }
+
+    override fun error(file: ScratchFile, message: String) {
+        printToConsole(file) {
+            print(message, ConsoleViewContentType.ERROR_OUTPUT)
+        }
+    }
+
+    private fun printToConsole(file: ScratchFile, print: ConsoleViewImpl.() -> Unit) {
+        ApplicationManager.getApplication().invokeLater {
+            val project = file.project.takeIf { !it.isDisposed } ?: return@invokeLater
+
+            val toolWindow = getToolWindow(project) ?: createToolWindow(file)
+
+            val contents = toolWindow.contentManager.contents
+            for (content in contents) {
+                val component = content.component
+                if (component is ConsoleViewImpl) {
+                    component.print()
+                    component.print("\n", ConsoleViewContentType.NORMAL_OUTPUT)
+                }
+            }
+
+            toolWindow.setAvailable(true, null)
+
+            if (!file.options.isInteractiveMode) {
+                toolWindow.show(null)
+            }
+
+            toolWindow.icon = ExecutionUtil.getLiveIndicator(scratchIcon())
+        }
+    }
+
+    override fun clear(file: ScratchFile) {
+        ApplicationManager.getApplication().invokeLater {
+            val toolWindow = getToolWindow(file.project) ?: return@invokeLater
+            val contents = toolWindow.contentManager.contents
+            for (content in contents) {
+                val component = content.component
+                if (component is ConsoleViewImpl) {
+                    component.clear()
+                }
+            }
+
+            if (!file.options.isInteractiveMode) {
+                toolWindow.hide(null)
+            }
+
+            toolWindow.icon = scratchIcon()
+        }
+    }
+
+    private fun ScratchOutputType.convert() = when (this) {
+        ScratchOutputType.OUTPUT -> ConsoleViewContentType.SYSTEM_OUTPUT
+        ScratchOutputType.RESULT -> ConsoleViewContentType.NORMAL_OUTPUT
+        ScratchOutputType.ERROR -> ConsoleViewContentType.ERROR_OUTPUT
+    }
+
+    private fun getToolWindow(project: Project): ToolWindow? {
+        val toolWindowManager = ToolWindowManager.getInstance(project)
+        return toolWindowManager.getToolWindow(ScratchToolWindowFactory.ID)
+    }
+
+    private fun createToolWindow(file: ScratchFile): ToolWindow {
+        val project = file.project
+        val toolWindowManager = ToolWindowManager.getInstance(project)
+        toolWindowManager.registerToolWindow(ScratchToolWindowFactory.ID, true, ToolWindowAnchor.BOTTOM)
+        val window = toolWindowManager.getToolWindow(ScratchToolWindowFactory.ID)
+        ScratchToolWindowFactory().createToolWindowContent(project, window)
+
+        Disposer.register(
+            parentDisposable,
+            Disposable {
+                toolWindowManager.unregisterToolWindow(ScratchToolWindowFactory.ID)
+            },
+        )
+
+        return window
+    }
+}
+
+private fun scratchIcon() = PlainTextFileType.INSTANCE.icon
+
+private fun getLineInfo(psiFile: PsiFile, expression: ScratchExpression) =
+    "${psiFile.name}:${expression.lineStart + 1}"
+
+private class ScratchToolWindowFactory : ToolWindowFactory {
+    companion object {
+        const val ID = "Scratch Output"
+    }
+
+    override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
+        val consoleView = ConsoleViewImpl(project, true)
+        toolWindow.isToHideOnEmptyContent = true
+        toolWindow.icon = scratchIcon()
+        toolWindow.hide(null)
+
+        val contentManager = toolWindow.contentManager
+        val content = contentManager.factory.createContent(consoleView.component, null, false)
+        contentManager.addContent(content)
+        val editor = consoleView.editor
+        if (editor is EditorEx) {
+            editor.isRendererMode = true
+        }
+
+        Disposer.register(project, consoleView)
+    }
+}
+
+private object TestOutputHandler : ScratchOutputHandlerAdapter() {
+    private val errors = arrayListOf<String>()
+    private val inlays = arrayListOf<Pair<ScratchExpression, String>>()
+
+    override fun handle(file: ScratchFile, expression: ScratchExpression, output: ScratchOutput) {
+        inlays.add(expression to output.text)
+    }
+
+    override fun error(file: ScratchFile, message: String) {
+        errors.add(message)
+    }
+
+    override fun onFinish(file: ScratchFile) {
+        TransactionGuard.submitTransaction(
+            file.project,
+            Runnable {
+                val psiFile = file.getPsiFile()
+                    ?: error(
+                        "PsiFile cannot be found for scratch to render inlays in tests:\n" +
+                                "project.isDisposed = ${file.project.isDisposed}\n" +
+                                "inlays = ${inlays.joinToString { it.second }}\n" +
+                                "errors = ${errors.joinToString()}",
+                    )
+
+                if (inlays.isNotEmpty()) {
+                    testPrint(
+                        psiFile,
+                        inlays.map { (expression, text) ->
+                            "/** ${getLineInfo(psiFile, expression)} $text */"
+                        },
+                    )
+                    inlays.clear()
+                }
+
+                if (errors.isNotEmpty()) {
+                    testPrint(psiFile, listOf(errors.joinToString(prefix = "/** ", postfix = " */")))
+                    errors.clear()
+                }
+            },
+        )
+    }
+
+    private fun testPrint(file: PsiFile, comments: List<String>) {
+        WriteCommandAction.runWriteCommandAction(file.project) {
+            for (comment in comments) {
+                file.addAfter(
+                    KtPsiFactory(file.project).createComment(comment),
+                    file.lastChild,
+                )
+            }
+        }
+    }
+}

idea/idea-jvm/src/org/jetbrains/kotlin/idea/scratch/ui/TextEditorWithPreview.java

@@ -22,7 +22,6 @@ import com.intellij.openapi.wm.IdeFocusManager;
 import com.intellij.ui.JBSplitter;
 import com.intellij.util.ui.JBUI;
 import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinJvmBundle;
@@ -473,7 +472,6 @@ class SplitEditorToolbar extends JPanel implements Disposable {
     }
 
     @Deprecated
-    @ApiStatus.ScheduledForRemoval
     public void addGutterToTrack(@NotNull EditorGutterComponentEx gutterComponentEx) {}
 
     public void refresh() {
@@ -481,7 +479,6 @@ class SplitEditorToolbar extends JPanel implements Disposable {
     }
 
     @Deprecated
-    @ApiStatus.ScheduledForRemoval
     @Override
     public void dispose() {}
 }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/scratch/ui/TextEditorWithPreview.java.193

@@ -0,0 +1,487 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.scratch.ui;
+
+
+import com.intellij.codeHighlighting.BackgroundEditorHighlighter;
+import com.intellij.icons.AllIcons;
+import com.intellij.ide.structureView.StructureViewBuilder;
+import com.intellij.ide.util.PropertiesComponent;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.editor.ex.EditorGutterComponentEx;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.UserDataHolderBase;
+import com.intellij.openapi.wm.IdeFocusManager;
+import com.intellij.ui.JBSplitter;
+import com.intellij.util.ui.JBUI;
+import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.idea.KotlinJvmBundle;
+
+import javax.swing.*;
+import java.awt.*;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Two panel editor with three states: Editor, Preview and Editor with Preview.
+ * Based on SplitFileEditor by Valentin Fondaratov
+ * <p/>
+ * <b>NOTE:</b> This class is a copy of {@link com.intellij.openapi.fileEditor.TextEditorWithPreview} from the most recent intellij-community
+ * repository. We cannot use bundled version of this class because it doesn't yet have customization methods
+ * (namely {@link TextEditorWithPreview#createLeftToolbarActionGroup()}).
+ * <p/>
+ * {@link SplitEditorToolbar} is also copied from the platform.
+ * <p/>
+ * This class also may have some minimal customizations to allow tracking when its layout have been changed. In the future we hope to
+ * remove this copied class entirely and to use the bundled version.
+ */
+public class TextEditorWithPreview extends UserDataHolderBase implements FileEditor {
+    protected final TextEditor myEditor;
+    protected final FileEditor myPreview;
+    @NotNull
+    private final MyListenersMultimap myListenersGenerator = new MyListenersMultimap();
+    private Layout myLayout;
+    private JComponent myComponent;
+    private SplitEditorToolbar myToolbarWrapper;
+    private final String myName;
+
+    public TextEditorWithPreview(@NotNull TextEditor editor, @NotNull FileEditor preview, @NotNull String editorName) {
+        myEditor = editor;
+        myPreview = preview;
+        myName = editorName;
+    }
+
+    public TextEditorWithPreview(@NotNull TextEditor editor, @NotNull FileEditor preview) {
+        this(editor, preview, "TextEditorWithPreview");
+    }
+
+    @Nullable
+    @Override
+    public BackgroundEditorHighlighter getBackgroundHighlighter() {
+        return myEditor.getBackgroundHighlighter();
+    }
+
+    @Nullable
+    @Override
+    public FileEditorLocation getCurrentLocation() {
+        return myEditor.getCurrentLocation();
+    }
+
+    @Nullable
+    @Override
+    public StructureViewBuilder getStructureViewBuilder() {
+        return myEditor.getStructureViewBuilder();
+    }
+
+    @Override
+    public void dispose() {
+        Disposer.dispose(myEditor);
+        Disposer.dispose(myPreview);
+    }
+
+    @Override
+    public void selectNotify() {
+        myEditor.selectNotify();
+        myPreview.selectNotify();
+    }
+
+    @Override
+    public void deselectNotify() {
+        myEditor.deselectNotify();
+        myPreview.deselectNotify();
+    }
+
+    @NotNull
+    @Override
+    public JComponent getComponent() {
+        if (myComponent == null) {
+            final JBSplitter splitter = new JBSplitter(false, 0.5f, 0.15f, 0.85f);
+            splitter.setSplitterProportionKey(getSplitterProportionKey());
+            splitter.setFirstComponent(myEditor.getComponent());
+            splitter.setSecondComponent(myPreview.getComponent());
+            splitter.setDividerWidth(3);
+
+            myToolbarWrapper = createMarkdownToolbarWrapper(splitter);
+            Disposer.register(this, myToolbarWrapper);
+
+            if (myLayout == null) {
+                String lastUsed = PropertiesComponent.getInstance().getValue(getLayoutPropertyName());
+                setLayout(Layout.fromName(lastUsed, Layout.SHOW_EDITOR_AND_PREVIEW));
+            }
+            adjustEditorsVisibility();
+
+            myComponent = JBUI.Panels.simplePanel(splitter).addToTop(myToolbarWrapper);
+        }
+        return myComponent;
+    }
+
+    @NotNull
+    private SplitEditorToolbar createMarkdownToolbarWrapper (@NotNull JComponent targetComponentForActions) {
+        final ActionToolbar leftToolbar = createToolbar();
+        if (leftToolbar != null) {
+            leftToolbar.setTargetComponent(targetComponentForActions);
+            leftToolbar.setReservePlaceAutoPopupIcon(false);
+        }
+
+        final ActionToolbar rightToolbar = createRightToolbar();
+        rightToolbar.setTargetComponent(targetComponentForActions);
+        rightToolbar.setReservePlaceAutoPopupIcon(false);
+
+        return new SplitEditorToolbar(leftToolbar, rightToolbar);
+    }
+
+    @Override
+    public void setState(@NotNull FileEditorState state) {
+        if (state instanceof MyFileEditorState) {
+            final MyFileEditorState compositeState = (MyFileEditorState)state;
+            if (compositeState.getFirstState() != null) {
+                myEditor.setState(compositeState.getFirstState());
+            }
+            if (compositeState.getSecondState() != null) {
+                myPreview.setState(compositeState.getSecondState());
+            }
+            if (compositeState.getSplitLayout() != null) {
+                setLayout(compositeState.getSplitLayout());
+                invalidateLayout();
+            }
+        }
+    }
+
+    private void adjustEditorsVisibility() {
+        myEditor.getComponent().setVisible(myLayout == Layout.SHOW_EDITOR || myLayout == Layout.SHOW_EDITOR_AND_PREVIEW);
+        myPreview.getComponent().setVisible(myLayout == Layout.SHOW_PREVIEW || myLayout == Layout.SHOW_EDITOR_AND_PREVIEW);
+    }
+
+    private void invalidateLayout() {
+        adjustEditorsVisibility();
+        myToolbarWrapper.refresh();
+        myComponent.repaint();
+
+        final JComponent focusComponent = getPreferredFocusedComponent();
+        if (focusComponent != null) {
+            IdeFocusManager.findInstanceByComponent(focusComponent).requestFocus(focusComponent, true);
+        }
+    }
+
+    @NotNull
+    protected String getSplitterProportionKey() {
+        return "TextEditorWithPreview.SplitterProportionKey";
+    }
+
+    @Nullable
+    @Override
+    public JComponent getPreferredFocusedComponent() {
+        switch (myLayout) {
+            case SHOW_EDITOR_AND_PREVIEW:
+            case SHOW_EDITOR:
+                return myEditor.getPreferredFocusedComponent();
+            case SHOW_PREVIEW:
+                return myPreview.getPreferredFocusedComponent();
+            default:
+                throw new IllegalStateException(myLayout.myName);
+        }
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return myName;
+    }
+
+    @NotNull
+    @Override
+    public FileEditorState getState(@NotNull FileEditorStateLevel level) {
+        return new MyFileEditorState(myLayout, myEditor.getState(level), myPreview.getState(level));
+    }
+
+    @Override
+    public void addPropertyChangeListener(@NotNull PropertyChangeListener listener) {
+        myEditor.addPropertyChangeListener(listener);
+        myPreview.addPropertyChangeListener(listener);
+
+        final DoublingEventListenerDelegate delegate = myListenersGenerator.addListenerAndGetDelegate(listener);
+        myEditor.addPropertyChangeListener(delegate);
+        myPreview.addPropertyChangeListener(delegate);
+    }
+
+    @Override
+    public void removePropertyChangeListener(@NotNull PropertyChangeListener listener) {
+        myEditor.removePropertyChangeListener(listener);
+        myPreview.removePropertyChangeListener(listener);
+
+        final DoublingEventListenerDelegate delegate = myListenersGenerator.removeListenerAndGetDelegate(listener);
+        if (delegate != null) {
+            myEditor.removePropertyChangeListener(delegate);
+            myPreview.removePropertyChangeListener(delegate);
+        }
+    }
+
+    @NotNull
+    public TextEditor getTextEditor() {
+        return myEditor;
+    }
+
+    public Layout getLayout() {
+        return myLayout;
+    }
+
+    protected void setLayout(@NotNull Layout layout) {
+        myLayout = layout;
+    }
+
+    static class MyFileEditorState implements FileEditorState {
+        private final Layout mySplitLayout;
+        private final FileEditorState myFirstState;
+        private final FileEditorState mySecondState;
+
+        MyFileEditorState(Layout layout, FileEditorState firstState, FileEditorState secondState) {
+            mySplitLayout = layout;
+            myFirstState = firstState;
+            mySecondState = secondState;
+        }
+
+        @Nullable
+        public Layout getSplitLayout() {
+            return mySplitLayout;
+        }
+
+        @Nullable
+        public FileEditorState getFirstState() {
+            return myFirstState;
+        }
+
+        @Nullable
+        public FileEditorState getSecondState() {
+            return mySecondState;
+        }
+
+        @Override
+        public boolean canBeMergedWith(FileEditorState otherState, FileEditorStateLevel level) {
+            return otherState instanceof MyFileEditorState
+                   && (myFirstState == null || myFirstState.canBeMergedWith(((MyFileEditorState)otherState).myFirstState, level))
+                   && (mySecondState == null || mySecondState.canBeMergedWith(((MyFileEditorState)otherState).mySecondState, level));
+        }
+    }
+
+    @Override
+    public boolean isModified() {
+        return myEditor.isModified() || myPreview.isModified();
+    }
+
+    @Override
+    public boolean isValid() {
+        return myEditor.isValid() && myPreview.isValid();
+    }
+
+    private class DoublingEventListenerDelegate implements PropertyChangeListener {
+        @NotNull
+        private final PropertyChangeListener myDelegate;
+
+        private DoublingEventListenerDelegate(@NotNull PropertyChangeListener delegate) {
+            myDelegate = delegate;
+        }
+
+        @Override
+        public void propertyChange(PropertyChangeEvent evt) {
+            myDelegate.propertyChange(
+                    new PropertyChangeEvent(TextEditorWithPreview.this, evt.getPropertyName(), evt.getOldValue(), evt.getNewValue()));
+        }
+    }
+
+    private class MyListenersMultimap {
+        private final Map<PropertyChangeListener, Pair<Integer, DoublingEventListenerDelegate>> myMap = new HashMap<>();
+
+        @NotNull
+        public DoublingEventListenerDelegate addListenerAndGetDelegate(@NotNull PropertyChangeListener listener) {
+            if (!myMap.containsKey(listener)) {
+                myMap.put(listener, Pair.create(1, new DoublingEventListenerDelegate(listener)));
+            }
+            else {
+                final Pair<Integer, DoublingEventListenerDelegate> oldPair = myMap.get(listener);
+                myMap.put(listener, Pair.create(oldPair.getFirst() + 1, oldPair.getSecond()));
+            }
+
+            return myMap.get(listener).getSecond();
+        }
+
+        @Nullable
+        public DoublingEventListenerDelegate removeListenerAndGetDelegate(@NotNull PropertyChangeListener listener) {
+            final Pair<Integer, DoublingEventListenerDelegate> oldPair = myMap.get(listener);
+            if (oldPair == null) {
+                return null;
+            }
+
+            if (oldPair.getFirst() == 1) {
+                myMap.remove(listener);
+            }
+            else {
+                myMap.put(listener, Pair.create(oldPair.getFirst() - 1, oldPair.getSecond()));
+            }
+            return oldPair.getSecond();
+        }
+    }
+
+    @Nullable
+    protected ActionToolbar createToolbar() {
+        ActionGroup actionGroup = createLeftToolbarActionGroup();
+        if (actionGroup != null) {
+            return ActionManager.getInstance().createActionToolbar("TextEditorWithPreview", actionGroup, true);
+        }
+        else {
+            return null;
+        }
+    }
+
+    @Nullable
+    protected ActionGroup createLeftToolbarActionGroup() {
+        return null;
+    }
+
+    @NotNull
+    private ActionToolbar createRightToolbar() {
+        final ActionGroup viewActions = createViewActionGroup();
+        final ActionGroup group = createRightToolbarActionGroup();
+        final ActionGroup rightToolbarActions = group == null
+                                                ? viewActions
+                                                : new DefaultActionGroup(group, Separator.create(), viewActions);
+        return ActionManager.getInstance().createActionToolbar("TextEditorWithPreview", rightToolbarActions, true);
+    }
+
+    @NotNull
+    protected ActionGroup createViewActionGroup() {
+        return new DefaultActionGroup(
+                getShowEditorAction(),
+                getShowEditorAndPreviewAction(),
+                getShowPreviewAction()
+        );
+    }
+
+    @Nullable
+    protected ActionGroup createRightToolbarActionGroup() {
+        return null;
+    }
+
+    @NotNull
+    protected ToggleAction getShowEditorAction() {
+        return new ChangeViewModeAction(Layout.SHOW_EDITOR);
+    }
+
+    @NotNull
+    protected ToggleAction getShowPreviewAction() {
+        return new ChangeViewModeAction(Layout.SHOW_PREVIEW);
+    }
+
+    @NotNull
+    protected ToggleAction getShowEditorAndPreviewAction() {
+        return new ChangeViewModeAction(Layout.SHOW_EDITOR_AND_PREVIEW);
+    }
+
+    public enum Layout {
+        SHOW_EDITOR(KotlinJvmBundle.message("editor.editor.only"), AllIcons.General.LayoutEditorOnly),
+        SHOW_PREVIEW(KotlinJvmBundle.message("editor.preview.only"), AllIcons.General.LayoutPreviewOnly),
+        SHOW_EDITOR_AND_PREVIEW(KotlinJvmBundle.message("editor.editor.and.preview"), AllIcons.General.LayoutEditorPreview);
+
+        private final String myName;
+        private final Icon myIcon;
+
+        Layout(String name, Icon icon) {
+            myName = name;
+            myIcon = icon;
+        }
+
+        public static Layout fromName(String name, Layout defaultValue) {
+            for (Layout layout : Layout.values()) {
+                if (layout.myName.equals(name)) {
+                    return layout;
+                }
+            }
+            return defaultValue;
+        }
+
+        public String getName() {
+            return myName;
+        }
+
+        public Icon getIcon() {
+            return myIcon;
+        }
+    }
+
+    private class ChangeViewModeAction extends ToggleAction implements DumbAware {
+        private final Layout myActionLayout;
+
+        ChangeViewModeAction(Layout layout) {
+            super(layout.getName(), layout.getName(), layout.getIcon());
+            myActionLayout = layout;
+        }
+
+        @Override
+        public boolean isSelected(@NotNull AnActionEvent e) {
+            return myLayout == myActionLayout;
+        }
+
+        @Override
+        public void setSelected(@NotNull AnActionEvent e, boolean state) {
+            if (state) {
+                setLayout(myActionLayout);
+                PropertiesComponent.getInstance().setValue(getLayoutPropertyName(), myLayout.myName, Layout.SHOW_EDITOR_AND_PREVIEW.myName);
+                adjustEditorsVisibility();
+            }
+        }
+    }
+
+    @NotNull
+    private String getLayoutPropertyName() {
+        return myName + "Layout";
+    }
+}
+
+class SplitEditorToolbar extends JPanel implements Disposable {
+
+    private final ActionToolbar myRightToolbar;
+
+    public SplitEditorToolbar(@Nullable ActionToolbar leftToolbar, @NotNull ActionToolbar rightToolbar) {
+        super(new GridBagLayout());
+        myRightToolbar = rightToolbar;
+
+        if (leftToolbar != null) {
+            add(leftToolbar.getComponent());
+        }
+
+        final JPanel centerPanel = new JPanel(new BorderLayout());
+        add(centerPanel, new GridBagConstraints(2, 0, 1, 1, 1.0, 1.0,
+                                                GridBagConstraints.CENTER, GridBagConstraints.BOTH, JBUI.emptyInsets(), 0, 0));
+
+        add(myRightToolbar.getComponent());
+
+        setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, UIUtil.CONTRAST_BORDER_COLOR));
+
+        if (leftToolbar != null) leftToolbar.updateActionsImmediately();
+        rightToolbar.updateActionsImmediately();
+    }
+
+    @Deprecated
+    @ApiStatus.ScheduledForRemoval
+    public void addGutterToTrack(@NotNull EditorGutterComponentEx gutterComponentEx) {}
+
+    public void refresh() {
+        myRightToolbar.updateActionsImmediately();
+    }
+
+    @Deprecated
+    @ApiStatus.ScheduledForRemoval
+    @Override
+    public void dispose() {}
+}

idea/idea-live-templates/tests/org/jetbrains/kotlin/idea/liveTemplates/compat.kt

@@ -11,5 +11,5 @@ import com.intellij.openapi.project.Project
 
 // BUNCH: 193
 fun setTemplateTestingCompat(project: Project, disposable: Disposable) {
-    TemplateManagerImpl.setTemplateTesting(project, disposable)
+    TemplateManagerImpl.setTemplateTesting(disposable)
 }

idea/idea-live-templates/tests/org/jetbrains/kotlin/idea/liveTemplates/compat.kt.193

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.liveTemplates
+
+import com.intellij.codeInsight.template.impl.TemplateManagerImpl
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.project.Project
+
+// BUNCH: 193
+fun setTemplateTestingCompat(project: Project, disposable: Disposable) {
+    TemplateManagerImpl.setTemplateTesting(project, disposable)
+}

idea/idea-repl/src/org/jetbrains/kotlin/console/ConsoleCompilerHelper.kt

@@ -41,12 +41,14 @@ class ConsoleCompilerHelper(
     }
 
     fun compileModule() {
-        if (ExecutionManager.getInstance(project).contentManager.removeRunContent(executor, contentDescriptor)) {
-            ProjectTaskManager.getInstance(project).build(module).onSuccess { executionResult ->
-                if (!module.isDisposed) {
-                    KotlinConsoleKeeper.getInstance(project).run(module, previousCompilationFailed = executionResult.hasErrors())
+        if (ExecutionManager.getInstance(project).getContentManager().removeRunContent(executor, contentDescriptor)) {
+            ProjectTaskManager.getInstance(project).build(arrayOf(module), object : ProjectTaskNotification {
+                override fun finished(context: ProjectTaskContext, executionResult: ProjectTaskResult) {
+                    if (!module.isDisposed) {
+                        KotlinConsoleKeeper.getInstance(project).run(module, previousCompilationFailed = executionResult.errors > 0)
+                    }
                 }
-            }
+            })
         }
     }
 }

idea/idea-repl/src/org/jetbrains/kotlin/console/ConsoleCompilerHelper.kt.193

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.console
+
+import com.intellij.execution.ExecutionManager
+import com.intellij.execution.Executor
+import com.intellij.execution.ui.RunContentDescriptor
+import com.intellij.openapi.compiler.CompilerManager
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.project.Project
+import com.intellij.task.ProjectTaskContext
+import com.intellij.task.ProjectTaskManager
+import com.intellij.task.ProjectTaskNotification
+import com.intellij.task.ProjectTaskResult
+
+class ConsoleCompilerHelper(
+    private val project: Project,
+    private val module: Module,
+    private val executor: Executor,
+    private val contentDescriptor: RunContentDescriptor
+) {
+
+    fun moduleIsUpToDate(): Boolean {
+        val compilerManager = CompilerManager.getInstance(project)
+        val compilerScope = compilerManager.createModuleCompileScope(module, true)
+        return compilerManager.isUpToDate(compilerScope)
+    }
+
+    fun compileModule() {
+        if (ExecutionManager.getInstance(project).contentManager.removeRunContent(executor, contentDescriptor)) {
+            ProjectTaskManager.getInstance(project).build(module).onSuccess { executionResult ->
+                if (!module.isDisposed) {
+                    KotlinConsoleKeeper.getInstance(project).run(module, previousCompilationFailed = executionResult.hasErrors())
+                }
+            }
+        }
+    }
+}

idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/compat.kt

@@ -13,8 +13,8 @@ import com.intellij.testFramework.propertyBased.MadTestingUtil
 
 // BUNCH: 193
 fun enableAllInspectionsCompat(project: Project, disposable: Disposable) {
-    MadTestingUtil.enableAllInspections(project, disposable)
+    MadTestingUtil.enableAllInspections(project)
 }
 
 // BUNCH: 193
-typealias TestApplicationManager = com.intellij.idea.IdeaTestApplication
+typealias TestApplicationManager = com.intellij.testFramework.TestApplicationManager

idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/compat.kt.193

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("UNUSED_PARAMETER")
+
+package org.jetbrains.kotlin.idea.perf
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.project.Project
+import com.intellij.testFramework.propertyBased.MadTestingUtil
+
+// BUNCH: 193
+fun enableAllInspectionsCompat(project: Project, disposable: Disposable) {
+    MadTestingUtil.enableAllInspections(project, disposable)
+}
+
+// BUNCH: 193
+typealias TestApplicationManager = com.intellij.idea.IdeaTestApplication

idea/performanceTests/test/org/jetbrains/kotlin/idea/testFramework/compat.kt

@@ -11,5 +11,5 @@ import com.intellij.openapi.project.ex.ProjectManagerEx
 // BUNCH: 193
 fun ProjectManagerEx.forceCloseProjectEx(project: Project, dispose: Boolean): Boolean {
     if (!dispose) error("dispose should be true")
-    return this.forceCloseProject(project, true)
+    return this.forceCloseProject(project)
 }

idea/performanceTests/test/org/jetbrains/kotlin/idea/testFramework/compat.kt.193

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.testFramework
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.project.ex.ProjectManagerEx
+
+// BUNCH: 193
+fun ProjectManagerEx.forceCloseProjectEx(project: Project, dispose: Boolean): Boolean {
+    if (!dispose) error("dispose should be true")
+    return this.forceCloseProject(project, true)
+}

idea/performanceTests/test/org/jetbrains/kotlin/idea/testFramework/gradleRoutines.kt

@@ -53,8 +53,6 @@ private fun _attachGradleProjectAndRefresh(
             ExternalSystemUtil.ensureToolWindowInitialized(project, GradleConstants.SYSTEM_ID)
         }
     }
-
-    ExternalProjectsManagerImpl.disableProjectWatcherAutoUpdate(project)
     val settings = ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID)
     if (settings.getLinkedProjectSettings(externalProjectPath) == null) {
         settings.linkProject(gradleProjectSettings)

idea/performanceTests/test/org/jetbrains/kotlin/idea/testFramework/gradleRoutines.kt.193

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.testFramework
+
+import com.intellij.openapi.externalSystem.importing.ImportSpecBuilder
+import com.intellij.openapi.externalSystem.service.execution.ProgressExecutionMode
+import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsManagerImpl
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
+import com.intellij.openapi.externalSystem.util.ExternalSystemUtil
+import com.intellij.openapi.project.DumbService
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectRootManager
+import org.jetbrains.plugins.gradle.service.project.open.setupGradleSettings
+import org.jetbrains.plugins.gradle.settings.GradleProjectSettings
+import org.jetbrains.plugins.gradle.util.GradleConstants
+import org.jetbrains.plugins.gradle.util.GradleLog
+import java.io.File
+import kotlin.test.assertNotNull
+
+fun refreshGradleProject(projectPath: String, project: Project) {
+    _importProject(File(projectPath).absolutePath, project)
+
+    dispatchAllInvocationEvents()
+}
+
+/**
+ * inspired by org.jetbrains.plugins.gradle.service.project.open.importProject(projectDirectory, project)
+ */
+private fun _importProject(projectPath: String, project: Project) {
+    GradleLog.LOG.info("Import project at $projectPath")
+    val projectSdk = ProjectRootManager.getInstance(project).projectSdk
+    assertNotNull(projectSdk, "project SDK not found for ${project.name} at $projectPath")
+    val gradleProjectSettings = GradleProjectSettings()
+    setupGradleSettings(gradleProjectSettings, projectPath, project, projectSdk)
+
+    _attachGradleProjectAndRefresh(gradleProjectSettings, project)
+}
+
+/**
+ * inspired by org.jetbrains.plugins.gradle.service.project.open.attachGradleProjectAndRefresh(gradleProjectSettings, project)
+ * except everything is MODAL_SYNC
+ */
+private fun _attachGradleProjectAndRefresh(
+    gradleProjectSettings: GradleProjectSettings,
+    project: Project
+) {
+    val externalProjectPath = gradleProjectSettings.externalProjectPath
+    ExternalProjectsManagerImpl.getInstance(project).runWhenInitialized {
+        DumbService.getInstance(project).runWhenSmart {
+            ExternalSystemUtil.ensureToolWindowInitialized(project, GradleConstants.SYSTEM_ID)
+        }
+    }
+
+    ExternalProjectsManagerImpl.disableProjectWatcherAutoUpdate(project)
+    val settings = ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID)
+    if (settings.getLinkedProjectSettings(externalProjectPath) == null) {
+        settings.linkProject(gradleProjectSettings)
+    }
+
+    StatefulTestGradleProjectRefreshCallback(externalProjectPath, project).use { callback ->
+        ExternalSystemUtil.refreshProject(
+            externalProjectPath,
+            ImportSpecBuilder(project, GradleConstants.SYSTEM_ID)
+                .use(ProgressExecutionMode.MODAL_SYNC)
+                .callback(callback)
+                .build()
+        )
+    }
+}

idea/resources/META-INF/extensions/ide.xml

@@ -73,6 +73,10 @@
 
         <extensionPoint qualifiedName="org.jetbrains.kotlin.experimentalFeature"
                         interface="org.jetbrains.kotlin.idea.configuration.ExperimentalFeature"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.foreignUsagesRenameProcessor"
+                        interface="org.jetbrains.kotlin.idea.refactoring.rename.ForeignUsagesRenameProcessor" dynamic="true"/>
+
     </extensionPoints>
 
     <extensions defaultExtensionNs="org.jetbrains.kotlin">

idea/resources/META-INF/gradle-java.xml

@@ -1,65 +1,59 @@
 <idea-plugin>
-  <extensions defaultExtensionNs="org.jetbrains.plugins.gradle">
-    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinMPPSourceSetsFrameworkSupportProvider"/>
-    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJavaFrameworkSupportProvider"/>
-    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSBrowserFrameworkSupportProvider"/>
-    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSNodeFrameworkSupportProvider"/>
-    <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinMPPFrameworkSupportProvider"/>
-    <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJavaFrameworkSupportProvider"/>
-    <kotlinDslFrameworkSupport
-        implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSBrowserFrameworkSupportProvider"/>
-    <kotlinDslFrameworkSupport
-        implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSNodeFrameworkSupportProvider"/>
-    <pluginDescriptions implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradlePluginDescription"/>
-    <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinNonJvmGutterConfigurator"/>
-    <projectResolve implementation="org.jetbrains.kotlin.idea.scripting.gradle.importing.KotlinDslScriptModelResolver" order="first"/>
-    <projectResolve implementation="org.jetbrains.kotlin.idea.cocoapods.KotlinCocoaPodsModelResolver" order="first"/>
-    <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectResolverExtension" order="first"/>
-    <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleCoroutineDebugProjectResolver" order="last"/>
-    <projectResolve implementation="org.jetbrains.kotlin.kapt.idea.KaptProjectResolverExtension" order="last"/>
-    <projectResolve implementation="org.jetbrains.kotlin.allopen.ide.AllOpenProjectResolverExtension" order="last"/>
-    <projectResolve implementation="org.jetbrains.kotlin.noarg.ide.NoArgProjectResolverExtension" order="last"/>
-    <projectResolve implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverProjectResolverExtension" order="last"/>
-  </extensions>
+    <extensions defaultExtensionNs="org.jetbrains.plugins.gradle">
+        <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinMPPSourceSetsFrameworkSupportProvider"/>
+        <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJavaFrameworkSupportProvider"/>
+        <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSBrowserFrameworkSupportProvider"/>
+        <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSNodeFrameworkSupportProvider"/>
+        <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinMPPFrameworkSupportProvider"/>
+        <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJavaFrameworkSupportProvider"/>
+        <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSBrowserFrameworkSupportProvider"/>
+        <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSNodeFrameworkSupportProvider"/>
+        <pluginDescriptions implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradlePluginDescription"/>
+        <projectResolve implementation="org.jetbrains.kotlin.idea.scripting.gradle.importing.KotlinDslScriptModelResolver" order="first"/>
+        <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectResolverExtension" order="first"/>
+        <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleCoroutineDebugProjectResolver" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.kapt.idea.KaptProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.allopen.ide.AllOpenProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.noarg.ide.NoArgProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverProjectResolverExtension" order="last"/>
+    </extensions>
 
-  <extensions defaultExtensionNs="com.intellij">
-    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSourceSetDataService"/>
-    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectDataService"/>
-    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleLibraryDataService"/>
-    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinTargetDataService"/>
-    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.KotlinJavaMPPSourceSetDataService"/>
-    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.klib.KotlinNativeLibraryDataService"/>
-    <externalSystemTaskNotificationListener implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsUpdater"/>
-    <editorNotificationProvider implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptOutOfSourceNotificationProvider"/>
+    <extensions defaultExtensionNs="com.intellij">
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSourceSetDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleLibraryDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinTargetDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.KotlinJavaMPPSourceSetDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.klib.KotlinNativeLibraryDataService"/>
+        <externalSystemTaskNotificationListener implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsUpdater"/>
+        <editorNotificationProvider implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptOutOfSourceNotificationProvider"/>
 
-    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestClassGradleConfigurationProducer"/>
-    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestClassGradleConfigurationProducer"/>
-    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestMethodGradleConfigurationProducer"/>
-    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestMethodGradleConfigurationProducer"/>
+        <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestClassGradleConfigurationProducer"/>
+        <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestClassGradleConfigurationProducer"/>
+        <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestMethodGradleConfigurationProducer"/>
+        <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestMethodGradleConfigurationProducer"/>
 
-  </extensions>
+    </extensions>
 
-  <extensions defaultExtensionNs="org.jetbrains.kotlin">
-    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.allopen.ide.AllOpenGradleProjectImportHandler"/>
-    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.scripting.idea.plugin.ScriptingGradleProjectImportHandler"/>
-    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.kapt.idea.KaptGradleProjectImportHandler"/>
-    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.noarg.ide.NoArgGradleProjectImportHandler"/>
-    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverGradleProjectImportHandler"/>
-    <gradleProjectImportHandler implementation="org.jetbrains.kotlinx.serialization.idea.KotlinSerializationGradleImportHandler"/>
+    <extensions defaultExtensionNs="org.jetbrains.kotlin">
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.allopen.ide.AllOpenGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.scripting.idea.plugin.ScriptingGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.kapt.idea.KaptGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.noarg.ide.NoArgGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlinx.serialization.idea.KotlinSerializationGradleImportHandler"/>
 
-    <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleModuleConfigurator"/>
-    <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinJsGradleModuleConfigurator"/>
-    <gradleModelFacade implementation="org.jetbrains.kotlin.idea.inspections.gradle.DefaultGradleModelFacade"/>
+        <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleModuleConfigurator"/>
+        <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinJsGradleModuleConfigurator"/>
+        <gradleModelFacade implementation="org.jetbrains.kotlin.idea.inspections.gradle.DefaultGradleModelFacade"/>
 
-    <scriptDefinitionContributor implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsContributor"
-                                 order="first"/>
-    <scriptAdditionalIdeaDependenciesProvider
-        implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptAdditionalIdeaDependenciesProvider"/>
+        <scriptDefinitionContributor implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsContributor" order="first"/>
+        <scriptAdditionalIdeaDependenciesProvider implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptAdditionalIdeaDependenciesProvider"/>
 
-    <moduleBuilder implementation="org.jetbrains.kotlin.ide.konan.gradle.KotlinGradleNativeMultiplatformModuleBuilder"/>
-    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSharedMultiplatformModuleBuilder"/>
-    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleWebMultiplatformModuleBuilder"/>
-    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileMultiplatformModuleBuilder"/>
-    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileSharedMultiplatformModuleBuilder"/>
-  </extensions>
+        <moduleBuilder implementation="org.jetbrains.kotlin.ide.konan.gradle.KotlinGradleNativeMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSharedMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleWebMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileSharedMultiplatformModuleBuilder"/>
+    </extensions>
 </idea-plugin>

idea/resources/META-INF/gradle-java.xml.193

@@ -0,0 +1,65 @@
+<idea-plugin>
+  <extensions defaultExtensionNs="org.jetbrains.plugins.gradle">
+    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinMPPSourceSetsFrameworkSupportProvider"/>
+    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJavaFrameworkSupportProvider"/>
+    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSBrowserFrameworkSupportProvider"/>
+    <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSNodeFrameworkSupportProvider"/>
+    <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinMPPFrameworkSupportProvider"/>
+    <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJavaFrameworkSupportProvider"/>
+    <kotlinDslFrameworkSupport
+        implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSBrowserFrameworkSupportProvider"/>
+    <kotlinDslFrameworkSupport
+        implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSNodeFrameworkSupportProvider"/>
+    <pluginDescriptions implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradlePluginDescription"/>
+    <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinNonJvmGutterConfigurator"/>
+    <projectResolve implementation="org.jetbrains.kotlin.idea.scripting.gradle.importing.KotlinDslScriptModelResolver" order="first"/>
+    <projectResolve implementation="org.jetbrains.kotlin.idea.cocoapods.KotlinCocoaPodsModelResolver" order="first"/>
+    <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectResolverExtension" order="first"/>
+    <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleCoroutineDebugProjectResolver" order="last"/>
+    <projectResolve implementation="org.jetbrains.kotlin.kapt.idea.KaptProjectResolverExtension" order="last"/>
+    <projectResolve implementation="org.jetbrains.kotlin.allopen.ide.AllOpenProjectResolverExtension" order="last"/>
+    <projectResolve implementation="org.jetbrains.kotlin.noarg.ide.NoArgProjectResolverExtension" order="last"/>
+    <projectResolve implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverProjectResolverExtension" order="last"/>
+  </extensions>
+
+  <extensions defaultExtensionNs="com.intellij">
+    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSourceSetDataService"/>
+    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectDataService"/>
+    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleLibraryDataService"/>
+    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinTargetDataService"/>
+    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.KotlinJavaMPPSourceSetDataService"/>
+    <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.klib.KotlinNativeLibraryDataService"/>
+    <externalSystemTaskNotificationListener implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsUpdater"/>
+    <editorNotificationProvider implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptOutOfSourceNotificationProvider"/>
+
+    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestClassGradleConfigurationProducer"/>
+    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestClassGradleConfigurationProducer"/>
+    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinJvmTestMethodGradleConfigurationProducer"/>
+    <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinMultiplatformJvmTestMethodGradleConfigurationProducer"/>
+
+  </extensions>
+
+  <extensions defaultExtensionNs="org.jetbrains.kotlin">
+    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.allopen.ide.AllOpenGradleProjectImportHandler"/>
+    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.scripting.idea.plugin.ScriptingGradleProjectImportHandler"/>
+    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.kapt.idea.KaptGradleProjectImportHandler"/>
+    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.noarg.ide.NoArgGradleProjectImportHandler"/>
+    <gradleProjectImportHandler implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverGradleProjectImportHandler"/>
+    <gradleProjectImportHandler implementation="org.jetbrains.kotlinx.serialization.idea.KotlinSerializationGradleImportHandler"/>
+
+    <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleModuleConfigurator"/>
+    <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinJsGradleModuleConfigurator"/>
+    <gradleModelFacade implementation="org.jetbrains.kotlin.idea.inspections.gradle.DefaultGradleModelFacade"/>
+
+    <scriptDefinitionContributor implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptDefinitionsContributor"
+                                 order="first"/>
+    <scriptAdditionalIdeaDependenciesProvider
+        implementation="org.jetbrains.kotlin.idea.scripting.gradle.GradleScriptAdditionalIdeaDependenciesProvider"/>
+
+    <moduleBuilder implementation="org.jetbrains.kotlin.ide.konan.gradle.KotlinGradleNativeMultiplatformModuleBuilder"/>
+    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSharedMultiplatformModuleBuilder"/>
+    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleWebMultiplatformModuleBuilder"/>
+    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileMultiplatformModuleBuilder"/>
+    <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileSharedMultiplatformModuleBuilder"/>
+  </extensions>
+</idea-plugin>

idea/resources/META-INF/gradle.xml

@@ -24,7 +24,8 @@
     </extensions>
 
     <extensions defaultExtensionNs="com.intellij">
-        <projectTaskRunner implementation="org.jetbrains.kotlin.idea.gradle.execution.KotlinMPPGradleProjectTaskRunner" order="first, before gradle"/>
+        <projectTaskRunner implementation="org.jetbrains.kotlin.idea.gradle.execution.KotlinMPPGradleProjectTaskRunner"
+                           id="gradle.mpp" order="first, before gradle"/>
         <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinSourceSetDataService"/>
         <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectSettingsDataService"/>
 

idea/resources/META-INF/jvm.xml

@@ -1,5 +1,9 @@
 <idea-plugin>
 
+    <extensions defaultExtensionNs="org.jetbrains.uast">
+        <generate.uastCodeGenerationPlugin implementation="org.jetbrains.uast.kotlin.generate.KotlinUastCodeGenerationPlugin"/>
+    </extensions>
+
     <extensions defaultExtensionNs="com.intellij">
         <postStartupActivity implementation="org.jetbrains.kotlin.idea.configuration.ui.KotlinConfigurationCheckerStartupActivity"/>
 

idea/resources/META-INF/jvm.xml.193

@@ -0,0 +1,9 @@
+<idea-plugin>
+
+    <extensions defaultExtensionNs="com.intellij">
+        <postStartupActivity implementation="org.jetbrains.kotlin.idea.configuration.ui.KotlinConfigurationCheckerStartupActivity"/>
+
+        <projectService serviceImplementation="org.jetbrains.kotlin.idea.configuration.ui.KotlinConfigurationCheckerService"/>
+    </extensions>
+
+</idea-plugin>

idea/resources/META-INF/plugin.xml

@@ -13,7 +13,7 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
   <version>@snapshot@</version>
   <vendor url="http://www.jetbrains.com">JetBrains</vendor>
 
-  <idea-version since-build="193.4099.13" until-build="193.*"/>
+  <idea-version since-build="201.6487" until-build="202.*"/>
 
   <depends>com.intellij.modules.platform</depends>
 
@@ -34,7 +34,6 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
   <!-- ULTIMATE-PLUGIN-PLACEHOLDER -->
 
   <!-- CIDR-PLUGIN-PLACEHOLDER-START -->
-  <depends>com.intellij.modules.idea</depends>
   <depends>com.intellij.modules.java</depends>
   <depends optional="true" config-file="javaScriptDebug.xml">JavaScriptDebugger</depends>
   <depends optional="true" config-file="kotlin-copyright.xml">com.intellij.copyright</depends>
@@ -57,12 +56,6 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
 
   <xi:include href="scripting-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
 
-  <project-components>
-    <component>
-      <implementation-class>org.jetbrains.kotlin.idea.caches.trackers.KotlinCodeBlockModificationListener</implementation-class>
-    </component>
-  </project-components>
-
   <extensionPoints>
     <xi:include href="extensions/compiler.xml" xpointer="xpointer(/idea-plugin/extensionPoints/*)"/>
 
@@ -76,40 +69,46 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
     <declarationSearcher language="kotlin" implementationClass="org.jetbrains.kotlin.idea.jvm.KotlinDeclarationSearcher"/>
   </extensions>
 
-    <extensions defaultExtensionNs="com.intellij">
-      <applicationService serviceImplementation="org.jetbrains.kotlin.idea.PluginStartupService" />
-      <postStartupActivity implementation="org.jetbrains.kotlin.idea.PluginStartupActivity"/>
-      <postStartupActivity implementation="org.jetbrains.kotlin.idea.completion.LookupCancelWatcher"/>
-      <postStartupActivity implementation="org.jetbrains.kotlin.idea.caches.KotlinPackageContentModificationListener"/>
-      <postStartupActivity implementation="org.jetbrains.kotlin.idea.configuration.KotlinMigrationProjectComponent"/>
+  <extensions defaultExtensionNs="com.intellij">
+    <applicationService serviceImplementation="org.jetbrains.kotlin.idea.PluginStartupService" />
+    <postStartupActivity implementation="org.jetbrains.kotlin.idea.PluginStartupActivity"/>
+    <postStartupActivity implementation="org.jetbrains.kotlin.idea.completion.LookupCancelWatcher"/>
+    <postStartupActivity implementation="org.jetbrains.kotlin.idea.caches.KotlinPackageContentModificationListener"/>
+    <postStartupActivity implementation="org.jetbrains.kotlin.idea.configuration.KotlinMigrationProjectComponent"/>
 
-      <projectService serviceImplementation="org.jetbrains.kotlin.idea.completion.LookupCancelService"/>
-      <projectService serviceImplementation="org.jetbrains.kotlin.idea.configuration.KotlinMigrationProjectService"/>
+    <projectService serviceImplementation="org.jetbrains.kotlin.idea.completion.LookupCancelService"/>
+    <projectService serviceImplementation="org.jetbrains.kotlin.idea.configuration.KotlinMigrationProjectService"/>
 
-      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.highlighter.KotlinBeforeResolveHighlightingPass$Registrar"/>
-      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.highlighter.ScriptExternalHighlightingPass$Registrar"/>
-      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.parameterInfo.custom.KotlinCodeHintsPass$Registrar"/>
-      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.refactoring.cutPaste.MoveDeclarationsPassFactory$Registrar"/>
+    <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.highlighter.KotlinBeforeResolveHighlightingPass$Registrar"/>
+    <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.highlighter.ScriptExternalHighlightingPass$Registrar"/>
+    <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.parameterInfo.custom.KotlinCodeHintsPass$Registrar"/>
+    <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.refactoring.cutPaste.MoveDeclarationsPassFactory$Registrar"/>
 
-      <statistics.counterUsagesCollector groupId="kotlin.gradle.target" version="2"/>
-      <statistics.counterUsagesCollector groupId="kotlin.maven.target" version="3"/>
-      <statistics.counterUsagesCollector groupId="kotlin.jps.target" version="3"/>
-      <statistics.counterUsagesCollector groupId="kotlin.gradle.library" version="1"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.refactoring" version="1"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.newFileTempl" version="1"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.npwizards" version="2"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.debugger" version="2"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.j2k" version="1"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.editor" version="1"/>
-      <statistics.counterUsagesCollector groupId="kotlin.ide.new.wizard" version="1"/>
-      <statistics.counterUsagesCollector groupId="kotlin.gradle.performance" version="1"/>
-      <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.statistics.IDESettingsFUSCollector"/>
-      <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.formatter.KotlinFormatterUsageCollector"/>
-      <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.statistics.ProjectConfigurationCollector"/>
+    <projectService serviceImplementation="org.jetbrains.kotlin.idea.caches.trackers.KotlinCodeBlockModificationListener"/>
 
-      <fileTypeUsageSchemaDescriptor schema="Gradle Script" implementationClass="org.jetbrains.kotlin.idea.core.script.KotlinGradleScriptFileTypeSchemaDetector"/>
+    <statistics.counterUsagesCollector groupId="kotlin.gradle.target" version="2"/>
+    <statistics.counterUsagesCollector groupId="kotlin.maven.target" version="3"/>
+    <statistics.counterUsagesCollector groupId="kotlin.jps.target" version="3"/>
+    <statistics.counterUsagesCollector groupId="kotlin.gradle.library" version="1"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.action.refactoring" version="1"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.newFileTempl" version="1"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.npwizards" version="2"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.debugger" version="2"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.j2k" version="1"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.editor" version="1"/>
+    <statistics.counterUsagesCollector groupId="kotlin.ide.new.wizard" version="1"/>
+    <statistics.counterUsagesCollector groupId="kotlin.gradle.performance" version="1"/>
+    <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.statistics.IDESettingsFUSCollector"/>
+    <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.formatter.KotlinFormatterUsageCollector"/>
+    <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.statistics.ProjectConfigurationCollector"/>
 
-      <completion.ml.model implementation="org.jetbrains.kotlin.idea.completion.ml.KotlinMLRankingProvider"/>
-      <completion.ml.contextFeatures language="kotlin" implementationClass="org.jetbrains.kotlin.idea.completion.ml.KotlinContextFeatureProvider"/>
-    </extensions>
+    <fileTypeUsageSchemaDescriptor schema="Gradle Script" implementationClass="org.jetbrains.kotlin.idea.core.script.KotlinGradleScriptFileTypeSchemaDetector"/>
+
+    <completion.ml.model implementation="org.jetbrains.kotlin.idea.completion.ml.KotlinMLRankingProvider"/>
+    <completion.ml.contextFeatures language="kotlin" implementationClass="org.jetbrains.kotlin.idea.completion.ml.KotlinContextFeatureProvider"/>
+    <suggestedRefactoringSupport language="kotlin" implementationClass="org.jetbrains.kotlin.idea.refactoring.suggested.KotlinSuggestedRefactoringSupport"/>
+
+    <refactoring.moveInnerHandler language="kotlin"
+                                  implementationClass="org.jetbrains.kotlin.idea.refactoring.move.MoveKotlinInnerHandler"/>
+  </extensions>
 </idea-plugin>

idea/resources/META-INF/plugin.xml.193

@@ -0,0 +1,115 @@
+<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude" version="2" url="http://kotlinlang.org" allow-bundled-update="true">
+  <id>org.jetbrains.kotlin</id>
+
+  <name>Kotlin</name>
+  <description><![CDATA[
+The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
+<br>
+<a href="http://kotlinlang.org/docs/tutorials/getting-started.html">Getting Started in IntelliJ IDEA</a><br>
+<a href="http://kotlinlang.org/docs/tutorials/kotlin-android.html">Getting Started in Android Studio</a><br>
+<a href="http://slack.kotlinlang.org/">Public Slack</a><br>
+<a href="https://youtrack.jetbrains.com/issues/KT">Issue tracker</a><br>
+]]></description>
+  <version>@snapshot@</version>
+  <vendor url="http://www.jetbrains.com">JetBrains</vendor>
+
+  <idea-version since-build="193.4099.13" until-build="193.*"/>
+
+  <depends>com.intellij.modules.platform</depends>
+
+  <depends optional="true" config-file="junit.xml">JUnit</depends>
+  <depends optional="true" config-file="gradle.xml">com.intellij.gradle</depends>
+  <depends optional="true" config-file="gradle-java.xml">org.jetbrains.plugins.gradle</depends>
+  <depends optional="true" config-file="kotlin-gradle-testing.xml">org.jetbrains.plugins.gradle</depends>
+  <depends optional="true" config-file="gradle-groovy.xml">org.intellij.groovy</depends>
+  <depends optional="true" config-file="maven.xml">org.jetbrains.idea.maven</depends>
+  <depends optional="true" config-file="testng-j.xml">TestNG-J</depends>
+  <depends optional="true" config-file="coverage.xml">Coverage</depends>
+  <depends optional="true" config-file="i18n.xml">com.intellij.java-i18n</depends>
+  <depends optional="true" config-file="decompiler.xml">org.jetbrains.java.decompiler</depends>
+  <depends optional="true" config-file="git4idea.xml">Git4Idea</depends>
+  <depends optional="true" config-file="stream-debugger.xml">org.jetbrains.debugger.streams</depends>
+  <depends optional="true" config-file="completion-stats.xml">com.intellij.stats.completion</depends>
+
+  <!-- ULTIMATE-PLUGIN-PLACEHOLDER -->
+
+  <!-- CIDR-PLUGIN-PLACEHOLDER-START -->
+  <depends>com.intellij.modules.idea</depends>
+  <depends>com.intellij.modules.java</depends>
+  <depends optional="true" config-file="javaScriptDebug.xml">JavaScriptDebugger</depends>
+  <depends optional="true" config-file="kotlin-copyright.xml">com.intellij.copyright</depends>
+  <depends optional="true" config-file="injection.xml">org.intellij.intelliLang</depends>
+  <!-- CIDR-PLUGIN-PLACEHOLDER-END -->
+
+  <xi:include href="plugin-common.xml" xpointer="xpointer(/idea-plugin/*)"/>
+
+  <!-- CIDR-PLUGIN-EXCLUDE-START -->
+  <xi:include href="jvm-common.xml" xpointer="xpointer(/idea-plugin/*)"/>
+  <xi:include href="jvm.xml" xpointer="xpointer(/idea-plugin/*)"/>
+  <!-- CIDR-PLUGIN-EXCLUDE-END -->
+
+  <xi:include href="native.xml" xpointer="xpointer(/idea-plugin/*)"/>
+  <xi:include href="tipsAndTricks.xml" xpointer="xpointer(/idea-plugin/*)"/>
+
+  <xi:include href="extensions/ide.xml" xpointer="xpointer(/idea-plugin/*)"/>
+
+  <xi:include href="kotlinx-serialization.xml" xpointer="xpointer(/idea-plugin/*)"/>
+
+  <xi:include href="scripting-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
+
+  <project-components>
+    <component>
+      <implementation-class>org.jetbrains.kotlin.idea.caches.trackers.KotlinCodeBlockModificationListener</implementation-class>
+    </component>
+  </project-components>
+
+  <extensionPoints>
+    <xi:include href="extensions/compiler.xml" xpointer="xpointer(/idea-plugin/extensionPoints/*)"/>
+
+    <extensionPoint qualifiedName="org.jetbrains.kotlin.pluginUpdateVerifier"
+                    interface="org.jetbrains.kotlin.idea.update.PluginUpdateVerifier"/>
+  </extensionPoints>
+
+  <xi:include href="plugin-kotlin-extensions.xml" xpointer="xpointer(/idea-plugin/*)"/>
+
+  <extensions defaultExtensionNs="com.intellij.jvm">
+    <declarationSearcher language="kotlin" implementationClass="org.jetbrains.kotlin.idea.jvm.KotlinDeclarationSearcher"/>
+  </extensions>
+
+    <extensions defaultExtensionNs="com.intellij">
+      <applicationService serviceImplementation="org.jetbrains.kotlin.idea.PluginStartupService" />
+      <postStartupActivity implementation="org.jetbrains.kotlin.idea.PluginStartupActivity"/>
+      <postStartupActivity implementation="org.jetbrains.kotlin.idea.completion.LookupCancelWatcher"/>
+      <postStartupActivity implementation="org.jetbrains.kotlin.idea.caches.KotlinPackageContentModificationListener"/>
+      <postStartupActivity implementation="org.jetbrains.kotlin.idea.configuration.KotlinMigrationProjectComponent"/>
+
+      <projectService serviceImplementation="org.jetbrains.kotlin.idea.completion.LookupCancelService"/>
+      <projectService serviceImplementation="org.jetbrains.kotlin.idea.configuration.KotlinMigrationProjectService"/>
+
+      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.highlighter.KotlinBeforeResolveHighlightingPass$Registrar"/>
+      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.highlighter.ScriptExternalHighlightingPass$Registrar"/>
+      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.parameterInfo.custom.KotlinCodeHintsPass$Registrar"/>
+      <highlightingPassFactory implementation="org.jetbrains.kotlin.idea.refactoring.cutPaste.MoveDeclarationsPassFactory$Registrar"/>
+
+      <statistics.counterUsagesCollector groupId="kotlin.gradle.target" version="2"/>
+      <statistics.counterUsagesCollector groupId="kotlin.maven.target" version="3"/>
+      <statistics.counterUsagesCollector groupId="kotlin.jps.target" version="3"/>
+      <statistics.counterUsagesCollector groupId="kotlin.gradle.library" version="1"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.refactoring" version="1"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.newFileTempl" version="1"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.npwizards" version="2"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.debugger" version="2"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.j2k" version="1"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.editor" version="1"/>
+      <statistics.counterUsagesCollector groupId="kotlin.ide.new.wizard" version="1"/>
+      <statistics.counterUsagesCollector groupId="kotlin.gradle.performance" version="1"/>
+      <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.statistics.IDESettingsFUSCollector"/>
+      <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.formatter.KotlinFormatterUsageCollector"/>
+      <statistics.projectUsagesCollector implementation="org.jetbrains.kotlin.idea.statistics.ProjectConfigurationCollector"/>
+
+      <fileTypeUsageSchemaDescriptor schema="Gradle Script" implementationClass="org.jetbrains.kotlin.idea.core.script.KotlinGradleScriptFileTypeSchemaDetector"/>
+
+      <completion.ml.model implementation="org.jetbrains.kotlin.idea.completion.ml.KotlinMLRankingProvider"/>
+      <completion.ml.contextFeatures language="kotlin" implementationClass="org.jetbrains.kotlin.idea.completion.ml.KotlinContextFeatureProvider"/>
+    </extensions>
+</idea-plugin>

idea/resources/META-INF/plugin.xml.201

@@ -34,7 +34,6 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
   <!-- ULTIMATE-PLUGIN-PLACEHOLDER -->
 
   <!-- CIDR-PLUGIN-PLACEHOLDER-START -->
-  <depends>com.intellij.modules.idea</depends>
   <depends>com.intellij.modules.java</depends>
   <depends optional="true" config-file="javaScriptDebug.xml">JavaScriptDebugger</depends>
   <depends optional="true" config-file="kotlin-copyright.xml">com.intellij.copyright</depends>

idea/src/org/jetbrains/kotlin/idea/KotlinDocumentationProviderCompat.kt

@@ -5,5 +5,35 @@
 
 package org.jetbrains.kotlin.idea
 
+import com.intellij.codeInsight.javadoc.JavaDocExternalFilter
+import com.intellij.psi.PsiDocCommentBase
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import java.util.function.Consumer
+
 // BUNCH 201
-class KotlinDocumentationProvider : KotlinDocumentationProviderCompatBase()
+class KotlinDocumentationProvider : KotlinDocumentationProviderCompatBase() {
+
+    override fun collectDocComments(file: PsiFile, sink: Consumer<PsiDocCommentBase>) {
+        if (file !is KtFile) return
+
+        PsiTreeUtil.processElements(file) {
+            val comment = (it as? KtDeclaration)?.docComment
+            if (comment != null) sink.accept(comment)
+            true
+        }
+    }
+
+    override fun generateRenderedDoc(element: PsiElement): String? {
+        val docComment = (element as? KtDeclaration)?.docComment ?: return null
+
+        val result = StringBuilder().also {
+            it.renderKDoc(docComment.getDefaultSection(), docComment.getAllSections())
+        }
+
+        return JavaDocExternalFilter.filterInternalDocInfo(result.toString())
+    }
+}

idea/src/org/jetbrains/kotlin/idea/KotlinDocumentationProviderCompat.kt.193

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea
+
+// BUNCH 201
+class KotlinDocumentationProvider : KotlinDocumentationProviderCompatBase()

idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinRefactoringHelperForDelayedRequests.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.idea.codeInsight.shorten.prepareDelayedRequests
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 
 class KotlinRefactoringHelperForDelayedRequests : RefactoringHelper<Any> {
-    override fun prepareOperation(usages: Array<out UsageInfo>?): Any? {
-        if (usages != null && usages.isNotEmpty()) {
+    override fun prepareOperation(usages: Array<out UsageInfo>): Any? {
+        if (usages.isNotEmpty()) {
             val project = usages[0].project
             prepareDelayedRequests(project)
         }

idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinRefactoringHelperForDelayedRequests.kt.193

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.codeInsight
+
+import com.intellij.openapi.project.Project
+import com.intellij.refactoring.RefactoringHelper
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.idea.codeInsight.shorten.performDelayedRefactoringRequests
+import org.jetbrains.kotlin.idea.codeInsight.shorten.prepareDelayedRequests
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
+
+class KotlinRefactoringHelperForDelayedRequests : RefactoringHelper<Any> {
+    override fun prepareOperation(usages: Array<out UsageInfo>?): Any? {
+        if (usages != null && usages.isNotEmpty()) {
+            val project = usages[0].project
+            prepareDelayedRequests(project)
+        }
+        return null
+    }
+
+    override fun performOperation(project: Project, operationData: Any?) {
+        runWriteAction { performDelayedRefactoringRequests(project) }
+    }
+}

idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinUsageTypeProvider.kt

@@ -75,35 +75,35 @@ object KotlinUsageTypeProvider : UsageTypeProviderEx {
 
 object KotlinUsageTypes {
     // types
-    val TYPE_CONSTRAINT = UsageType(KotlinBundle.message("find.usages.type.type.constraint"))
-    val VALUE_PARAMETER_TYPE = UsageType(KotlinBundle.message("find.usages.type.value.parameter.type"))
-    val NON_LOCAL_PROPERTY_TYPE = UsageType(KotlinBundle.message("find.usages.type.nonLocal.property.type"))
-    val FUNCTION_RETURN_TYPE = UsageType(KotlinBundle.message("find.usages.type.function.return.type"))
-    val SUPER_TYPE = UsageType(KotlinBundle.message("find.usages.type.superType"))
-    val IS = UsageType(KotlinBundle.message("find.usages.type.is"))
-    val CLASS_OBJECT_ACCESS = UsageType(KotlinBundle.message("find.usages.type.class.object"))
-    val COMPANION_OBJECT_ACCESS = UsageType(KotlinBundle.message("find.usages.type.companion.object"))
-    val EXTENSION_RECEIVER_TYPE = UsageType(KotlinBundle.message("find.usages.type.extension.receiver.type"))
-    val SUPER_TYPE_QUALIFIER = UsageType(KotlinBundle.message("find.usages.type.super.type.qualifier"))
-    val TYPE_ALIAS = UsageType(KotlinBundle.message("find.usages.type.type.alias"))
+    val TYPE_CONSTRAINT = UsageType(KotlinBundle.lazyMessage("find.usages.type.type.constraint"))
+    val VALUE_PARAMETER_TYPE = UsageType(KotlinBundle.lazyMessage("find.usages.type.value.parameter.type"))
+    val NON_LOCAL_PROPERTY_TYPE = UsageType(KotlinBundle.lazyMessage("find.usages.type.nonLocal.property.type"))
+    val FUNCTION_RETURN_TYPE = UsageType(KotlinBundle.lazyMessage("find.usages.type.function.return.type"))
+    val SUPER_TYPE = UsageType(KotlinBundle.lazyMessage("find.usages.type.superType"))
+    val IS = UsageType(KotlinBundle.lazyMessage("find.usages.type.is"))
+    val CLASS_OBJECT_ACCESS = UsageType(KotlinBundle.lazyMessage("find.usages.type.class.object"))
+    val COMPANION_OBJECT_ACCESS = UsageType(KotlinBundle.lazyMessage("find.usages.type.companion.object"))
+    val EXTENSION_RECEIVER_TYPE = UsageType(KotlinBundle.lazyMessage("find.usages.type.extension.receiver.type"))
+    val SUPER_TYPE_QUALIFIER = UsageType(KotlinBundle.lazyMessage("find.usages.type.super.type.qualifier"))
+    val TYPE_ALIAS = UsageType(KotlinBundle.lazyMessage("find.usages.type.type.alias"))
 
     // functions
-    val FUNCTION_CALL = UsageType(KotlinBundle.message("find.usages.type.function.call"))
-    val IMPLICIT_GET = UsageType(KotlinBundle.message("find.usages.type.implicit.get"))
-    val IMPLICIT_SET = UsageType(KotlinBundle.message("find.usages.type.implicit.set"))
-    val IMPLICIT_INVOKE = UsageType(KotlinBundle.message("find.usages.type.implicit.invoke"))
-    val IMPLICIT_ITERATION = UsageType(KotlinBundle.message("find.usages.type.implicit.iteration"))
-    val PROPERTY_DELEGATION = UsageType(KotlinBundle.message("find.usages.type.property.delegation"))
+    val FUNCTION_CALL = UsageType(KotlinBundle.lazyMessage("find.usages.type.function.call"))
+    val IMPLICIT_GET = UsageType(KotlinBundle.lazyMessage("find.usages.type.implicit.get"))
+    val IMPLICIT_SET = UsageType(KotlinBundle.lazyMessage("find.usages.type.implicit.set"))
+    val IMPLICIT_INVOKE = UsageType(KotlinBundle.lazyMessage("find.usages.type.implicit.invoke"))
+    val IMPLICIT_ITERATION = UsageType(KotlinBundle.lazyMessage("find.usages.type.implicit.iteration"))
+    val PROPERTY_DELEGATION = UsageType(KotlinBundle.lazyMessage("find.usages.type.property.delegation"))
 
     // values
-    val RECEIVER = UsageType(KotlinBundle.message("find.usages.type.receiver"))
-    val DELEGATE = UsageType(KotlinBundle.message("find.usages.type.delegate"))
+    val RECEIVER = UsageType(KotlinBundle.lazyMessage("find.usages.type.receiver"))
+    val DELEGATE = UsageType(KotlinBundle.lazyMessage("find.usages.type.delegate"))
 
     // packages
-    val PACKAGE_DIRECTIVE = UsageType(KotlinBundle.message("find.usages.type.packageDirective"))
-    val PACKAGE_MEMBER_ACCESS = UsageType(KotlinBundle.message("find.usages.type.packageMemberAccess"))
+    val PACKAGE_DIRECTIVE = UsageType(KotlinBundle.lazyMessage("find.usages.type.packageDirective"))
+    val PACKAGE_MEMBER_ACCESS = UsageType(KotlinBundle.lazyMessage("find.usages.type.packageMemberAccess"))
 
     // common usage types
-    val CALLABLE_REFERENCE = UsageType(KotlinBundle.message("find.usages.type.callable.reference"))
-    val NAMED_ARGUMENT = UsageType(KotlinBundle.message("find.usages.type.named.argument"))
+    val CALLABLE_REFERENCE = UsageType(KotlinBundle.lazyMessage("find.usages.type.callable.reference"))
+    val NAMED_ARGUMENT = UsageType(KotlinBundle.lazyMessage("find.usages.type.named.argument"))
 }

idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinUsageTypeProvider.kt.193

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.findUsages
+
+import com.intellij.psi.PsiElement
+import com.intellij.usages.UsageTarget
+import com.intellij.usages.impl.rules.UsageType
+import com.intellij.usages.impl.rules.UsageTypeProviderEx
+import org.jetbrains.kotlin.idea.KotlinBundle
+import org.jetbrains.kotlin.idea.findUsages.UsageTypeEnum.*
+
+object KotlinUsageTypeProvider : UsageTypeProviderEx {
+    override fun getUsageType(element: PsiElement?): UsageType? = getUsageType(element, UsageTarget.EMPTY_ARRAY)
+
+    override fun getUsageType(element: PsiElement?, targets: Array<out UsageTarget>): UsageType? {
+        val usageType = UsageTypeUtils.getUsageType(element) ?: return null
+        return convertEnumToUsageType(usageType)
+    }
+
+    private fun convertEnumToUsageType(usageType: UsageTypeEnum): UsageType = when (usageType) {
+        TYPE_CONSTRAINT -> KotlinUsageTypes.TYPE_CONSTRAINT
+        VALUE_PARAMETER_TYPE -> KotlinUsageTypes.VALUE_PARAMETER_TYPE
+        NON_LOCAL_PROPERTY_TYPE -> KotlinUsageTypes.NON_LOCAL_PROPERTY_TYPE
+        FUNCTION_RETURN_TYPE -> KotlinUsageTypes.FUNCTION_RETURN_TYPE
+        SUPER_TYPE -> KotlinUsageTypes.SUPER_TYPE
+        IS -> KotlinUsageTypes.IS
+        CLASS_OBJECT_ACCESS -> KotlinUsageTypes.CLASS_OBJECT_ACCESS
+        COMPANION_OBJECT_ACCESS -> KotlinUsageTypes.COMPANION_OBJECT_ACCESS
+        EXTENSION_RECEIVER_TYPE -> KotlinUsageTypes.EXTENSION_RECEIVER_TYPE
+        SUPER_TYPE_QUALIFIER -> KotlinUsageTypes.SUPER_TYPE_QUALIFIER
+        TYPE_ALIAS -> KotlinUsageTypes.TYPE_ALIAS
+
+        FUNCTION_CALL -> KotlinUsageTypes.FUNCTION_CALL
+        IMPLICIT_GET -> KotlinUsageTypes.IMPLICIT_GET
+        IMPLICIT_SET -> KotlinUsageTypes.IMPLICIT_SET
+        IMPLICIT_INVOKE -> KotlinUsageTypes.IMPLICIT_INVOKE
+        IMPLICIT_ITERATION -> KotlinUsageTypes.IMPLICIT_ITERATION
+        PROPERTY_DELEGATION -> KotlinUsageTypes.PROPERTY_DELEGATION
+
+        RECEIVER -> KotlinUsageTypes.RECEIVER
+        DELEGATE -> KotlinUsageTypes.DELEGATE
+
+        PACKAGE_DIRECTIVE -> KotlinUsageTypes.PACKAGE_DIRECTIVE
+        PACKAGE_MEMBER_ACCESS -> KotlinUsageTypes.PACKAGE_MEMBER_ACCESS
+
+        CALLABLE_REFERENCE -> KotlinUsageTypes.CALLABLE_REFERENCE
+
+        READ -> UsageType.READ
+        WRITE -> UsageType.WRITE
+        CLASS_IMPORT -> UsageType.CLASS_IMPORT
+        CLASS_LOCAL_VAR_DECLARATION -> UsageType.CLASS_LOCAL_VAR_DECLARATION
+        TYPE_PARAMETER -> UsageType.TYPE_PARAMETER
+        CLASS_CAST_TO -> UsageType.CLASS_CAST_TO
+        ANNOTATION -> UsageType.ANNOTATION
+        CLASS_NEW_OPERATOR -> UsageType.CLASS_NEW_OPERATOR
+        NAMED_ARGUMENT -> KotlinUsageTypes.NAMED_ARGUMENT
+
+        USAGE_IN_STRING_LITERAL -> UsageType.LITERAL_USAGE
+    }
+}
+
+object KotlinUsageTypes {
+    // types
+    val TYPE_CONSTRAINT = UsageType(KotlinBundle.message("find.usages.type.type.constraint"))
+    val VALUE_PARAMETER_TYPE = UsageType(KotlinBundle.message("find.usages.type.value.parameter.type"))
+    val NON_LOCAL_PROPERTY_TYPE = UsageType(KotlinBundle.message("find.usages.type.nonLocal.property.type"))
+    val FUNCTION_RETURN_TYPE = UsageType(KotlinBundle.message("find.usages.type.function.return.type"))
+    val SUPER_TYPE = UsageType(KotlinBundle.message("find.usages.type.superType"))
+    val IS = UsageType(KotlinBundle.message("find.usages.type.is"))
+    val CLASS_OBJECT_ACCESS = UsageType(KotlinBundle.message("find.usages.type.class.object"))
+    val COMPANION_OBJECT_ACCESS = UsageType(KotlinBundle.message("find.usages.type.companion.object"))
+    val EXTENSION_RECEIVER_TYPE = UsageType(KotlinBundle.message("find.usages.type.extension.receiver.type"))
+    val SUPER_TYPE_QUALIFIER = UsageType(KotlinBundle.message("find.usages.type.super.type.qualifier"))
+    val TYPE_ALIAS = UsageType(KotlinBundle.message("find.usages.type.type.alias"))
+
+    // functions
+    val FUNCTION_CALL = UsageType(KotlinBundle.message("find.usages.type.function.call"))
+    val IMPLICIT_GET = UsageType(KotlinBundle.message("find.usages.type.implicit.get"))
+    val IMPLICIT_SET = UsageType(KotlinBundle.message("find.usages.type.implicit.set"))
+    val IMPLICIT_INVOKE = UsageType(KotlinBundle.message("find.usages.type.implicit.invoke"))
+    val IMPLICIT_ITERATION = UsageType(KotlinBundle.message("find.usages.type.implicit.iteration"))
+    val PROPERTY_DELEGATION = UsageType(KotlinBundle.message("find.usages.type.property.delegation"))
+
+    // values
+    val RECEIVER = UsageType(KotlinBundle.message("find.usages.type.receiver"))
+    val DELEGATE = UsageType(KotlinBundle.message("find.usages.type.delegate"))
+
+    // packages
+    val PACKAGE_DIRECTIVE = UsageType(KotlinBundle.message("find.usages.type.packageDirective"))
+    val PACKAGE_MEMBER_ACCESS = UsageType(KotlinBundle.message("find.usages.type.packageMemberAccess"))
+
+    // common usage types
+    val CALLABLE_REFERENCE = UsageType(KotlinBundle.message("find.usages.type.callable.reference"))
+    val NAMED_ARGUMENT = UsageType(KotlinBundle.message("find.usages.type.named.argument"))
+}

idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/compat.kt

@@ -10,5 +10,5 @@ import com.intellij.usageView.UsageInfo
 import com.intellij.util.Processor
 
 // BUNCH: 193
-typealias UsageInfoProcessor = Processor<UsageInfo>
-typealias SliceUsageProcessor = Processor<SliceUsage>
+typealias UsageInfoProcessor = Processor<in UsageInfo>
+typealias SliceUsageProcessor = Processor<in SliceUsage>

idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/compat.kt.193

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.findUsages.handlers
+
+import com.intellij.slicer.SliceUsage
+import com.intellij.usageView.UsageInfo
+import com.intellij.util.Processor
+
+// BUNCH: 193
+typealias UsageInfoProcessor = Processor<UsageInfo>
+typealias SliceUsageProcessor = Processor<SliceUsage>

idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/compat.kt

@@ -3,21 +3,22 @@
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
-@file:Suppress("TYPEALIAS_EXPANSION_DEPRECATION", "DEPRECATION", "UnstableApiUsage")
+@file:Suppress("TYPEALIAS_EXPANSION_DEPRECATION", "DEPRECATION")
 
 package org.jetbrains.kotlin.idea.hierarchy.calls
 
 import com.intellij.ide.hierarchy.call.CalleeMethodsTreeStructure
 import com.intellij.ide.hierarchy.call.CallerMethodsTreeStructure
 import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMember
 import com.intellij.psi.PsiMethod
 
 // BUNCH: 193
 fun createCallerMethodsTreeStructure(project: Project, method: PsiMethod, scopeType: String): CallerMethodsTreeStructure {
-    return CallerMethodsTreeStructure(project, method, scopeType)
+    return CallerMethodsTreeStructure(project, method as PsiMember, scopeType)
 }
 
 // BUNCH: 193
 fun createCalleeMethodsTreeStructure(project: Project, method: PsiMethod, scopeType: String): CalleeMethodsTreeStructure {
-    return CalleeMethodsTreeStructure(project, method, scopeType)
+    return CalleeMethodsTreeStructure(project, method as PsiMember, scopeType)
 }

idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/compat.kt.193

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:Suppress("TYPEALIAS_EXPANSION_DEPRECATION", "DEPRECATION", "UnstableApiUsage")
+
+package org.jetbrains.kotlin.idea.hierarchy.calls
+
+import com.intellij.ide.hierarchy.call.CalleeMethodsTreeStructure
+import com.intellij.ide.hierarchy.call.CallerMethodsTreeStructure
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiMethod
+
+// BUNCH: 193
+fun createCallerMethodsTreeStructure(project: Project, method: PsiMethod, scopeType: String): CallerMethodsTreeStructure {
+    return CallerMethodsTreeStructure(project, method, scopeType)
+}
+
+// BUNCH: 193
+fun createCalleeMethodsTreeStructure(project: Project, method: PsiMethod, scopeType: String): CalleeMethodsTreeStructure {
+    return CalleeMethodsTreeStructure(project, method, scopeType)
+}

idea/src/org/jetbrains/kotlin/idea/navigationToolbar/KotlinNavBarModelExtension.kt

@@ -19,8 +19,8 @@ class KotlinNavBarModelExtension : AbstractNavBarModelExtension() {
         }
     }
 
-    override fun adjustElement(psiElement: PsiElement?): PsiElement? {
-        val containingFile = psiElement?.containingFile as? KtFile ?: return psiElement
+    override fun adjustElement(psiElement: PsiElement): PsiElement? {
+        val containingFile = psiElement.containingFile as? KtFile ?: return psiElement
         if (containingFile.isScript()) return psiElement
         return KotlinIconProvider.getSingleClass(containingFile) ?: psiElement
     }

idea/src/org/jetbrains/kotlin/idea/navigationToolbar/KotlinNavBarModelExtension.kt.193

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.navigationToolbar
+
+import com.intellij.ide.navigationToolbar.AbstractNavBarModelExtension
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.idea.KotlinIconProvider
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtFile
+
+class KotlinNavBarModelExtension : AbstractNavBarModelExtension() {
+    override fun getPresentableText(item: Any?): String? {
+        return when (item) {
+            is KtClassOrObject -> item.name ?: "unknown"
+            else -> null
+        }
+    }
+
+    override fun adjustElement(psiElement: PsiElement?): PsiElement? {
+        val containingFile = psiElement?.containingFile as? KtFile ?: return psiElement
+        if (containingFile.isScript()) return psiElement
+        return KotlinIconProvider.getSingleClass(containingFile) ?: psiElement
+    }
+}

idea/src/org/jetbrains/kotlin/idea/projectView/KtDeclarationTreeNode.java

@@ -44,7 +44,7 @@ public class KtDeclarationTreeNode extends AbstractPsiBasedNode<KtDeclaration> {
     }
 
     @Override
-    protected Collection<AbstractTreeNode> getChildrenImpl() {
+    protected Collection<AbstractTreeNode<?>> getChildrenImpl() {
         return Collections.emptyList();
     }
 

idea/src/org/jetbrains/kotlin/idea/projectView/KtDeclarationTreeNode.java.193

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.projectView;
+
+import com.intellij.application.options.CodeStyle;
+import com.intellij.ide.projectView.PresentationData;
+import com.intellij.ide.projectView.ViewSettings;
+import com.intellij.ide.projectView.impl.nodes.AbstractPsiBasedNode;
+import com.intellij.ide.util.treeView.AbstractTreeNode;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.kotlin.idea.KotlinBundle;
+import org.jetbrains.kotlin.idea.core.formatter.KotlinCodeStyleSettings;
+import org.jetbrains.kotlin.psi.*;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class KtDeclarationTreeNode extends AbstractPsiBasedNode<KtDeclaration> {
+    public static final String CLASS_INITIALIZER = "<" + KotlinBundle.message("project.view.class.initializer") + ">";
+
+    protected KtDeclarationTreeNode(Project project, KtDeclaration ktDeclaration, ViewSettings viewSettings) {
+        super(project, ktDeclaration, viewSettings);
+    }
+
+    @Override
+    protected PsiElement extractPsiFromValue() {
+        return getValue();
+    }
+
+    @Override
+    protected Collection<AbstractTreeNode> getChildrenImpl() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected void updateImpl(PresentationData data) {
+        KtDeclaration declaration = getValue();
+        if (declaration != null) {
+            String text = declaration instanceof KtAnonymousInitializer ? CLASS_INITIALIZER : declaration.getName();
+            if (text == null) return;
+
+            KotlinCodeStyleSettings settings = CodeStyle.getSettings(getProject())
+                    .getCustomSettings(KotlinCodeStyleSettings.class);
+
+            if (declaration instanceof KtProperty) {
+                KtProperty property = (KtProperty) declaration;
+                KtTypeReference ref = property.getTypeReference();
+                if (ref != null) {
+                    if (settings.SPACE_BEFORE_TYPE_COLON) text += " ";
+                    text += ":";
+                    if (settings.SPACE_AFTER_TYPE_COLON) text += " ";
+                    text += ref.getText();
+                }
+            }
+            else if (declaration instanceof KtFunction) {
+                KtFunction function = (KtFunction) declaration;
+                KtTypeReference receiverTypeRef = function.getReceiverTypeReference();
+                if (receiverTypeRef != null) {
+                    text = receiverTypeRef.getText() + "." + text;
+                }
+                text += "(";
+                List<KtParameter> parameters = function.getValueParameters();
+                for (KtParameter parameter : parameters) {
+                    if (parameter.getName() != null) {
+                        text += parameter.getName();
+                        if (settings.SPACE_BEFORE_TYPE_COLON) text += " ";
+                        text += ":";
+                        if (settings.SPACE_AFTER_TYPE_COLON) text += " ";
+                    }
+                    KtTypeReference typeReference = parameter.getTypeReference();
+                    if (typeReference != null) {
+                        text += typeReference.getText();
+                    }
+                    text += ", ";
+                }
+                if (parameters.size() > 0) text = text.substring(0, text.length() - 2);
+                text += ")";
+                KtTypeReference typeReference = function.getTypeReference();
+                if (typeReference != null) {
+                    if (settings.SPACE_BEFORE_TYPE_COLON) text += " ";
+                    text += ":";
+                    if (settings.SPACE_AFTER_TYPE_COLON) text += " ";
+                    text += typeReference.getText();
+                }
+            }
+
+            data.setPresentableText(text);
+        }
+    }
+
+    @Override
+    protected boolean isDeprecated() {
+        return KtPsiUtil.isDeprecated(getValue());
+    }
+}

idea/src/org/jetbrains/kotlin/idea/projectView/KtFileTreeNode.java

@@ -39,11 +39,11 @@ public class KtFileTreeNode extends PsiFileNode {
     }
 
     @Override
-    public Collection<AbstractTreeNode> getChildrenImpl() {
+    public Collection<AbstractTreeNode<?>> getChildrenImpl() {
         KtFile file = (KtFile) getValue();
 
         if (file == null) return Collections.emptyList();
-        ArrayList<AbstractTreeNode> result = new ArrayList<AbstractTreeNode>();
+        ArrayList<AbstractTreeNode<?>> result = new ArrayList<>();
 
         if (getSettings().isShowMembers()) {
             @SuppressWarnings("ConstantConditions") List<KtDeclaration> declarations = (file.isScript() ? file.getScript() : file).getDeclarations();

idea/src/org/jetbrains/kotlin/idea/projectView/KtFileTreeNode.java.193

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.projectView;
+
+import com.intellij.ide.projectView.ViewSettings;
+import com.intellij.ide.projectView.impl.nodes.PsiFileNode;
+import com.intellij.ide.util.treeView.AbstractTreeNode;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class KtFileTreeNode extends PsiFileNode {
+    public KtFileTreeNode(Project project, KtFile value, ViewSettings viewSettings) {
+        super(project, value, viewSettings);
+    }
+
+    public final KtFile getKtFile() {
+        return (KtFile) getValue();
+    }
+
+    @Override
+    public Collection<AbstractTreeNode> getChildrenImpl() {
+        KtFile file = (KtFile) getValue();
+
+        if (file == null) return Collections.emptyList();
+        ArrayList<AbstractTreeNode> result = new ArrayList<AbstractTreeNode>();
+
+        if (getSettings().isShowMembers()) {
+            @SuppressWarnings("ConstantConditions") List<KtDeclaration> declarations = (file.isScript() ? file.getScript() : file).getDeclarations();
+
+            for (KtDeclaration declaration : declarations) {
+                if (declaration instanceof KtClassOrObject) {
+                    result.add(new KtClassOrObjectTreeNode(file.getProject(), (KtClassOrObject) declaration, getSettings()));
+                }
+                else if (getSettings().isShowMembers()) {
+                    result.add(new KtDeclarationTreeNode(getProject(), declaration, getSettings()));
+                }
+            }
+        }
+
+        return result;
+    }
+}

idea/src/org/jetbrains/kotlin/idea/projectView/compat.kt

@@ -8,4 +8,4 @@ package org.jetbrains.kotlin.idea.projectView
 import com.intellij.ide.util.treeView.AbstractTreeNode
 
 // BUNCH: 193
-typealias AbstractTreeNodeAny = AbstractTreeNode<Any>
+typealias AbstractTreeNodeAny = AbstractTreeNode<*>

idea/src/org/jetbrains/kotlin/idea/projectView/compat.kt.193

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.projectView
+
+import com.intellij.ide.util.treeView.AbstractTreeNode
+
+// BUNCH: 193
+typealias AbstractTreeNodeAny = AbstractTreeNode<Any>

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/BunchedDeprecation.java

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.idea.refactoring.changeSignature;
 
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.util.TextOccurrencesUtil;
 import com.intellij.usageView.UsageInfo;
 
@@ -20,6 +21,7 @@ final class BunchedDeprecation {
             boolean searchInNonJavaFiles,
             String newQName,
             Collection<? super UsageInfo> results) {
-        TextOccurrencesUtil.findNonCodeUsages(element, stringToSearch, searchInStringsAndComments, searchInNonJavaFiles, newQName, results);
+        TextOccurrencesUtil.findNonCodeUsages(element, GlobalSearchScope.projectScope(element.getProject()),
+                                              stringToSearch, searchInStringsAndComments, searchInNonJavaFiles, newQName, results);
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/BunchedDeprecation.java.193

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.refactoring.changeSignature;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.refactoring.util.TextOccurrencesUtil;
+import com.intellij.usageView.UsageInfo;
+
+import java.util.Collection;
+
+// BUNCH: 201
+final class BunchedDeprecation {
+    public static void findNonCodeUsages(
+            PsiElement element,
+            String stringToSearch,
+            boolean searchInStringsAndComments,
+            boolean searchInNonJavaFiles,
+            String newQName,
+            Collection<? super UsageInfo> results) {
+        TextOccurrencesUtil.findNonCodeUsages(element, stringToSearch, searchInStringsAndComments, searchInNonJavaFiles, newQName, results);
+    }
+}

idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveKotlinInnerHandler.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.refactoring.move
+
+import com.intellij.refactoring.move.moveInner.MoveJavaInnerHandler
+import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.idea.references.getImportAlias
+
+class MoveKotlinInnerHandler : MoveJavaInnerHandler() {
+
+    override fun preprocessUsages(results: MutableCollection<UsageInfo>?) {
+        results?.removeAll { usageInfo ->
+            usageInfo.element?.references?.any { it.getImportAlias() != null } == true
+        }
+    }
+}

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveDeclarations/BunchedDeprecation.java

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.idea.refactoring.move.moveDeclarations;
 
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.refactoring.util.TextOccurrencesUtil;
 import com.intellij.usageView.UsageInfo;
 
@@ -20,6 +21,7 @@ final class BunchedDeprecation {
             boolean searchInNonJavaFiles,
             String newQName,
             Collection<? super UsageInfo> results) {
-        TextOccurrencesUtil.findNonCodeUsages(element, stringToSearch, searchInStringsAndComments, searchInNonJavaFiles, newQName, results);
+        TextOccurrencesUtil.findNonCodeUsages(element, GlobalSearchScope.projectScope(element.getProject()),
+                                              stringToSearch, searchInStringsAndComments, searchInNonJavaFiles, newQName, results);
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveDeclarations/BunchedDeprecation.java.193

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.refactoring.move.moveDeclarations;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.refactoring.util.TextOccurrencesUtil;
+import com.intellij.usageView.UsageInfo;
+
+import java.util.Collection;
+
+// BUNCH: 201
+final class BunchedDeprecation {
+    public static void findNonCodeUsages(
+            PsiElement element,
+            String stringToSearch,
+            boolean searchInStringsAndComments,
+            boolean searchInNonJavaFiles,
+            String newQName,
+            Collection<? super UsageInfo> results) {
+        TextOccurrencesUtil.findNonCodeUsages(element, stringToSearch, searchInStringsAndComments, searchInNonJavaFiles, newQName, results);
+    }
+}

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/ForeignUsagesRenameProcessor.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.idea.refactoring.rename
+
+import com.intellij.lang.Language
+import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.psi.PsiElement
+import com.intellij.usageView.UsageInfo
+
+abstract class ForeignUsagesRenameProcessor {
+    companion object {
+        private val EP_NAME = ExtensionPointName<ForeignUsagesRenameProcessor>("org.jetbrains.kotlin.foreignUsagesRenameProcessor")
+
+        @JvmStatic
+        fun processAll(element: PsiElement, newName: String, usages: Array<UsageInfo>, fallbackHandler: (UsageInfo) -> Unit) {
+            val usagesByLanguage = usages.groupBy { it.element?.language }
+            for ((language, languageInfos) in usagesByLanguage) {
+                if (language != null && EP_NAME.extensions.any { it.process(element, newName, language, languageInfos) }) {
+                    continue
+                }
+                languageInfos.forEach(fallbackHandler)
+            }
+        }
+    }
+
+    abstract fun process(element: PsiElement, newName: String, language: Language, allUsages: Collection<UsageInfo>): Boolean
+}

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFileProcessor.kt

@@ -11,13 +11,16 @@ import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.SearchScope
+import com.intellij.refactoring.listeners.RefactoringElementListener
 import com.intellij.refactoring.rename.RenamePsiFileProcessor
+import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.psi.KtFile
+import java.util.ArrayList
 
 class RenameKotlinFileProcessor : RenamePsiFileProcessor() {
     class FileRenamingPsiClassWrapper(
@@ -54,4 +57,14 @@ class RenameKotlinFileProcessor : RenamePsiFileProcessor() {
             }
         }
     }
+
+    override fun renameElement(element: PsiElement, newName: String, usages: Array<UsageInfo>, listener: RefactoringElementListener?) {
+        val kotlinUsages = ArrayList<UsageInfo>(usages.size)
+
+        ForeignUsagesRenameProcessor.processAll(element, newName, usages, fallbackHandler = {
+            kotlinUsages += it
+        })
+
+        super.renameElement(element, newName, kotlinUsages.toTypedArray(), listener)
+    }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt

@@ -214,10 +214,10 @@ class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() {
     override fun renameElement(element: PsiElement, newName: String, usages: Array<UsageInfo>, listener: RefactoringElementListener?) {
         val simpleUsages = ArrayList<UsageInfo>(usages.size)
         val ambiguousImportUsages = SmartList<UsageInfo>()
-        for (usage in usages) {
+        ForeignUsagesRenameProcessor.processAll(element, newName, usages, fallbackHandler = { usage ->
             if (usage is LostDefaultValuesInOverridingFunctionUsageInfo) {
                 usage.apply()
-                continue
+                return@processAll
             }
 
             if (usage.isAmbiguousImportUsage()) {
@@ -227,7 +227,7 @@ class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() {
                     simpleUsages += usage
                 }
             }
-        }
+        })
         element.ambiguousImportUsages = ambiguousImportUsages
 
         RenameUtil.doRenameGenericNamedElement(element, newName, simpleUsages.toTypedArray(), listener)

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt

@@ -151,10 +151,10 @@ abstract class RenameKotlinPsiProcessor : RenamePsiElementProcessor() {
         listener: RefactoringElementListener?
     ) {
         val simpleUsages = ArrayList<UsageInfo>(usages.size)
-        for (usage in usages) {
-            if (renameMangledUsageIfPossible(usage, element, newName)) continue
+        ForeignUsagesRenameProcessor.processAll(element, newName, usages, fallbackHandler = { usage ->
+            if (renameMangledUsageIfPossible(usage, element, newName)) return@processAll
             simpleUsages += usage
-        }
+        })
 
         RenameUtil.doRenameGenericNamedElement(element, newName, simpleUsages.toTypedArray(), listener)
     }

idea/src/org/jetbrains/kotlin/idea/refactoring/suggested/KotlinSignaturePresentationBuilder.kt

@@ -0,0 +1,77 @@
+package org.jetbrains.kotlin.idea.refactoring.suggested
+
+import com.intellij.refactoring.suggested.SuggestedRefactoringSupport
+import com.intellij.refactoring.suggested.SignatureChangePresentationModel.Effect
+import com.intellij.refactoring.suggested.SignatureChangePresentationModel.TextFragment.Leaf
+import com.intellij.refactoring.suggested.SignaturePresentationBuilder
+
+internal class KotlinSignaturePresentationBuilder(
+    signature: SuggestedRefactoringSupport.Signature,
+    otherSignature: SuggestedRefactoringSupport.Signature,
+    isOldSignature: Boolean
+) : SignaturePresentationBuilder(signature, otherSignature, isOldSignature)
+{
+    override fun buildPresentation() {
+        val declarationType = (signature.additionalData as KotlinSignatureAdditionalData).declarationType
+        val keyword = declarationType.prefixKeyword
+        if (keyword != null) {
+            fragments += Leaf("$keyword ")
+        }
+
+        signature.receiverType?.let {
+            when (val effect = effect(it, otherSignature.receiverType)) {
+                Effect.Modified -> {
+                    fragments += Leaf(it, effect)
+                    fragments += Leaf(".")
+                }
+
+                else -> {
+                    fragments += Leaf("$it.", effect)
+                }
+            }
+        }
+
+        val name = if (declarationType == DeclarationType.SECONDARY_CONSTRUCTOR) "constructor" else signature.name
+        fragments += Leaf(name, effect(signature.name, otherSignature.name))
+
+        if (declarationType.isFunction) {
+            buildParameterList { fragments, parameter, correspondingParameter ->
+                if (parameter.modifiers.isNotEmpty()) {
+                    fragments += leaf(parameter.modifiers, correspondingParameter?.modifiers ?: parameter.modifiers)
+                    fragments += Leaf(" ")
+                }
+
+                fragments += leaf(parameter.name, correspondingParameter?.name ?: parameter.name)
+
+                fragments += Leaf(": ")
+
+                fragments += leaf(parameter.type, correspondingParameter?.type ?: parameter.type)
+
+                val defaultValue = parameter.defaultValue
+                if (defaultValue != null) {
+                    val defaultValueEffect = if (correspondingParameter != null)
+                        effect(defaultValue, correspondingParameter.defaultValue)
+                    else
+                        Effect.None
+                    fragments += Leaf(" = ", defaultValueEffect.takeIf { it != Effect.Modified } ?: Effect.None)
+                    fragments += Leaf(defaultValue, defaultValueEffect)
+                }
+            }
+        } else {
+            require(signature.parameters.isEmpty())
+        }
+
+        signature.type?.let { type ->
+            when (val effect = effect(type, otherSignature.type)) {
+                Effect.Added, Effect.Removed, Effect.None -> {
+                    fragments += Leaf(": ${signature.type}", effect)
+                }
+
+                Effect.Modified -> {
+                    fragments += Leaf(": ")
+                    fragments += Leaf(type, effect)
+                }
+            }
+        }
+    }
+}

idea/src/org/jetbrains/kotlin/idea/refactoring/suggested/KotlinSuggestedRefactoringAvailability.kt

@@ -0,0 +1,177 @@
+package org.jetbrains.kotlin.idea.refactoring.suggested
+
+import com.intellij.openapi.util.Key
+import com.intellij.psi.PsiNamedElement
+import com.intellij.psi.search.LocalSearchScope
+import com.intellij.psi.search.searches.ReferencesSearch
+import com.intellij.refactoring.suggested.*
+import com.intellij.refactoring.suggested.SuggestedRefactoringSupport.Parameter
+import com.intellij.refactoring.suggested.SuggestedRefactoringSupport.Signature
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.idea.caches.project.forcedModuleInfo
+import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
+import org.jetbrains.kotlin.idea.refactoring.isInterfaceClass
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
+import org.jetbrains.kotlin.psi.psiUtil.hasBody
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.isError
+
+class KotlinSuggestedRefactoringAvailability(refactoringSupport: SuggestedRefactoringSupport) :
+    SuggestedRefactoringAvailability(refactoringSupport)
+{
+    private val HAS_USAGES = Key<Boolean>("KotlinSuggestedRefactoringAvailability.HAS_USAGES")
+
+    override fun amendStateInBackground(state: SuggestedRefactoringState): Iterator<SuggestedRefactoringState> {
+        return iterator {
+            if (state.additionalData[HAS_USAGES] == null) {
+                val declarationCopy = state.restoredDeclarationCopy()
+                val useScope = declarationCopy.useScope
+                if (useScope is LocalSearchScope) {
+                    val hasUsages = ReferencesSearch.search(declarationCopy, useScope).findFirst() != null
+                    yield(state.withAdditionalData(HAS_USAGES, hasUsages))
+                }
+            }
+        }
+    }
+
+    override fun refineSignaturesWithResolve(state: SuggestedRefactoringState): SuggestedRefactoringState {
+        val newDeclaration = state.declaration as? KtCallableDeclaration ?: return state
+        val oldDeclaration = state.restoredDeclarationCopy() as? KtCallableDeclaration ?: return state
+        oldDeclaration.containingKtFile.forcedModuleInfo = newDeclaration.getModuleInfo()
+
+        val descriptorWithOldSignature = oldDeclaration.resolveToDescriptorIfAny() as CallableDescriptor
+        val descriptorWithNewSignature = newDeclaration.resolveToDescriptorIfAny() as CallableDescriptor
+
+        val oldSignature = state.oldSignature
+        val newSignature = state.newSignature
+
+        val (oldReturnType, newReturnType) = refineType(
+            oldSignature.type,
+            newSignature.type,
+            descriptorWithOldSignature.returnType,
+            descriptorWithNewSignature.returnType
+        )
+
+        val improvedOldParameterTypesById = mutableMapOf<Any, String>()
+        val improvedNewParameterTypesById = mutableMapOf<Any, String>()
+        for (oldParameter in oldSignature.parameters) {
+            val id = oldParameter.id
+            val newParameter = newSignature.parameterById(id) ?: continue
+            val oldIndex = oldSignature.parameterIndex(oldParameter)
+            val newIndex = newSignature.parameterIndex(newParameter)
+            val (oldType, newType) = refineType(
+                oldParameter.type,
+                newParameter.type,
+                descriptorWithOldSignature.valueParameters[oldIndex].type,
+                descriptorWithNewSignature.valueParameters[newIndex].type
+            )
+            // oldType and newType may not be null because arguments of refineType call were all non-null
+            improvedOldParameterTypesById[id] = oldType!!
+            improvedNewParameterTypesById[id] = newType!!
+        }
+        val oldParameters = oldSignature.parameters.map { it.copy(type = improvedOldParameterTypesById[it.id] ?: it.type) }
+        val newParameters = newSignature.parameters.map { it.copy(type = improvedNewParameterTypesById[it.id] ?: it.type) }
+
+        val oldAdditionalData = oldSignature.additionalData as KotlinSignatureAdditionalData?
+        val newAdditionalData = newSignature.additionalData as KotlinSignatureAdditionalData?
+        val (oldReceiverType, newReceiverType) = refineType(
+            oldAdditionalData?.receiverType,
+            newAdditionalData?.receiverType,
+            descriptorWithOldSignature.extensionReceiverParameter?.type,
+            descriptorWithNewSignature.extensionReceiverParameter?.type
+        )
+
+        return state
+            .withOldSignature(
+                Signature.create(oldSignature.name, oldReturnType, oldParameters, oldAdditionalData?.copy(receiverType = oldReceiverType))!!
+            )
+            .withNewSignature(
+                Signature.create(newSignature.name, newReturnType, newParameters, newAdditionalData?.copy(receiverType = newReceiverType))!!
+            )
+    }
+
+    private fun refineType(
+        oldTypeInCode: String?,
+        newTypeInCode: String?,
+        oldTypeResolved: KotlinType?,
+        newTypeResolved: KotlinType?
+    ): Pair<String?, String?> {
+        if (oldTypeResolved?.isError == true || newTypeResolved?.isError == true) {
+            return oldTypeInCode to newTypeInCode
+        }
+
+        val oldTypeFQ = oldTypeResolved?.fqText()
+        val newTypeFQ = newTypeResolved?.fqText()
+
+        if (oldTypeInCode != newTypeInCode) {
+            if (oldTypeFQ == newTypeFQ) {
+                return newTypeInCode to newTypeInCode
+            }
+        } else {
+            if (oldTypeFQ != newTypeFQ) {
+                return oldTypeFQ to newTypeFQ
+            }
+        }
+
+        return oldTypeInCode to newTypeInCode
+    }
+
+    private fun KotlinType.fqText() = DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(this)
+
+    override fun detectAvailableRefactoring(state: SuggestedRefactoringState): SuggestedRefactoringData? {
+        val declaration = state.declaration
+        if (declaration !is KtCallableDeclaration || KotlinSuggestedRefactoringSupport.isOnlyRenameSupported(declaration)) {
+            if (state.additionalData[HAS_USAGES] == false) return null
+            return SuggestedRenameData(declaration as PsiNamedElement, state.oldSignature.name)
+        }
+
+        val overridesName = declaration.overridesName()
+        if (overridesName == null && state.additionalData[HAS_USAGES] == false) return null
+
+        val oldSignature = state.oldSignature
+        val newSignature = state.newSignature
+        val updateUsagesData = SuggestedChangeSignatureData.create(state, USAGES)
+
+        if (hasParameterAddedRemovedOrReordered(oldSignature, newSignature)) return updateUsagesData
+
+        // for non-virtual function we can add or remove receiver for usages but not change its type
+        if ((oldSignature.receiverType == null) != (newSignature.receiverType == null)) return updateUsagesData
+
+        val (nameChanges, renameData) = nameChanges(oldSignature, newSignature, declaration, declaration.valueParameters)
+
+        if (hasTypeChanges(oldSignature, newSignature)) {
+            return if (nameChanges > 0)
+                updateUsagesData
+            else
+                overridesName?.let { updateUsagesData.copy(nameOfStuffToUpdate = it) }
+        }
+
+        return when {
+            renameData != null -> renameData
+            nameChanges > 0 -> updateUsagesData
+            else -> null
+        }
+    }
+
+    private fun KtCallableDeclaration.overridesName(): String? {
+        return when {
+            hasModifier(KtTokens.ABSTRACT_KEYWORD) -> IMPLEMENTATIONS
+            hasModifier(KtTokens.OPEN_KEYWORD) -> OVERRIDES
+            containingClassOrObject?.isInterfaceClass() == true -> if (hasBody()) OVERRIDES else IMPLEMENTATIONS
+            hasModifier(KtTokens.EXPECT_KEYWORD) -> "actual declarations"
+            else -> null
+        }
+    }
+
+    override fun hasTypeChanges(oldSignature: Signature, newSignature: Signature): Boolean {
+        return super.hasTypeChanges(oldSignature, newSignature) || oldSignature.receiverType != newSignature.receiverType
+    }
+
+    override fun hasParameterTypeChanges(oldParam: Parameter, newParam: Parameter): Boolean {
+        return super.hasParameterTypeChanges(oldParam, newParam) || oldParam.modifiers != newParam.modifiers
+    }
+}