Switch to 183 platform

.bunch

@@ -1,10 +1,10 @@
-182
-181
-173_181
-as31_173_181
-as32_181
-as33
-as34_183
 183
-191_183
-cidr183_183
+182
+181_182
+173_181_182
+as31_173_181_182
+as32_181_182
+as33_182
+as34
+191
+cidr183

compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt

@@ -7,4 +7,7 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 
-internal fun visitAnnotableParameterCount(mv: MethodVisitor, paramCount: Int) {}
+internal fun visitAnnotableParameterCount(mv: MethodVisitor, paramCount: Int) {
+    mv.visitAnnotableParameterCount(paramCount, true)
+    mv.visitAnnotableParameterCount(paramCount, false)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt.182

@@ -7,7 +7,4 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 
-internal fun visitAnnotableParameterCount(mv: MethodVisitor, paramCount: Int) {
-    mv.visitAnnotableParameterCount(paramCount, true)
-    mv.visitAnnotableParameterCount(paramCount, false)
-}
+internal fun visitAnnotableParameterCount(mv: MethodVisitor, paramCount: Int) {}

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

@@ -22,11 +22,10 @@ import com.intellij.psi.PsiModifierListOwner
 
 class MockInferredAnnotationsManager : InferredAnnotationsManager() {
     override fun findInferredAnnotation(listOwner: PsiModifierListOwner, annotationFQN: String): PsiAnnotation? = null
-    override fun ignoreInference(owner: PsiModifierListOwner, annotationFQN: String?): Boolean = true
     override fun findInferredAnnotations(listOwner: PsiModifierListOwner): Array<out PsiAnnotation> = EMPTY_PSI_ANNOTATION_ARRAY
     override fun isInferredAnnotation(annotation: PsiAnnotation): Boolean = false
 
     companion object {
         val EMPTY_PSI_ANNOTATION_ARRAY = arrayOf<PsiAnnotation>()
     }
-}
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/MockInferredAnnotationsManager.kt.182

@@ -22,10 +22,11 @@ import com.intellij.psi.PsiModifierListOwner
 
 class MockInferredAnnotationsManager : InferredAnnotationsManager() {
     override fun findInferredAnnotation(listOwner: PsiModifierListOwner, annotationFQN: String): PsiAnnotation? = null
+    override fun ignoreInference(owner: PsiModifierListOwner, annotationFQN: String?): Boolean = true
     override fun findInferredAnnotations(listOwner: PsiModifierListOwner): Array<out PsiAnnotation> = EMPTY_PSI_ANNOTATION_ARRAY
     override fun isInferredAnnotation(annotation: PsiAnnotation): Boolean = false
 
     companion object {
         val EMPTY_PSI_ANNOTATION_ARRAY = arrayOf<PsiAnnotation>()
     }
-}
+}

compiler/psi/src/org/jetbrains/kotlin/util/AstLoadingUtil.kt

@@ -18,6 +18,6 @@ import com.intellij.util.AstLoadingFilter
 object AstLoadingFilter {
     @JvmStatic
     fun <T, E : Throwable> forceAllowTreeLoading(psiFile: PsiFile, computable: ThrowableComputable<out T, E>): T {
-        return AstLoadingFilter.forceEnableTreeLoading(psiFile, computable)
+        return AstLoadingFilter.forceAllowTreeLoading(psiFile, computable)
     }
 }

compiler/psi/src/org/jetbrains/kotlin/util/AstLoadingUtil.kt.182

@@ -18,6 +18,6 @@ import com.intellij.util.AstLoadingFilter
 object AstLoadingFilter {
     @JvmStatic
     fun <T, E : Throwable> forceAllowTreeLoading(psiFile: PsiFile, computable: ThrowableComputable<out T, E>): T {
-        return AstLoadingFilter.forceAllowTreeLoading(psiFile, computable)
+        return AstLoadingFilter.forceEnableTreeLoading(psiFile, computable)
     }
 }

compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java

@@ -2,10 +2,10 @@ public final class AnnotatedParameterInInnerClassConstructor {
     public AnnotatedParameterInInnerClassConstructor() { /* compiled code */ }
 
     public final class Inner {
-        public Inner(@test.Anno(x = "a") @org.jetbrains.annotations.NotNull java.lang.String $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }
+        public Inner(@test.Anno(x = "a") @org.jetbrains.annotations.NotNull java.lang.String a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ }
     }
 
     public final class InnerGeneric <T> {
-        public InnerGeneric(@test.Anno(x = "a") T $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }
+        public InnerGeneric(@test.Anno(x = "a") T a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ }
     }
 }

compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java.182

@@ -2,10 +2,10 @@ public final class AnnotatedParameterInInnerClassConstructor {
     public AnnotatedParameterInInnerClassConstructor() { /* compiled code */ }
 
     public final class Inner {
-        public Inner(@test.Anno(x = "a") @org.jetbrains.annotations.NotNull java.lang.String a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ }
+        public Inner(@test.Anno(x = "a") @org.jetbrains.annotations.NotNull java.lang.String $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }
     }
 
     public final class InnerGeneric <T> {
-        public InnerGeneric(@test.Anno(x = "a") T a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ }
+        public InnerGeneric(@test.Anno(x = "a") T $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }
     }
 }

compiler/testData/codegen/bytecodeListing/inlineClasses/annotationsOnHiddenConstructor.txt

@@ -14,7 +14,7 @@ public final class Sealed$Inner {
     synthetic final field this$0: Sealed
     private final field z2: int
     inner class Sealed$Inner
-    public synthetic @Ann method <init>(@java.lang.Synthetic p0: Sealed, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic @Ann method <init>(p0: Sealed, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
     private method <init>(p0: Sealed, p1: int, p2: int, p3: java.lang.String): void
     public final method getZ2(): int
 }
@@ -34,7 +34,7 @@ public final class Test$Inner {
     synthetic final field this$0: Test
     private final field z2: int
     inner class Test$Inner
-    public synthetic @Ann method <init>(@java.lang.Synthetic p0: Test, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic @Ann method <init>(p0: Test, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
     private method <init>(p0: Test, p1: int, p2: int, p3: java.lang.String): void
     public final method getZ2(): int
 }

compiler/testData/codegen/bytecodeListing/inlineClasses/annotationsOnHiddenConstructor.txt.182

@@ -14,7 +14,7 @@ public final class Sealed$Inner {
     synthetic final field this$0: Sealed
     private final field z2: int
     inner class Sealed$Inner
-    public synthetic @Ann method <init>(p0: Sealed, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic @Ann method <init>(@java.lang.Synthetic p0: Sealed, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
     private method <init>(p0: Sealed, p1: int, p2: int, p3: java.lang.String): void
     public final method getZ2(): int
 }
@@ -34,7 +34,7 @@ public final class Test$Inner {
     synthetic final field this$0: Test
     private final field z2: int
     inner class Test$Inner
-    public synthetic @Ann method <init>(p0: Test, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic @Ann method <init>(@java.lang.Synthetic p0: Test, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
     private method <init>(p0: Test, p1: int, p2: int, p3: java.lang.String): void
     public final method getZ2(): int
 }

compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.txt

@@ -81,11 +81,11 @@ public final class CClassWithCompanion {
 public final class DClassConstuctors$InnerClass {
     synthetic final field this$0: DClassConstuctors
     inner class DClassConstuctors$InnerClass
-    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic @java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void
-    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int): void
-    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void
-    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, @LongRes p2: long): void
-    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, p2: int): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @LongRes p2: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, p2: int): void
     public synthetic @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, p1: int, p2: int, p3: int, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
     public synthetic @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: kotlin.jvm.internal.DefaultConstructorMarker): void
 }

compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.txt.182

@@ -81,11 +81,11 @@ public final class CClassWithCompanion {
 public final class DClassConstuctors$InnerClass {
     synthetic final field this$0: DClassConstuctors
     inner class DClassConstuctors$InnerClass
-    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int): void
-    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void
-    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void
-    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @LongRes p2: long): void
-    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, p2: int): void
+    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic @java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void
+    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int): void
+    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, @LongRes p2: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(@java.lang.Synthetic p0: DClassConstuctors, @StringRes p1: int, p2: int): void
     public synthetic @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, p1: int, p2: int, p3: int, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
     public synthetic @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: kotlin.jvm.internal.DefaultConstructorMarker): void
 }

idea/idea-android/tests/org/jetbrains/kotlin/android/AndroidTestCase.java

@@ -21,9 +21,7 @@ import com.android.tools.idea.rendering.RenderSecurityManager;
 import com.android.tools.idea.startup.AndroidCodeStyleSettingsModifier;
 import com.intellij.analysis.AnalysisScope;
 import com.intellij.codeInspection.GlobalInspectionTool;
-import com.intellij.codeInspection.InspectionManager;
 import com.intellij.codeInspection.ex.GlobalInspectionToolWrapper;
-import com.intellij.codeInspection.ex.InspectionManagerEx;
 import com.intellij.facet.FacetManager;
 import com.intellij.facet.ModifiableFacetModel;
 import com.intellij.openapi.Disposable;
@@ -41,13 +39,13 @@ import com.intellij.psi.codeStyle.CodeStyleSchemes;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
 import com.intellij.testFramework.InspectionTestUtil;
+import com.intellij.testFramework.InspectionsKt;
 import com.intellij.testFramework.ThreadTracker;
 import com.intellij.testFramework.builders.JavaModuleFixtureBuilder;
 import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory;
 import com.intellij.testFramework.fixtures.JavaTestFixtureFactory;
 import com.intellij.testFramework.fixtures.TestFixtureBuilder;
-import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl;
 import com.intellij.testFramework.fixtures.impl.GlobalInspectionContextForTests;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.android.facet.AndroidFacet;
@@ -61,6 +59,7 @@ import org.picocontainer.MutablePicoContainer;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -343,9 +342,8 @@ public abstract class AndroidTestCase extends AndroidTestBase {
 
         scope.invalidate();
 
-        InspectionManagerEx inspectionManager = (InspectionManagerEx)InspectionManager.getInstance(getProject());
         GlobalInspectionContextForTests globalContext =
-                CodeInsightTestFixtureImpl.createGlobalContextForTool(scope, getProject(), inspectionManager, wrapper);
+                InspectionsKt.createGlobalContextForTool(scope, getProject(), Collections.singletonList(wrapper));
 
         InspectionTestUtil.runTool(wrapper, scope, globalContext);
         InspectionTestUtil.compareToolResults(globalContext, wrapper, false, getTestDataPath() + globalTestDir);

idea/idea-android/tests/org/jetbrains/kotlin/android/AndroidTestCase.java.182

@@ -21,7 +21,9 @@ import com.android.tools.idea.rendering.RenderSecurityManager;
 import com.android.tools.idea.startup.AndroidCodeStyleSettingsModifier;
 import com.intellij.analysis.AnalysisScope;
 import com.intellij.codeInspection.GlobalInspectionTool;
+import com.intellij.codeInspection.InspectionManager;
 import com.intellij.codeInspection.ex.GlobalInspectionToolWrapper;
+import com.intellij.codeInspection.ex.InspectionManagerEx;
 import com.intellij.facet.FacetManager;
 import com.intellij.facet.ModifiableFacetModel;
 import com.intellij.openapi.Disposable;
@@ -39,13 +41,13 @@ import com.intellij.psi.codeStyle.CodeStyleSchemes;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
 import com.intellij.testFramework.InspectionTestUtil;
-import com.intellij.testFramework.InspectionsKt;
 import com.intellij.testFramework.ThreadTracker;
 import com.intellij.testFramework.builders.JavaModuleFixtureBuilder;
 import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory;
 import com.intellij.testFramework.fixtures.JavaTestFixtureFactory;
 import com.intellij.testFramework.fixtures.TestFixtureBuilder;
+import com.intellij.testFramework.fixtures.impl.CodeInsightTestFixtureImpl;
 import com.intellij.testFramework.fixtures.impl.GlobalInspectionContextForTests;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.android.facet.AndroidFacet;
@@ -59,7 +61,6 @@ import org.picocontainer.MutablePicoContainer;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 /**
@@ -342,8 +343,9 @@ public abstract class AndroidTestCase extends AndroidTestBase {
 
         scope.invalidate();
 
+        InspectionManagerEx inspectionManager = (InspectionManagerEx)InspectionManager.getInstance(getProject());
         GlobalInspectionContextForTests globalContext =
-                InspectionsKt.createGlobalContextForTool(scope, getProject(), Collections.singletonList(wrapper));
+                CodeInsightTestFixtureImpl.createGlobalContextForTool(scope, getProject(), inspectionManager, wrapper);
 
         InspectionTestUtil.runTool(wrapper, scope, globalContext);
         InspectionTestUtil.compareToolResults(globalContext, wrapper, false, getTestDataPath() + globalTestDir);

idea/idea-git/src/org/jetbrains/kotlin/git/KotlinExplicitMovementProvider.kt

@@ -6,12 +6,18 @@
 package org.jetbrains.kotlin.git
 
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Couple
+import com.intellij.openapi.util.registry.Registry
 import com.intellij.openapi.vcs.FilePath
 import git4idea.checkin.GitCheckinExplicitMovementProvider
 import org.jetbrains.kotlin.idea.actions.pathBeforeJ2K
 import java.util.*
 
 class KotlinExplicitMovementProvider : GitCheckinExplicitMovementProvider() {
+    init {
+        Registry.get("git.explicit.commit.renames.prohibit.multiple.calls").setValue(false)
+    }
+
     override fun isEnabled(project: Project): Boolean {
         return true
     }
@@ -36,11 +42,14 @@ class KotlinExplicitMovementProvider : GitCheckinExplicitMovementProvider() {
                 val before = beforePaths.firstOrNull { it.path == pathBeforeJ2K }
                 if (before != null) {
                     movedChanges.add(GitCheckinExplicitMovementProvider.Movement(before, after))
-                    after.virtualFile?.pathBeforeJ2K = null
                 }
             }
         }
 
         return movedChanges
     }
+
+    override fun afterMovementsCommitted(project: Project, movedPaths: MutableList<Couple<FilePath>>) {
+        movedPaths.forEach { it.second.virtualFile?.pathBeforeJ2K = null }
+    }
 }

idea/idea-git/src/org/jetbrains/kotlin/git/KotlinExplicitMovementProvider.kt.182

@@ -6,18 +6,12 @@
 package org.jetbrains.kotlin.git
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Couple
-import com.intellij.openapi.util.registry.Registry
 import com.intellij.openapi.vcs.FilePath
 import git4idea.checkin.GitCheckinExplicitMovementProvider
 import org.jetbrains.kotlin.idea.actions.pathBeforeJ2K
 import java.util.*
 
 class KotlinExplicitMovementProvider : GitCheckinExplicitMovementProvider() {
-    init {
-        Registry.get("git.explicit.commit.renames.prohibit.multiple.calls").setValue(false)
-    }
-
     override fun isEnabled(project: Project): Boolean {
         return true
     }
@@ -42,14 +36,11 @@ class KotlinExplicitMovementProvider : GitCheckinExplicitMovementProvider() {
                 val before = beforePaths.firstOrNull { it.path == pathBeforeJ2K }
                 if (before != null) {
                     movedChanges.add(GitCheckinExplicitMovementProvider.Movement(before, after))
+                    after.virtualFile?.pathBeforeJ2K = null
                 }
             }
         }
 
         return movedChanges
     }
-
-    override fun afterMovementsCommitted(project: Project, movedPaths: MutableList<Couple<FilePath>>) {
-        movedPaths.forEach { it.second.virtualFile?.pathBeforeJ2K = null }
-    }
 }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/runConfigurationsCompat.kt

@@ -14,16 +14,16 @@ import org.jdom.Element
 
 // Generalized in 183
 // BUNCH: 183
-typealias RunConfigurationBaseAny = RunConfigurationBase
+typealias RunConfigurationBaseAny = RunConfigurationBase<*>
 
 // Generalized in 183
 // BUNCH: 183
-typealias ModuleBasedConfigurationAny = ModuleBasedConfiguration<*>
+typealias ModuleBasedConfigurationAny = ModuleBasedConfiguration<*, *>
 
 // Generalized in 183
 // BUNCH: 183
-typealias LocatableConfigurationBaseAny = LocatableConfigurationBase
+typealias LocatableConfigurationBaseAny = LocatableConfigurationBase<Any>
 
 // Generalized in 183
 // BUNCH: 183
-typealias ModuleBasedConfigurationElement<T> = ModuleBasedConfiguration<T>
+typealias ModuleBasedConfigurationElement<T> = ModuleBasedConfiguration<T, Element>

idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/runConfigurationsCompat.kt.182

@@ -14,16 +14,16 @@ import org.jdom.Element
 
 // Generalized in 183
 // BUNCH: 183
-typealias RunConfigurationBaseAny = RunConfigurationBase<*>
+typealias RunConfigurationBaseAny = RunConfigurationBase
 
 // Generalized in 183
 // BUNCH: 183
-typealias ModuleBasedConfigurationAny = ModuleBasedConfiguration<*, *>
+typealias ModuleBasedConfigurationAny = ModuleBasedConfiguration<*>
 
 // Generalized in 183
 // BUNCH: 183
-typealias LocatableConfigurationBaseAny = LocatableConfigurationBase<Any>
+typealias LocatableConfigurationBaseAny = LocatableConfigurationBase
 
 // Generalized in 183
 // BUNCH: 183
-typealias ModuleBasedConfigurationElement<T> = ModuleBasedConfiguration<T, Element>
+typealias ModuleBasedConfigurationElement<T> = ModuleBasedConfiguration<T>

idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/MavenImportingTestCase.java

@@ -46,7 +46,6 @@ import org.jetbrains.idea.maven.execution.*;
 import org.jetbrains.idea.maven.model.MavenArtifact;
 import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
 import org.jetbrains.idea.maven.project.*;
-import org.jetbrains.idea.maven.server.MavenServerManager;
 import org.jetbrains.jps.model.java.JavaResourceRootType;
 import org.jetbrains.jps.model.java.JavaSourceRootProperties;
 import org.jetbrains.jps.model.java.JavaSourceRootType;
@@ -389,32 +388,14 @@ public abstract class MavenImportingTestCase extends MavenTestCase {
     }
 
     protected void importProjectWithProfiles(String... profiles) {
-        doImportProjects(true, Collections.singletonList(myProjectPom), profiles);
-    }
-
-    protected void importProject(VirtualFile file) {
-        importProjects(file);
+        doImportProjects(Collections.singletonList(myProjectPom), profiles);
     }
 
     protected void importProjects(VirtualFile... files) {
-        doImportProjects(true, Arrays.asList(files));
+        doImportProjects(Arrays.asList(files));
     }
 
-    protected void importProjectWithMaven3(@NonNls String xml) throws IOException {
-        createProjectPom(xml);
-        importProjectWithMaven3();
-    }
-
-    protected void importProjectWithMaven3() {
-        importProjectWithMaven3WithProfiles();
-    }
-
-    protected void importProjectWithMaven3WithProfiles(String... profiles) {
-        doImportProjects(false, Collections.singletonList(myProjectPom), profiles);
-    }
-
-    private void doImportProjects(boolean useMaven2, final List<VirtualFile> files, String... profiles) {
-        MavenServerManager.getInstance().setUseMaven2(useMaven2);
+    private void doImportProjects(List<VirtualFile> files, String... profiles) {
         initProjectsManager(false);
 
         readProjects(files, profiles);

idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/MavenImportingTestCase.java.182

@@ -46,6 +46,7 @@ import org.jetbrains.idea.maven.execution.*;
 import org.jetbrains.idea.maven.model.MavenArtifact;
 import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
 import org.jetbrains.idea.maven.project.*;
+import org.jetbrains.idea.maven.server.MavenServerManager;
 import org.jetbrains.jps.model.java.JavaResourceRootType;
 import org.jetbrains.jps.model.java.JavaSourceRootProperties;
 import org.jetbrains.jps.model.java.JavaSourceRootType;
@@ -388,14 +389,32 @@ public abstract class MavenImportingTestCase extends MavenTestCase {
     }
 
     protected void importProjectWithProfiles(String... profiles) {
-        doImportProjects(Collections.singletonList(myProjectPom), profiles);
+        doImportProjects(true, Collections.singletonList(myProjectPom), profiles);
+    }
+
+    protected void importProject(VirtualFile file) {
+        importProjects(file);
     }
 
     protected void importProjects(VirtualFile... files) {
-        doImportProjects(Arrays.asList(files));
+        doImportProjects(true, Arrays.asList(files));
     }
 
-    private void doImportProjects(List<VirtualFile> files, String... profiles) {
+    protected void importProjectWithMaven3(@NonNls String xml) throws IOException {
+        createProjectPom(xml);
+        importProjectWithMaven3();
+    }
+
+    protected void importProjectWithMaven3() {
+        importProjectWithMaven3WithProfiles();
+    }
+
+    protected void importProjectWithMaven3WithProfiles(String... profiles) {
+        doImportProjects(false, Collections.singletonList(myProjectPom), profiles);
+    }
+
+    private void doImportProjects(boolean useMaven2, final List<VirtualFile> files, String... profiles) {
+        MavenServerManager.getInstance().setUseMaven2(useMaven2);
         initProjectsManager(false);
 
         readProjects(files, profiles);

idea/performanceTests/org/jetbrains/kotlin/idea/perf/WholeProjectLightClassTest.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.idea.perf
 
+import com.intellij.openapi.util.registry.Registry
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.toLightClass
@@ -64,4 +65,9 @@ class WholeProjectLightClassTest : WholeProjectPerformanceTest(), WholeProjectKo
 
         return PerFileTestResult(results, totalNs, errors)
     }
+
+    fun testUltraLightPerformance() {
+        Registry.get("kotlin.use.ultra.light.classes").setValue(true, testRootDisposable)
+        testWholeProjectPerformance()
+    }
 }

idea/performanceTests/org/jetbrains/kotlin/idea/perf/WholeProjectLightClassTest.kt.182

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.idea.perf
 
-import com.intellij.openapi.util.registry.Registry
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration
 import org.jetbrains.kotlin.asJava.toLightClass
@@ -65,9 +64,4 @@ class WholeProjectLightClassTest : WholeProjectPerformanceTest(), WholeProjectKo
 
         return PerFileTestResult(results, totalNs, errors)
     }
-
-    fun testUltraLightPerformance() {
-        Registry.get("kotlin.use.ultra.light.classes").setValue(true, testRootDisposable)
-        testWholeProjectPerformance()
-    }
 }

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="182.4323.46" until-build="182.*"/>
+  <idea-version since-build="183.1" until-build="191.*"/>
 
   <depends>com.intellij.modules.platform</depends>
 
@@ -55,13 +55,6 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
 
   <xi:include href="kotlinx-serialization.xml" xpointer="xpointer(/idea-plugin/*)"/>
 
-  <project-components>
-    <component>
-      <!-- This is a workaround for IDEA < 183. For details, see IDEA-200525. -->
-      <implementation-class>org.jetbrains.kotlin.idea.caches.ProjectRootModificationTrackerFixer</implementation-class>
-    </component>
-  </project-components>
-
   <extensionPoints>
     <xi:include href="extensions/compiler.xml" xpointer="xpointer(/idea-plugin/extensionPoints/*)"/>
 
@@ -74,4 +67,8 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
   <extensions defaultExtensionNs="com.intellij.jvm">
     <declarationSearcher language="kotlin" implementationClass="org.jetbrains.kotlin.idea.jvm.KotlinDeclarationSearcher"/>
   </extensions>
+
+  <extensions defaultExtensionNs="com.intellij.codeInsight">
+      <nonBlockingContextChecker implementation="org.jetbrains.kotlin.idea.inspections.blockingCallsDetection.CoroutineNonBlockingContextChecker"/>
+    </extensions>
 </idea-plugin>

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

@@ -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="183.1" until-build="191.*"/>
+  <idea-version since-build="182.4323.46" until-build="182.*"/>
 
   <depends>com.intellij.modules.platform</depends>
 
@@ -55,6 +55,13 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
 
   <xi:include href="kotlinx-serialization.xml" xpointer="xpointer(/idea-plugin/*)"/>
 
+  <project-components>
+    <component>
+      <!-- This is a workaround for IDEA < 183. For details, see IDEA-200525. -->
+      <implementation-class>org.jetbrains.kotlin.idea.caches.ProjectRootModificationTrackerFixer</implementation-class>
+    </component>
+  </project-components>
+
   <extensionPoints>
     <xi:include href="extensions/compiler.xml" xpointer="xpointer(/idea-plugin/extensionPoints/*)"/>
 
@@ -67,8 +74,4 @@ The Kotlin plugin provides language support in IntelliJ IDEA and Android Studio.
   <extensions defaultExtensionNs="com.intellij.jvm">
     <declarationSearcher language="kotlin" implementationClass="org.jetbrains.kotlin.idea.jvm.KotlinDeclarationSearcher"/>
   </extensions>
-
-  <extensions defaultExtensionNs="com.intellij.codeInsight">
-      <nonBlockingContextChecker implementation="org.jetbrains.kotlin.idea.inspections.blockingCallsDetection.CoroutineNonBlockingContextChecker"/>
-    </extensions>
 </idea-plugin>

idea/src/org/jetbrains/kotlin/idea/quickfix/crossLanguage/KotlinElementActionsFactory.kt

@@ -20,10 +20,7 @@ import com.intellij.codeInsight.daemon.QuickFixBundle
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.codeInsight.intention.QuickFixFactory
 import com.intellij.lang.java.beans.PropertyKind
-import com.intellij.lang.jvm.JvmClass
-import com.intellij.lang.jvm.JvmElement
-import com.intellij.lang.jvm.JvmModifier
-import com.intellij.lang.jvm.JvmModifiersOwner
+import com.intellij.lang.jvm.*
 import com.intellij.lang.jvm.actions.*
 import com.intellij.lang.jvm.types.JvmType
 import com.intellij.openapi.editor.Editor
@@ -147,7 +144,7 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
     }
 
     class CreatePropertyFix(
-        contextElement: KtElement,
+            contextElement: KtElement,
         propertyInfo: PropertyInfo,
         private val classOrFileName: String?
     ) : CreateCallableFromUsageFix<KtElement>(contextElement, listOf(propertyInfo)) {
@@ -350,16 +347,17 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
         val ktType = (propertyType as? PsiType)?.resolveToKotlinType(resolutionFacade) ?: nullableAnyType
         val propertyInfo = PropertyInfo(
             propertyName,
-            TypeInfo.Empty,
-            TypeInfo(ktType, Variance.INVARIANT),
+                TypeInfo.Empty,
+                TypeInfo(ktType, Variance.INVARIANT),
             setterRequired,
-            listOf(targetContainer),
-            modifierList = modifierBuilder.modifierList,
-            withInitializer = true
+                listOf(targetContainer),
+                modifierList = modifierBuilder.modifierList,
+                withInitializer = true
         )
         val propertyInfos = if (setterRequired) {
             listOf(propertyInfo, propertyInfo.copyProperty(isLateinitPreferred = true))
-        } else {
+        }
+        else {
             listOf(propertyInfo)
         }
         return propertyInfos.map { CreatePropertyFix(targetContainer, it, classOrFileName) }
@@ -426,7 +424,6 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
             preferEmptyBody = true
         )
         val targetClassName = targetClass.name
-
         val action = object : CreateCallableFromUsageFix<KtElement>(targetContainer, listOf(functionInfo)) {
             override fun getFamilyName() = "Add method"
             override fun getText() = "Add method '$methodName' to '$targetClassName'"
@@ -503,6 +500,21 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
 
     }
 
+    override fun createChangeParametersActions(target: JvmMethod, request: ChangeParametersRequest): List<IntentionAction> {
+        val ktNamedFunction = (target as? KtLightElement<*, *>)?.kotlinOrigin as? KtNamedFunction ?: return emptyList()
+
+        val helper = JvmPsiConversionHelper.getInstance(target.project)
+
+        val params = request.expectedParameters.map { ep ->
+            val name = ep.semanticNames.singleOrNull() ?: return emptyList()
+            val expectedType = ep.expectedTypes.singleOrNull() ?: return emptyList()
+
+            val kotlinType =
+                helper.convertType(expectedType.theType).resolveToKotlinType(ktNamedFunction.getResolutionFacade()) ?: return emptyList()
+            Name.identifier(name) to kotlinType
+        }
+        return listOf(ChangeMethodParameters(ktNamedFunction, params, { request.isValid }))
+    }
 }
 
 private fun JvmPsiConversionHelper.asPsiType(param: Pair<SuggestedNameInfo, List<ExpectedType>>): PsiType? =

idea/src/org/jetbrains/kotlin/idea/quickfix/crossLanguage/KotlinElementActionsFactory.kt.182

@@ -20,7 +20,10 @@ import com.intellij.codeInsight.daemon.QuickFixBundle
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.codeInsight.intention.QuickFixFactory
 import com.intellij.lang.java.beans.PropertyKind
-import com.intellij.lang.jvm.*
+import com.intellij.lang.jvm.JvmClass
+import com.intellij.lang.jvm.JvmElement
+import com.intellij.lang.jvm.JvmModifier
+import com.intellij.lang.jvm.JvmModifiersOwner
 import com.intellij.lang.jvm.actions.*
 import com.intellij.lang.jvm.types.JvmType
 import com.intellij.openapi.editor.Editor
@@ -144,7 +147,7 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
     }
 
     class CreatePropertyFix(
-            contextElement: KtElement,
+        contextElement: KtElement,
         propertyInfo: PropertyInfo,
         private val classOrFileName: String?
     ) : CreateCallableFromUsageFix<KtElement>(contextElement, listOf(propertyInfo)) {
@@ -347,17 +350,16 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
         val ktType = (propertyType as? PsiType)?.resolveToKotlinType(resolutionFacade) ?: nullableAnyType
         val propertyInfo = PropertyInfo(
             propertyName,
-                TypeInfo.Empty,
-                TypeInfo(ktType, Variance.INVARIANT),
+            TypeInfo.Empty,
+            TypeInfo(ktType, Variance.INVARIANT),
             setterRequired,
-                listOf(targetContainer),
-                modifierList = modifierBuilder.modifierList,
-                withInitializer = true
+            listOf(targetContainer),
+            modifierList = modifierBuilder.modifierList,
+            withInitializer = true
         )
         val propertyInfos = if (setterRequired) {
             listOf(propertyInfo, propertyInfo.copyProperty(isLateinitPreferred = true))
-        }
-        else {
+        } else {
             listOf(propertyInfo)
         }
         return propertyInfos.map { CreatePropertyFix(targetContainer, it, classOrFileName) }
@@ -424,6 +426,7 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
             preferEmptyBody = true
         )
         val targetClassName = targetClass.name
+
         val action = object : CreateCallableFromUsageFix<KtElement>(targetContainer, listOf(functionInfo)) {
             override fun getFamilyName() = "Add method"
             override fun getText() = "Add method '$methodName' to '$targetClassName'"
@@ -500,21 +503,6 @@ class KotlinElementActionsFactory : JvmElementActionsFactory() {
 
     }
 
-    override fun createChangeParametersActions(target: JvmMethod, request: ChangeParametersRequest): List<IntentionAction> {
-        val ktNamedFunction = (target as? KtLightElement<*, *>)?.kotlinOrigin as? KtNamedFunction ?: return emptyList()
-
-        val helper = JvmPsiConversionHelper.getInstance(target.project)
-
-        val params = request.expectedParameters.map { ep ->
-            val name = ep.semanticNames.singleOrNull() ?: return emptyList()
-            val expectedType = ep.expectedTypes.singleOrNull() ?: return emptyList()
-
-            val kotlinType =
-                helper.convertType(expectedType.theType).resolveToKotlinType(ktNamedFunction.getResolutionFacade()) ?: return emptyList()
-            Name.identifier(name) to kotlinType
-        }
-        return listOf(ChangeMethodParameters(ktNamedFunction, params, { request.isValid }))
-    }
 }
 
 private fun JvmPsiConversionHelper.asPsiType(param: Pair<SuggestedNameInfo, List<ExpectedType>>): PsiType? =

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/PsiElementChecker.kt

@@ -59,7 +59,7 @@ object PsiElementChecker {
 
         with(element) {
             try {
-                Assert.assertEquals("Number of methods has changed. Please update test.", 54, PsiElement::class.java.methods.size)
+                Assert.assertEquals("Number of methods has changed. Please update test.", 55, PsiElement::class.java.methods.size)
 
                 project
                 Assert.assertTrue(language == KotlinLanguage.INSTANCE)
@@ -72,6 +72,7 @@ object PsiElementChecker {
                 prevSibling
                 containingFile
                 textRange
+                //textRangeInParent - throws an exception for non-physical elements, it is expected behaviour
                 startOffsetInParent
                 textLength
                 findElementAt(0)

idea/tests/org/jetbrains/kotlin/idea/caches/resolve/PsiElementChecker.kt.182

@@ -59,7 +59,7 @@ object PsiElementChecker {
 
         with(element) {
             try {
-                Assert.assertEquals("Number of methods has changed. Please update test.", 55, PsiElement::class.java.methods.size)
+                Assert.assertEquals("Number of methods has changed. Please update test.", 54, PsiElement::class.java.methods.size)
 
                 project
                 Assert.assertTrue(language == KotlinLanguage.INSTANCE)
@@ -72,7 +72,6 @@ object PsiElementChecker {
                 prevSibling
                 containingFile
                 textRange
-                //textRangeInParent - throws an exception for non-physical elements, it is expected behaviour
                 startOffsetInParent
                 textLength
                 findElementAt(0)

idea/tests/org/jetbrains/kotlin/idea/quickfix/CommonIntentionActionsTest.kt

@@ -19,15 +19,14 @@ package org.jetbrains.kotlin.idea.quickfix
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.lang.jvm.JvmClass
 import com.intellij.lang.jvm.JvmElement
+import com.intellij.lang.jvm.JvmMethod
 import com.intellij.lang.jvm.JvmModifier
 import com.intellij.lang.jvm.actions.*
 import com.intellij.lang.jvm.types.JvmSubstitutor
+import com.intellij.lang.jvm.types.JvmType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Pair.pair
-import com.intellij.psi.PsiJvmSubstitutor
-import com.intellij.psi.PsiMethod
-import com.intellij.psi.PsiSubstitutor
-import com.intellij.psi.PsiType
+import com.intellij.psi.*
 import com.intellij.psi.codeStyle.SuggestedNameInfo
 import com.intellij.testFramework.fixtures.CodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase
@@ -35,6 +34,9 @@ import org.jetbrains.kotlin.asJava.toLightElements
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.psi.KtModifierListOwner
+import org.jetbrains.uast.UMethod
+import org.jetbrains.uast.UParameter
+import org.jetbrains.uast.UastContext
 import org.jetbrains.uast.toUElement
 import org.junit.Assert
 
@@ -401,15 +403,15 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
 
         myFixture.launchAction(
             createMethodActions(
-                myFixture.atCaret(),
+                        myFixture.atCaret(),
                 SimpleMethodRequest(
                     project,
                     methodName = "setBaz",
                     modifiers = listOf(JvmModifier.PUBLIC),
                     returnType = expectedTypes(),
                     parameters = expectedParams(PsiType.getTypeByName("java.lang.String", project, project.allScope()))
-                )
-            ).findWithText("Add 'var' property 'baz' to 'Foo'")
+                        )
+                ).findWithText("Add 'var' property 'baz' to 'Foo'")
         )
         myFixture.checkResult("""
         |class Foo {
@@ -429,15 +431,15 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
 
         myFixture.launchAction(
             createMethodActions(
-                myFixture.atCaret(),
+                        myFixture.atCaret(),
                 SimpleMethodRequest(
                     project,
                     methodName = "setBaz",
                     modifiers = listOf(JvmModifier.PUBLIC),
                     returnType = expectedTypes(),
                     parameters = expectedParams(PsiType.getTypeByName("java.lang.String", project, project.allScope()))
-                )
-            ).findWithText("Add 'lateinit var' property 'baz' to 'Foo'")
+                        )
+                ).findWithText("Add 'lateinit var' property 'baz' to 'Foo'")
         )
         myFixture.checkResult("""
         |class Foo {
@@ -515,15 +517,15 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
 
         myFixture.launchAction(
             createMethodActions(
-                myFixture.atCaret(),
+                        myFixture.atCaret(),
                 SimpleMethodRequest(
                     project,
                     methodName = "getBaz",
                     modifiers = listOf(JvmModifier.PUBLIC),
                     returnType = expectedTypes(PsiType.getTypeByName("java.lang.String", project, project.allScope())),
                     parameters = expectedParams()
-                )
-            ).findWithText("Add 'val' property 'baz' to 'Foo'")
+                        )
+                ).findWithText("Add 'val' property 'baz' to 'Foo'")
         )
         myFixture.checkResult("""
         |class Foo {
@@ -534,6 +536,45 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
         """.trim().trimMargin(), true)
     }
 
+    fun testSetParameters() {
+        myFixture.configureByText(
+            "foo.kt", """
+        |class Foo {
+        |    fun ba<caret>r() {}
+        |}
+        """.trim().trimMargin()
+        )
+
+
+        myFixture.launchAction(
+            com.intellij.lang.jvm.actions.createChangeParametersActions(
+                myFixture.atCaret<UMethod>().javaPsi,
+                setMethodParametersRequest(
+                    linkedMapOf<String, JvmType>(
+                        "i" to PsiType.INT,
+                        "file" to PsiType.getTypeByName("java.io.File", project, myFixture.file.resolveScope)
+                    ).entries
+                )
+            ).findWithText("Change method parameters to '(i: Int, file: File)'")
+        )
+        myFixture.checkResult(
+            """
+        import java.io.File
+
+        class Foo {
+            fun bar(i: Int, file: File) {}
+        }
+        """.trimIndent(), true
+        )
+    }
+
+    private fun makeParams(vararg psyTypes: PsiType): List<UParameter> {
+        val uastContext = UastContext(myFixture.project)
+        val factory = JavaPsiFacade.getElementFactory(myFixture.project)
+        val parameters = psyTypes.mapIndexed { index, psiType -> factory.createParameter("param$index", psiType) }
+        return parameters.map { uastContext.convertElement(it, null, UParameter::class.java) as UParameter }
+    }
+
     private fun expectedTypes(vararg psiTypes: PsiType) = psiTypes.map { expectedType(it) }
 
     private fun expectedParams(vararg psyTypes: PsiType) =

idea/tests/org/jetbrains/kotlin/idea/quickfix/CommonIntentionActionsTest.kt.182

@@ -19,14 +19,15 @@ package org.jetbrains.kotlin.idea.quickfix
 import com.intellij.codeInsight.intention.IntentionAction
 import com.intellij.lang.jvm.JvmClass
 import com.intellij.lang.jvm.JvmElement
-import com.intellij.lang.jvm.JvmMethod
 import com.intellij.lang.jvm.JvmModifier
 import com.intellij.lang.jvm.actions.*
 import com.intellij.lang.jvm.types.JvmSubstitutor
-import com.intellij.lang.jvm.types.JvmType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Pair.pair
-import com.intellij.psi.*
+import com.intellij.psi.PsiJvmSubstitutor
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiSubstitutor
+import com.intellij.psi.PsiType
 import com.intellij.psi.codeStyle.SuggestedNameInfo
 import com.intellij.testFramework.fixtures.CodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase
@@ -34,9 +35,6 @@ import org.jetbrains.kotlin.asJava.toLightElements
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.psi.KtModifierListOwner
-import org.jetbrains.uast.UMethod
-import org.jetbrains.uast.UParameter
-import org.jetbrains.uast.UastContext
 import org.jetbrains.uast.toUElement
 import org.junit.Assert
 
@@ -403,15 +401,15 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
 
         myFixture.launchAction(
             createMethodActions(
-                        myFixture.atCaret(),
+                myFixture.atCaret(),
                 SimpleMethodRequest(
                     project,
                     methodName = "setBaz",
                     modifiers = listOf(JvmModifier.PUBLIC),
                     returnType = expectedTypes(),
                     parameters = expectedParams(PsiType.getTypeByName("java.lang.String", project, project.allScope()))
-                        )
-                ).findWithText("Add 'var' property 'baz' to 'Foo'")
+                )
+            ).findWithText("Add 'var' property 'baz' to 'Foo'")
         )
         myFixture.checkResult("""
         |class Foo {
@@ -431,15 +429,15 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
 
         myFixture.launchAction(
             createMethodActions(
-                        myFixture.atCaret(),
+                myFixture.atCaret(),
                 SimpleMethodRequest(
                     project,
                     methodName = "setBaz",
                     modifiers = listOf(JvmModifier.PUBLIC),
                     returnType = expectedTypes(),
                     parameters = expectedParams(PsiType.getTypeByName("java.lang.String", project, project.allScope()))
-                        )
-                ).findWithText("Add 'lateinit var' property 'baz' to 'Foo'")
+                )
+            ).findWithText("Add 'lateinit var' property 'baz' to 'Foo'")
         )
         myFixture.checkResult("""
         |class Foo {
@@ -517,15 +515,15 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
 
         myFixture.launchAction(
             createMethodActions(
-                        myFixture.atCaret(),
+                myFixture.atCaret(),
                 SimpleMethodRequest(
                     project,
                     methodName = "getBaz",
                     modifiers = listOf(JvmModifier.PUBLIC),
                     returnType = expectedTypes(PsiType.getTypeByName("java.lang.String", project, project.allScope())),
                     parameters = expectedParams()
-                        )
-                ).findWithText("Add 'val' property 'baz' to 'Foo'")
+                )
+            ).findWithText("Add 'val' property 'baz' to 'Foo'")
         )
         myFixture.checkResult("""
         |class Foo {
@@ -536,45 +534,6 @@ class CommonIntentionActionsTest : LightPlatformCodeInsightFixtureTestCase() {
         """.trim().trimMargin(), true)
     }
 
-    fun testSetParameters() {
-        myFixture.configureByText(
-            "foo.kt", """
-        |class Foo {
-        |    fun ba<caret>r() {}
-        |}
-        """.trim().trimMargin()
-        )
-
-
-        myFixture.launchAction(
-            com.intellij.lang.jvm.actions.createChangeParametersActions(
-                myFixture.atCaret<UMethod>().javaPsi,
-                setMethodParametersRequest(
-                    linkedMapOf<String, JvmType>(
-                        "i" to PsiType.INT,
-                        "file" to PsiType.getTypeByName("java.io.File", project, myFixture.file.resolveScope)
-                    ).entries
-                )
-            ).findWithText("Change method parameters to '(i: Int, file: File)'")
-        )
-        myFixture.checkResult(
-            """
-        import java.io.File
-
-        class Foo {
-            fun bar(i: Int, file: File) {}
-        }
-        """.trimIndent(), true
-        )
-    }
-
-    private fun makeParams(vararg psyTypes: PsiType): List<UParameter> {
-        val uastContext = UastContext(myFixture.project)
-        val factory = JavaPsiFacade.getElementFactory(myFixture.project)
-        val parameters = psyTypes.mapIndexed { index, psiType -> factory.createParameter("param$index", psiType) }
-        return parameters.map { uastContext.convertElement(it, null, UParameter::class.java) as UParameter }
-    }
-
     private fun expectedTypes(vararg psiTypes: PsiType) = psiTypes.map { expectedType(it) }
 
     private fun expectedParams(vararg psyTypes: PsiType) =

plugins/uast-kotlin-idea/src/IdeaKotlinUastResolveProviderService.kt

@@ -22,12 +22,16 @@ import org.jetbrains.kotlin.codegen.state.IncompatibleClassTracker
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.idea.core.resolveCandidates
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.uast.kotlin.KotlinUastResolveProviderService
@@ -52,4 +56,11 @@ class IdeaKotlinUastResolveProviderService : KotlinUastResolveProviderService {
     override fun getLanguageVersionSettings(element: KtElement): LanguageVersionSettings {
         return element.languageVersionSettings
     }
+
+    override fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor> {
+        val resolutionFacade = ktElement.getResolutionFacade()
+        val bindingContext = ktElement.analyze()
+        val call = ktElement.getCall(bindingContext) ?: return emptySequence()
+        return call.resolveCandidates(bindingContext, resolutionFacade).map { it.candidateDescriptor }.asSequence()
+    }
 }

plugins/uast-kotlin-idea/src/IdeaKotlinUastResolveProviderService.kt.182

@@ -22,16 +22,12 @@ import org.jetbrains.kotlin.codegen.state.IncompatibleClassTracker
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.idea.core.resolveCandidates
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.util.module
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.uast.kotlin.KotlinUastResolveProviderService
@@ -56,11 +52,4 @@ class IdeaKotlinUastResolveProviderService : KotlinUastResolveProviderService {
     override fun getLanguageVersionSettings(element: KtElement): LanguageVersionSettings {
         return element.languageVersionSettings
     }
-
-    override fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor> {
-        val resolutionFacade = ktElement.getResolutionFacade()
-        val bindingContext = ktElement.analyze()
-        val call = ktElement.getCall(bindingContext) ?: return emptySequence()
-        return call.resolveCandidates(bindingContext, resolutionFacade).map { it.candidateDescriptor }.asSequence()
-    }
 }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/KotlinUastLanguagePlugin.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -49,6 +50,7 @@ interface KotlinUastResolveProviderService {
     fun getTypeMapper(element: KtElement): KotlinTypeMapper?
     fun getLanguageVersionSettings(element: KtElement): LanguageVersionSettings
     fun isJvmElement(psiElement: PsiElement): Boolean
+    fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor>
 }
 
 var PsiElement.destructuringDeclarationInitializer: Boolean? by UserDataProperty(Key.create("kotlin.uast.destructuringDeclarationInitializer"))

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/KotlinUastLanguagePlugin.kt.182

@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -50,7 +49,6 @@ interface KotlinUastResolveProviderService {
     fun getTypeMapper(element: KtElement): KotlinTypeMapper?
     fun getLanguageVersionSettings(element: KtElement): LanguageVersionSettings
     fun isJvmElement(psiElement: PsiElement): Boolean
-    fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor>
 }
 
 var PsiElement.destructuringDeclarationInitializer: Boolean? by UserDataProperty(Key.create("kotlin.uast.destructuringDeclarationInitializer"))

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUAnnotation.kt

@@ -3,6 +3,7 @@ package org.jetbrains.uast.kotlin
 import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
+import com.intellij.psi.ResolveResult
 import org.jetbrains.kotlin.asJava.toLightAnnotation
 import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -22,11 +23,12 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
 import org.jetbrains.uast.*
 import org.jetbrains.uast.kotlin.declarations.KotlinUIdentifier
 import org.jetbrains.uast.kotlin.declarations.KotlinUMethod
+import org.jetbrains.uast.kotlin.internal.multiResolveResults
 
 abstract class KotlinUAnnotationBase<T : KtCallElement>(
     final override val sourcePsi: T,
     givenParent: UElement?
-) : KotlinAbstractUElement(givenParent), UAnnotationEx, UAnchorOwner {
+) : KotlinAbstractUElement(givenParent), UAnnotationEx, UAnchorOwner, UMultiResolvable {
 
     abstract override val javaPsi: PsiAnnotation?
 
@@ -100,6 +102,8 @@ abstract class KotlinUAnnotationBase<T : KtCallElement>(
         }
         return superParent
     }
+
+    override fun multiResolve(): Iterable<ResolveResult> = sourcePsi.multiResolveResults().asIterable()
 }
 
 class KotlinUAnnotation(

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/declarations/KotlinUAnnotation.kt.182

@@ -3,7 +3,6 @@ package org.jetbrains.uast.kotlin
 import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
-import com.intellij.psi.ResolveResult
 import org.jetbrains.kotlin.asJava.toLightAnnotation
 import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -23,12 +22,11 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
 import org.jetbrains.uast.*
 import org.jetbrains.uast.kotlin.declarations.KotlinUIdentifier
 import org.jetbrains.uast.kotlin.declarations.KotlinUMethod
-import org.jetbrains.uast.kotlin.internal.multiResolveResults
 
 abstract class KotlinUAnnotationBase<T : KtCallElement>(
     final override val sourcePsi: T,
     givenParent: UElement?
-) : KotlinAbstractUElement(givenParent), UAnnotationEx, UAnchorOwner, UMultiResolvable {
+) : KotlinAbstractUElement(givenParent), UAnnotationEx, UAnchorOwner {
 
     abstract override val javaPsi: PsiAnnotation?
 
@@ -102,8 +100,6 @@ abstract class KotlinUAnnotationBase<T : KtCallElement>(
         }
         return superParent
     }
-
-    override fun multiResolve(): Iterable<ResolveResult> = sourcePsi.multiResolveResults().asIterable()
 }
 
 class KotlinUAnnotation(

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/expressions/KotlinUCallableReferenceExpression.kt

@@ -17,16 +17,19 @@
 package org.jetbrains.uast.kotlin
 
 import com.intellij.psi.PsiNamedElement
+import com.intellij.psi.ResolveResult
 import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.resolve.BindingContext.DOUBLE_COLON_LHS
 import org.jetbrains.uast.UCallableReferenceExpression
 import org.jetbrains.uast.UElement
 import org.jetbrains.uast.UExpression
+import org.jetbrains.uast.UMultiResolvable
+import org.jetbrains.uast.kotlin.internal.getResolveResultVariants
 
 class KotlinUCallableReferenceExpression(
         override val psi: KtCallableReferenceExpression,
         givenParent: UElement?
-) : KotlinAbstractUExpression(givenParent), UCallableReferenceExpression, KotlinUElementWithType {
+) : KotlinAbstractUExpression(givenParent), UCallableReferenceExpression, UMultiResolvable, KotlinUElementWithType {
     override val qualifierExpression: UExpression?
         get() {
             if (qualifierType != null) return null
@@ -46,4 +49,7 @@ class KotlinUCallableReferenceExpression(
         get() = (resolve() as? PsiNamedElement)?.name
 
     override fun resolve() = psi.callableReference.resolveCallToDeclaration(this)
+
+    override fun multiResolve(): Iterable<ResolveResult> = getResolveResultVariants(psi.callableReference)
+
 }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/expressions/KotlinUCallableReferenceExpression.kt.182

@@ -17,19 +17,16 @@
 package org.jetbrains.uast.kotlin
 
 import com.intellij.psi.PsiNamedElement
-import com.intellij.psi.ResolveResult
 import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.resolve.BindingContext.DOUBLE_COLON_LHS
 import org.jetbrains.uast.UCallableReferenceExpression
 import org.jetbrains.uast.UElement
 import org.jetbrains.uast.UExpression
-import org.jetbrains.uast.UMultiResolvable
-import org.jetbrains.uast.kotlin.internal.getResolveResultVariants
 
 class KotlinUCallableReferenceExpression(
         override val psi: KtCallableReferenceExpression,
         givenParent: UElement?
-) : KotlinAbstractUExpression(givenParent), UCallableReferenceExpression, UMultiResolvable, KotlinUElementWithType {
+) : KotlinAbstractUExpression(givenParent), UCallableReferenceExpression, KotlinUElementWithType {
     override val qualifierExpression: UExpression?
         get() {
             if (qualifierType != null) return null
@@ -49,7 +46,4 @@ class KotlinUCallableReferenceExpression(
         get() = (resolve() as? PsiNamedElement)?.name
 
     override fun resolve() = psi.callableReference.resolveCallToDeclaration(this)
-
-    override fun multiResolve(): Iterable<ResolveResult> = getResolveResultVariants(psi.callableReference)
-
 }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/expressions/KotlinUFunctionCallExpression.kt

@@ -16,10 +16,13 @@
 
 package org.jetbrains.uast.kotlin
 
+import com.intellij.openapi.util.registry.Registry
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiNamedElement
 import com.intellij.psi.PsiType
+import com.intellij.psi.util.PsiTypesUtil
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
@@ -30,16 +33,20 @@ import org.jetbrains.kotlin.resolve.CompileTimeConstantUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.uast.*
 import org.jetbrains.uast.internal.acceptList
 import org.jetbrains.uast.kotlin.declarations.KotlinUIdentifier
+import org.jetbrains.uast.kotlin.internal.TypedResolveResult
+import org.jetbrains.uast.kotlin.internal.getReferenceVariants
+import org.jetbrains.uast.kotlin.internal.multiResolveResults
 import org.jetbrains.uast.visitor.UastVisitor
 
 class KotlinUFunctionCallExpression(
         override val psi: KtCallElement,
         givenParent: UElement?,
         private val _resolvedCall: ResolvedCall<*>?
-) : KotlinAbstractUExpression(givenParent), UCallExpressionEx, KotlinUElementWithType {
+) : KotlinAbstractUExpression(givenParent), UCallExpressionEx, KotlinUElementWithType, UMultiResolvable {
 
     constructor(psi: KtCallElement, uastParent: UElement?) : this(psi, uastParent, null)
 
@@ -80,12 +87,37 @@ class KotlinUFunctionCallExpression(
     override val valueArguments by lz { psi.valueArguments.map { KotlinConverter.convertOrEmpty(it.getArgumentExpression(), this) } }
 
     override fun getArgumentForParameter(i: Int): UExpression? {
-        val resolvedCall = resolvedCall ?: return null
-        val actualParamIndex = if (resolvedCall.extensionReceiver == null) i else i - 1
-        if (actualParamIndex == -1) return receiver
-        return getArgumentExpressionByIndex(actualParamIndex, resolvedCall, this)
+        val resolvedCall = resolvedCall
+        if (resolvedCall != null) {
+            val actualParamIndex = if (resolvedCall.extensionReceiver == null) i else i - 1
+            if (actualParamIndex == -1) return receiver
+            return getArgumentExpressionByIndex(actualParamIndex, resolvedCall, this)
+        }
+        val argument = valueArguments.getOrNull(i) ?: return null
+        val argumentType = argument.getExpressionType()
+        for (resolveResult in multiResolve()) {
+            val psiMethod = resolveResult.element as? PsiMethod ?: continue
+            val psiParameter = psiMethod.parameterList.parameters.getOrNull(i) ?: continue
+
+            if (argumentType == null || psiParameter.type.isAssignableFrom(argumentType))
+                return argument
+        }
+        return null
     }
 
+    override fun getExpressionType(): PsiType? {
+        super<KotlinUElementWithType>.getExpressionType()?.let { return it }
+        for (resolveResult in multiResolve()) {
+            val psiMethod = resolveResult.element
+            when {
+                psiMethod.isConstructor ->
+                    psiMethod.containingClass?.let { return PsiTypesUtil.getClassType(it) }
+                else ->
+                    psiMethod.returnType?.let { return it }
+            }
+        }
+        return null
+    }
 
     override val typeArgumentCount: Int
         get() = psi.typeArguments.size
@@ -131,6 +163,30 @@ class KotlinUFunctionCallExpression(
 
         }
 
+    private val multiResolved by lazy(fun(): Iterable<TypedResolveResult<PsiMethod>> {
+        val contextElement = psi
+
+        if (!Registry.`is`("kotlin.uast.multiresolve.enabled", true)) {
+            val calleeExpression = contextElement.calleeExpression ?: return emptyList()
+            return calleeExpression.multiResolveResults()
+                .mapNotNull { it.element.safeAs<PsiMethod>()?.let { TypedResolveResult(it) } }
+                .asIterable()
+        }
+
+        val calleeExpression = contextElement.calleeExpression as? KtReferenceExpression ?: return emptyList()
+        val methodName = methodName ?: calleeExpression.text ?: return emptyList()
+        val variants = getReferenceVariants(calleeExpression, methodName)
+        return variants.flatMap {
+            when (val source = it.toSource()) {
+                is KtClass -> source.toLightClass()?.constructors?.asSequence().orEmpty()
+                else -> resolveSource(psi, it, source)?.let { sequenceOf(it) }.orEmpty()
+            }
+        }.map { TypedResolveResult(it) }.asIterable()
+    })
+
+    override fun multiResolve(): Iterable<TypedResolveResult<PsiMethod>> = multiResolved
+
+
     override fun resolve(): PsiMethod? {
         val descriptor = resolvedCall?.resultingDescriptor ?: return null
         val source = descriptor.toSource()

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/expressions/KotlinUFunctionCallExpression.kt.182

@@ -16,13 +16,10 @@
 
 package org.jetbrains.uast.kotlin
 
-import com.intellij.openapi.util.registry.Registry
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiNamedElement
 import com.intellij.psi.PsiType
-import com.intellij.psi.util.PsiTypesUtil
-import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
@@ -33,20 +30,16 @@ import org.jetbrains.kotlin.resolve.CompileTimeConstantUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.uast.*
 import org.jetbrains.uast.internal.acceptList
 import org.jetbrains.uast.kotlin.declarations.KotlinUIdentifier
-import org.jetbrains.uast.kotlin.internal.TypedResolveResult
-import org.jetbrains.uast.kotlin.internal.getReferenceVariants
-import org.jetbrains.uast.kotlin.internal.multiResolveResults
 import org.jetbrains.uast.visitor.UastVisitor
 
 class KotlinUFunctionCallExpression(
         override val psi: KtCallElement,
         givenParent: UElement?,
         private val _resolvedCall: ResolvedCall<*>?
-) : KotlinAbstractUExpression(givenParent), UCallExpressionEx, KotlinUElementWithType, UMultiResolvable {
+) : KotlinAbstractUExpression(givenParent), UCallExpressionEx, KotlinUElementWithType {
 
     constructor(psi: KtCallElement, uastParent: UElement?) : this(psi, uastParent, null)
 
@@ -87,37 +80,12 @@ class KotlinUFunctionCallExpression(
     override val valueArguments by lz { psi.valueArguments.map { KotlinConverter.convertOrEmpty(it.getArgumentExpression(), this) } }
 
     override fun getArgumentForParameter(i: Int): UExpression? {
-        val resolvedCall = resolvedCall
-        if (resolvedCall != null) {
-            val actualParamIndex = if (resolvedCall.extensionReceiver == null) i else i - 1
-            if (actualParamIndex == -1) return receiver
-            return getArgumentExpressionByIndex(actualParamIndex, resolvedCall, this)
-        }
-        val argument = valueArguments.getOrNull(i) ?: return null
-        val argumentType = argument.getExpressionType()
-        for (resolveResult in multiResolve()) {
-            val psiMethod = resolveResult.element as? PsiMethod ?: continue
-            val psiParameter = psiMethod.parameterList.parameters.getOrNull(i) ?: continue
-
-            if (argumentType == null || psiParameter.type.isAssignableFrom(argumentType))
-                return argument
-        }
-        return null
+        val resolvedCall = resolvedCall ?: return null
+        val actualParamIndex = if (resolvedCall.extensionReceiver == null) i else i - 1
+        if (actualParamIndex == -1) return receiver
+        return getArgumentExpressionByIndex(actualParamIndex, resolvedCall, this)
     }
 
-    override fun getExpressionType(): PsiType? {
-        super<KotlinUElementWithType>.getExpressionType()?.let { return it }
-        for (resolveResult in multiResolve()) {
-            val psiMethod = resolveResult.element
-            when {
-                psiMethod.isConstructor ->
-                    psiMethod.containingClass?.let { return PsiTypesUtil.getClassType(it) }
-                else ->
-                    psiMethod.returnType?.let { return it }
-            }
-        }
-        return null
-    }
 
     override val typeArgumentCount: Int
         get() = psi.typeArguments.size
@@ -163,30 +131,6 @@ class KotlinUFunctionCallExpression(
 
         }
 
-    private val multiResolved by lazy(fun(): Iterable<TypedResolveResult<PsiMethod>> {
-        val contextElement = psi
-
-        if (!Registry.`is`("kotlin.uast.multiresolve.enabled", true)) {
-            val calleeExpression = contextElement.calleeExpression ?: return emptyList()
-            return calleeExpression.multiResolveResults()
-                .mapNotNull { it.element.safeAs<PsiMethod>()?.let { TypedResolveResult(it) } }
-                .asIterable()
-        }
-
-        val calleeExpression = contextElement.calleeExpression as? KtReferenceExpression ?: return emptyList()
-        val methodName = methodName ?: calleeExpression.text ?: return emptyList()
-        val variants = getReferenceVariants(calleeExpression, methodName)
-        return variants.flatMap {
-            when (val source = it.toSource()) {
-                is KtClass -> source.toLightClass()?.constructors?.asSequence().orEmpty()
-                else -> resolveSource(psi, it, source)?.let { sequenceOf(it) }.orEmpty()
-            }
-        }.map { TypedResolveResult(it) }.asIterable()
-    })
-
-    override fun multiResolve(): Iterable<TypedResolveResult<PsiMethod>> = multiResolved
-
-
     override fun resolve(): PsiMethod? {
         val descriptor = resolvedCall?.resultingDescriptor ?: return null
         val source = descriptor.toSource()

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/expressions/KotlinUSafeQualifiedExpression.kt

@@ -17,14 +17,17 @@
 package org.jetbrains.uast.kotlin
 
 import com.intellij.psi.PsiNamedElement
+import com.intellij.psi.ResolveResult
 import org.jetbrains.kotlin.psi.KtSafeQualifiedExpression
 import org.jetbrains.uast.UElement
+import org.jetbrains.uast.UMultiResolvable
 import org.jetbrains.uast.UQualifiedReferenceExpression
+import org.jetbrains.uast.kotlin.internal.getResolveResultVariants
 
 class KotlinUSafeQualifiedExpression(
         override val psi: KtSafeQualifiedExpression,
         givenParent: UElement?
-) : KotlinAbstractUExpression(givenParent), UQualifiedReferenceExpression,
+) : KotlinAbstractUExpression(givenParent), UQualifiedReferenceExpression, UMultiResolvable,
         KotlinUElementWithType, KotlinEvaluatableUElement {
     override val receiver by lz { KotlinConverter.convertOrEmpty(psi.receiverExpression, this) }
     override val selector by lz { KotlinConverter.convertOrEmpty(psi.selectorExpression, this) }
@@ -34,4 +37,5 @@ class KotlinUSafeQualifiedExpression(
         get() = (resolve() as? PsiNamedElement)?.name
     
     override fun resolve() = psi.selectorExpression?.resolveCallToDeclaration(this)
+    override fun multiResolve(): Iterable<ResolveResult> = getResolveResultVariants(psi.selectorExpression)
 }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/expressions/KotlinUSafeQualifiedExpression.kt.182

@@ -17,17 +17,14 @@
 package org.jetbrains.uast.kotlin
 
 import com.intellij.psi.PsiNamedElement
-import com.intellij.psi.ResolveResult
 import org.jetbrains.kotlin.psi.KtSafeQualifiedExpression
 import org.jetbrains.uast.UElement
-import org.jetbrains.uast.UMultiResolvable
 import org.jetbrains.uast.UQualifiedReferenceExpression
-import org.jetbrains.uast.kotlin.internal.getResolveResultVariants
 
 class KotlinUSafeQualifiedExpression(
         override val psi: KtSafeQualifiedExpression,
         givenParent: UElement?
-) : KotlinAbstractUExpression(givenParent), UQualifiedReferenceExpression, UMultiResolvable,
+) : KotlinAbstractUExpression(givenParent), UQualifiedReferenceExpression,
         KotlinUElementWithType, KotlinEvaluatableUElement {
     override val receiver by lz { KotlinConverter.convertOrEmpty(psi.receiverExpression, this) }
     override val selector by lz { KotlinConverter.convertOrEmpty(psi.selectorExpression, this) }
@@ -37,5 +34,4 @@ class KotlinUSafeQualifiedExpression(
         get() = (resolve() as? PsiNamedElement)?.name
     
     override fun resolve() = psi.selectorExpression?.resolveCallToDeclaration(this)
-    override fun multiResolve(): Iterable<ResolveResult> = getResolveResultVariants(psi.selectorExpression)
 }

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastResolveProviderService.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtElement
@@ -40,6 +41,9 @@ class CliKotlinUastResolveProviderService : KotlinUastResolveProviderService {
     override fun getLanguageVersionSettings(element: KtElement): LanguageVersionSettings {
         return element.project.analysisCompletedHandler?.getLanguageVersionSettings() ?: LanguageVersionSettingsImpl.DEFAULT
     }
+
+    override fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor> =
+        emptySequence() // Not supported
 }
 
 class UastAnalysisHandlerExtension : AnalysisHandlerExtension {

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastResolveProviderService.kt.182

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtElement
@@ -41,9 +40,6 @@ class CliKotlinUastResolveProviderService : KotlinUastResolveProviderService {
     override fun getLanguageVersionSettings(element: KtElement): LanguageVersionSettings {
         return element.project.analysisCompletedHandler?.getLanguageVersionSettings() ?: LanguageVersionSettingsImpl.DEFAULT
     }
-
-    override fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor> =
-        emptySequence() // Not supported
 }
 
 class UastAnalysisHandlerExtension : AnalysisHandlerExtension {

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/kotlinUastMultiresolve.kt

@@ -5,10 +5,55 @@
 
 package org.jetbrains.uast.kotlin.internal
 
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.util.registry.Registry
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiPolyVariantReference
+import com.intellij.psi.PsiSubstitutor
+import com.intellij.psi.ResolveResult
+import com.intellij.psi.infos.CandidateInfo
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.uast.UElement
+import org.jetbrains.uast.UMultiResolvable
 import org.jetbrains.uast.UResolvable
+import org.jetbrains.uast.kotlin.KotlinUastResolveProviderService
+import org.jetbrains.uast.kotlin.getMaybeLightElement
+import org.jetbrains.uast.kotlin.toSource
 
 
-//Dummy holder until idea 183
-interface DelegatedMultiResolve : UResolvable
+internal fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor> =
+    ServiceManager.getService(ktElement.project, KotlinUastResolveProviderService::class.java).getReferenceVariants(ktElement, nameHint)
+
+internal fun UElement.getResolveResultVariants(ktExpression: KtExpression?): Iterable<ResolveResult> {
+    ktExpression ?: return emptyList()
+
+    if (!Registry.`is`("kotlin.uast.multiresolve.enabled", true)) return ktExpression.multiResolveResults().asIterable()
+
+    val referenceVariants = getReferenceVariants(ktExpression, ktExpression.name ?: ktExpression.text)
+
+    fun asCandidateInfo(descriptor: DeclarationDescriptor): CandidateInfo? =
+        descriptor.toSource()?.getMaybeLightElement(this)?.let { CandidateInfo(it, PsiSubstitutor.EMPTY) }
+
+    return referenceVariants.mapNotNull(::asCandidateInfo).asIterable()
+}
 
 
+internal fun KtElement.multiResolveResults(): Sequence<ResolveResult> =
+    references.asSequence().flatMap { ref ->
+        when (ref) {
+            is PsiPolyVariantReference -> ref.multiResolve(false).asSequence()
+            else -> (ref.resolve()?.let { sequenceOf(CandidateInfo(it, PsiSubstitutor.EMPTY)) }).orEmpty()
+        }
+    }
+
+interface DelegatedMultiResolve : UMultiResolvable, UResolvable {
+    override fun multiResolve(): Iterable<ResolveResult> = listOfNotNull(resolve()?.let { CandidateInfo(it, PsiSubstitutor.EMPTY) })
+}
+
+class TypedResolveResult<T : PsiElement>(element: T) : CandidateInfo(element, PsiSubstitutor.EMPTY) {
+    @Suppress("UNCHECKED_CAST")
+    override fun getElement(): T = super.getElement() as T
+}
+

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/kotlinUastMultiresolve.kt.182

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. 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.uast.kotlin.internal
+
+import org.jetbrains.uast.UResolvable
+
+
+//Dummy holder until idea 183
+interface DelegatedMultiResolve : UResolvable
+
+

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/kotlinUastMultiresolve.kt.183

@@ -1,59 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. 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.uast.kotlin.internal
-
-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.util.registry.Registry
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiPolyVariantReference
-import com.intellij.psi.PsiSubstitutor
-import com.intellij.psi.ResolveResult
-import com.intellij.psi.infos.CandidateInfo
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.uast.UElement
-import org.jetbrains.uast.UMultiResolvable
-import org.jetbrains.uast.UResolvable
-import org.jetbrains.uast.kotlin.KotlinUastResolveProviderService
-import org.jetbrains.uast.kotlin.getMaybeLightElement
-import org.jetbrains.uast.kotlin.toSource
-
-
-internal fun getReferenceVariants(ktElement: KtElement, nameHint: String): Sequence<DeclarationDescriptor> =
-    ServiceManager.getService(ktElement.project, KotlinUastResolveProviderService::class.java).getReferenceVariants(ktElement, nameHint)
-
-internal fun UElement.getResolveResultVariants(ktExpression: KtExpression?): Iterable<ResolveResult> {
-    ktExpression ?: return emptyList()
-
-    if (!Registry.`is`("kotlin.uast.multiresolve.enabled", true)) return ktExpression.multiResolveResults().asIterable()
-
-    val referenceVariants = getReferenceVariants(ktExpression, ktExpression.name ?: ktExpression.text)
-
-    fun asCandidateInfo(descriptor: DeclarationDescriptor): CandidateInfo? =
-        descriptor.toSource()?.getMaybeLightElement(this)?.let { CandidateInfo(it, PsiSubstitutor.EMPTY) }
-
-    return referenceVariants.mapNotNull(::asCandidateInfo).asIterable()
-}
-
-
-internal fun KtElement.multiResolveResults(): Sequence<ResolveResult> =
-    references.asSequence().flatMap { ref ->
-        when (ref) {
-            is PsiPolyVariantReference -> ref.multiResolve(false).asSequence()
-            else -> (ref.resolve()?.let { sequenceOf(CandidateInfo(it, PsiSubstitutor.EMPTY)) }).orEmpty()
-        }
-    }
-
-interface DelegatedMultiResolve : UMultiResolvable, UResolvable {
-    override fun multiResolve(): Iterable<ResolveResult> = listOfNotNull(resolve()?.let { CandidateInfo(it, PsiSubstitutor.EMPTY) })
-}
-
-class TypedResolveResult<T : PsiElement>(element: T) : CandidateInfo(element, PsiSubstitutor.EMPTY) {
-    @Suppress("UNCHECKED_CAST")
-    override fun getElement(): T = super.getElement() as T
-}
-

plugins/uast-kotlin/tests/KotlinUastResolveApiTest.kt

@@ -5,19 +5,32 @@
 
 package org.jetbrains.uast.test.kotlin
 
+import com.intellij.openapi.util.registry.Registry
 import com.intellij.psi.PsiClassType
+import com.intellij.psi.PsiType
 import com.intellij.testFramework.LightProjectDescriptor
 import junit.framework.TestCase
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
+import org.jetbrains.uast.UElement
 import org.jetbrains.uast.UQualifiedReferenceExpression
+import org.jetbrains.uast.getContainingUMethod
+import org.jetbrains.uast.kotlin.KotlinUFunctionCallExpression
+import org.jetbrains.uast.test.env.findElementByText
+import org.jetbrains.uast.test.env.findElementByTextFromPsi
 import org.jetbrains.uast.test.env.findUElementByTextFromPsi
+import org.jetbrains.uast.toUElement
 
 class KotlinUastResolveApiTest : KotlinLightCodeInsightFixtureTestCase() {
 
     override fun getProjectDescriptor(): LightProjectDescriptor =
         KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
 
+    override fun setUp() {
+        super.setUp()
+        Registry.get("kotlin.uast.multiresolve.enabled").setValue(true, testRootDisposable)
+    }
+
     fun testResolveStringFromUast() {
         val file = myFixture.addFileToProject(
             "s.kt", """fun foo(){
@@ -31,4 +44,250 @@ class KotlinUastResolveApiTest : KotlinLightCodeInsightFixtureTestCase() {
         TestCase.assertNotNull((refs.receiver.getExpressionType() as PsiClassType).resolve())
     }
 
+    fun testMultiResolve() {
+        val file = myFixture.configureByText(
+            "s.kt", """
+                fun foo(): Int = TODO()
+                fun foo(a: Int): Int = TODO()
+                fun foo(a: Int, b: Int): Int = TODO()
+
+
+                fun main(args: Array<String>) {
+                    foo(1<caret>
+                }"""
+        )
+
+        val main = file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+        val functionCall =
+            main.findElementByText<UElement>("foo").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "fun foo(): Int = TODO()",
+            "fun foo(a: Int): Int = TODO()",
+            "fun foo(a: Int, b: Int): Int = TODO()"
+        )
+
+        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
+
+        val firstArgument = main.findElementByText<UElement>("1")
+        val firstParameter = functionCall.getArgumentForParameter(0)
+        TestCase.assertEquals(firstArgument, firstParameter)
+
+    }
+
+    fun testMultiResolveJava() {
+        val file = myFixture.configureByText(
+            "s.kt", """
+
+                fun main(args: Array<String>) {
+                    System.out.print(""
+                }
+                """
+        )
+
+        val main = file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+        val functionCall = main.findElementByText<UElement>("print").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "public void print(char c) { /* compiled code */ }",
+            "public void print(int i) { /* compiled code */ }",
+            "public void print(long l) { /* compiled code */ }",
+            "public void print(float f) { /* compiled code */ }",
+            "public void print(double d) { /* compiled code */ }",
+            "public void print(char[] s) { /* compiled code */ }",
+            "public void print(java.lang.String s) { /* compiled code */ }",
+            "public void print(java.lang.Object obj) { /* compiled code */ }"
+        )
+
+        TestCase.assertEquals(PsiType.VOID, functionCall.getExpressionType())
+
+        val firstArgument = main.findElementByText<UElement>("\"\"")
+        val firstParameter = functionCall.getArgumentForParameter(0)
+        TestCase.assertEquals(firstArgument, firstParameter)
+    }
+
+    fun testMultiResolveJavaAmbiguous() {
+        myFixture.addClass(
+            """
+            public class JavaClass {
+
+                public void setParameter(String name, int value){}
+                public void setParameter(String name, double value){}
+                public void setParameter(String name, String value){}
+
+            }
+        """
+        )
+        val file = myFixture.configureByText(
+            "s.kt", """
+
+                fun main(args: Array<String>) {
+                    JavaClass().setParameter(""
+                }
+                """
+        )
+
+        val main = file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+        val functionCall = main.findElementByText<UElement>("setParameter").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "public void setParameter(String name, int value){}",
+            "public void setParameter(String name, double value){}",
+            "public void setParameter(String name, String value){}"
+
+        )
+
+        TestCase.assertEquals(PsiType.VOID, functionCall.getExpressionType())
+
+        val firstArgument = main.findElementByText<UElement>("\"\"")
+        val firstParameter = functionCall.getArgumentForParameter(0)
+        TestCase.assertEquals(firstArgument, firstParameter)
+    }
+
+    fun testMultiResolveInClass() {
+        val file = myFixture.configureByText(
+            "s.kt", """
+                class MyClass {
+
+                    fun foo(): Int = TODO()
+                    fun foo(a: Int): Int = TODO()
+                    fun foo(a: Int, b: Int): Int = TODO()
+
+                }
+
+                fun foo(string: String) = TODO()
+
+
+                fun main(args: Array<String>) {
+                    MyClass().foo(
+                }
+            """
+        )
+
+
+        val functionCall =
+            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+                .findElementByText<UElement>("foo").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "fun foo(): Int = TODO()",
+            "fun foo(a: Int): Int = TODO()",
+            "fun foo(a: Int, b: Int): Int = TODO()"
+        )
+        assertDoesntContain(resolvedDeclarationsStrings, "fun foo(string: String) = TODO()")
+        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
+    }
+
+    fun testMultiConstructorResolve() {
+        val file = myFixture.configureByText(
+            "s.kt", """
+                class MyClass(int: Int) {
+
+                    constructor(int: Int, int1: Int) : this(int + int1)
+
+                    fun foo(): Int = TODO()
+
+                }
+
+                fun MyClass(string: String): MyClass = MyClass(1)
+
+
+                fun main(args: Array<String>) {
+                    MyClass(
+                }
+            """
+        )
+
+
+        val functionCall =
+            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+                .findElementByText<UElement>("MyClass").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "(int: Int)",
+            "constructor(int: Int, int1: Int) : this(int + int1)",
+            "fun MyClass(string: String): MyClass = MyClass(1)"
+        )
+        assertDoesntContain(resolvedDeclarationsStrings, "fun foo(): Int = TODO()")
+        TestCase.assertEquals(PsiType.getTypeByName("MyClass", project, file.resolveScope), functionCall.getExpressionType())
+    }
+
+
+    fun testMultiInvokableObjectResolve() {
+        val file = myFixture.configureByText(
+            "s.kt", """
+                object Foo {
+
+                    operator fun invoke(i: Int): Int = TODO()
+                    operator fun invoke(i1: Int, i2: Int): Int = TODO()
+                    operator fun invoke(i1: Int, i2: Int, i3: Int): Int = TODO()
+
+                }
+
+                fun main(args: Array<String>) {
+                    Foo(
+                }
+            """
+        )
+
+        val functionCall =
+            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+                .findElementByText<UElement>("Foo").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "operator fun invoke(i: Int): Int = TODO()",
+            "operator fun invoke(i1: Int, i2: Int): Int = TODO()",
+            "operator fun invoke(i1: Int, i2: Int, i3: Int): Int = TODO()"
+        )
+        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
+    }
+
+    fun testMultiResolveJvmOverloads() {
+        val file = myFixture.configureByText(
+            "s.kt", """
+
+                class MyClass {
+
+                    @JvmOverloads
+                    fun foo(i1: Int = 1, i2: Int = 2): Int = TODO()
+
+                }
+
+                fun main(args: Array<String>) {
+                    MyClass().foo(
+                }"""
+        )
+
+        val functionCall =
+            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
+                .findElementByText<UElement>("foo").uastParent as KotlinUFunctionCallExpression
+
+        val resolvedDeclaration = functionCall.multiResolve()
+        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
+        assertContainsElements(
+            resolvedDeclarationsStrings,
+            "@JvmOverloads\n                    fun foo(i1: Int = 1, i2: Int = 2): Int = TODO()"
+        )
+        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
+    }
+
 }
+

plugins/uast-kotlin/tests/KotlinUastResolveApiTest.kt.182

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. 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.uast.test.kotlin
+
+import com.intellij.psi.PsiClassType
+import com.intellij.testFramework.LightProjectDescriptor
+import junit.framework.TestCase
+import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
+import org.jetbrains.uast.UQualifiedReferenceExpression
+import org.jetbrains.uast.test.env.findUElementByTextFromPsi
+
+class KotlinUastResolveApiTest : KotlinLightCodeInsightFixtureTestCase() {
+
+    override fun getProjectDescriptor(): LightProjectDescriptor =
+        KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
+
+    fun testResolveStringFromUast() {
+        val file = myFixture.addFileToProject(
+            "s.kt", """fun foo(){
+                val s = "abc"
+                s.toUpperCase()
+                }
+            ""${'"'}"""
+        )
+
+        val refs = file.findUElementByTextFromPsi<UQualifiedReferenceExpression>("s.toUpperCase()")
+        TestCase.assertNotNull((refs.receiver.getExpressionType() as PsiClassType).resolve())
+    }
+
+}

plugins/uast-kotlin/tests/KotlinUastResolveApiTest.kt.183

@@ -1,293 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. 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.uast.test.kotlin
-
-import com.intellij.openapi.util.registry.Registry
-import com.intellij.psi.PsiClassType
-import com.intellij.psi.PsiType
-import com.intellij.testFramework.LightProjectDescriptor
-import junit.framework.TestCase
-import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.uast.UElement
-import org.jetbrains.uast.UQualifiedReferenceExpression
-import org.jetbrains.uast.getContainingUMethod
-import org.jetbrains.uast.kotlin.KotlinUFunctionCallExpression
-import org.jetbrains.uast.test.env.findElementByText
-import org.jetbrains.uast.test.env.findElementByTextFromPsi
-import org.jetbrains.uast.test.env.findUElementByTextFromPsi
-import org.jetbrains.uast.toUElement
-
-class KotlinUastResolveApiTest : KotlinLightCodeInsightFixtureTestCase() {
-
-    override fun getProjectDescriptor(): LightProjectDescriptor =
-        KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
-
-    override fun setUp() {
-        super.setUp()
-        Registry.get("kotlin.uast.multiresolve.enabled").setValue(true, testRootDisposable)
-    }
-
-    fun testResolveStringFromUast() {
-        val file = myFixture.addFileToProject(
-            "s.kt", """fun foo(){
-                val s = "abc"
-                s.toUpperCase()
-                }
-            ""${'"'}"""
-        )
-
-        val refs = file.findUElementByTextFromPsi<UQualifiedReferenceExpression>("s.toUpperCase()")
-        TestCase.assertNotNull((refs.receiver.getExpressionType() as PsiClassType).resolve())
-    }
-
-    fun testMultiResolve() {
-        val file = myFixture.configureByText(
-            "s.kt", """
-                fun foo(): Int = TODO()
-                fun foo(a: Int): Int = TODO()
-                fun foo(a: Int, b: Int): Int = TODO()
-
-
-                fun main(args: Array<String>) {
-                    foo(1<caret>
-                }"""
-        )
-
-        val main = file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-        val functionCall =
-            main.findElementByText<UElement>("foo").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "fun foo(): Int = TODO()",
-            "fun foo(a: Int): Int = TODO()",
-            "fun foo(a: Int, b: Int): Int = TODO()"
-        )
-
-        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
-
-        val firstArgument = main.findElementByText<UElement>("1")
-        val firstParameter = functionCall.getArgumentForParameter(0)
-        TestCase.assertEquals(firstArgument, firstParameter)
-
-    }
-
-    fun testMultiResolveJava() {
-        val file = myFixture.configureByText(
-            "s.kt", """
-
-                fun main(args: Array<String>) {
-                    System.out.print(""
-                }
-                """
-        )
-
-        val main = file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-        val functionCall = main.findElementByText<UElement>("print").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "public void print(char c) { /* compiled code */ }",
-            "public void print(int i) { /* compiled code */ }",
-            "public void print(long l) { /* compiled code */ }",
-            "public void print(float f) { /* compiled code */ }",
-            "public void print(double d) { /* compiled code */ }",
-            "public void print(char[] s) { /* compiled code */ }",
-            "public void print(java.lang.String s) { /* compiled code */ }",
-            "public void print(java.lang.Object obj) { /* compiled code */ }"
-        )
-
-        TestCase.assertEquals(PsiType.VOID, functionCall.getExpressionType())
-
-        val firstArgument = main.findElementByText<UElement>("\"\"")
-        val firstParameter = functionCall.getArgumentForParameter(0)
-        TestCase.assertEquals(firstArgument, firstParameter)
-    }
-
-    fun testMultiResolveJavaAmbiguous() {
-        myFixture.addClass(
-            """
-            public class JavaClass {
-
-                public void setParameter(String name, int value){}
-                public void setParameter(String name, double value){}
-                public void setParameter(String name, String value){}
-
-            }
-        """
-        )
-        val file = myFixture.configureByText(
-            "s.kt", """
-
-                fun main(args: Array<String>) {
-                    JavaClass().setParameter(""
-                }
-                """
-        )
-
-        val main = file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-        val functionCall = main.findElementByText<UElement>("setParameter").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "public void setParameter(String name, int value){}",
-            "public void setParameter(String name, double value){}",
-            "public void setParameter(String name, String value){}"
-
-        )
-
-        TestCase.assertEquals(PsiType.VOID, functionCall.getExpressionType())
-
-        val firstArgument = main.findElementByText<UElement>("\"\"")
-        val firstParameter = functionCall.getArgumentForParameter(0)
-        TestCase.assertEquals(firstArgument, firstParameter)
-    }
-
-    fun testMultiResolveInClass() {
-        val file = myFixture.configureByText(
-            "s.kt", """
-                class MyClass {
-
-                    fun foo(): Int = TODO()
-                    fun foo(a: Int): Int = TODO()
-                    fun foo(a: Int, b: Int): Int = TODO()
-
-                }
-
-                fun foo(string: String) = TODO()
-
-
-                fun main(args: Array<String>) {
-                    MyClass().foo(
-                }
-            """
-        )
-
-
-        val functionCall =
-            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-                .findElementByText<UElement>("foo").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "fun foo(): Int = TODO()",
-            "fun foo(a: Int): Int = TODO()",
-            "fun foo(a: Int, b: Int): Int = TODO()"
-        )
-        assertDoesntContain(resolvedDeclarationsStrings, "fun foo(string: String) = TODO()")
-        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
-    }
-
-    fun testMultiConstructorResolve() {
-        val file = myFixture.configureByText(
-            "s.kt", """
-                class MyClass(int: Int) {
-
-                    constructor(int: Int, int1: Int) : this(int + int1)
-
-                    fun foo(): Int = TODO()
-
-                }
-
-                fun MyClass(string: String): MyClass = MyClass(1)
-
-
-                fun main(args: Array<String>) {
-                    MyClass(
-                }
-            """
-        )
-
-
-        val functionCall =
-            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-                .findElementByText<UElement>("MyClass").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "(int: Int)",
-            "constructor(int: Int, int1: Int) : this(int + int1)",
-            "fun MyClass(string: String): MyClass = MyClass(1)"
-        )
-        assertDoesntContain(resolvedDeclarationsStrings, "fun foo(): Int = TODO()")
-        TestCase.assertEquals(PsiType.getTypeByName("MyClass", project, file.resolveScope), functionCall.getExpressionType())
-    }
-
-
-    fun testMultiInvokableObjectResolve() {
-        val file = myFixture.configureByText(
-            "s.kt", """
-                object Foo {
-
-                    operator fun invoke(i: Int): Int = TODO()
-                    operator fun invoke(i1: Int, i2: Int): Int = TODO()
-                    operator fun invoke(i1: Int, i2: Int, i3: Int): Int = TODO()
-
-                }
-
-                fun main(args: Array<String>) {
-                    Foo(
-                }
-            """
-        )
-
-        val functionCall =
-            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-                .findElementByText<UElement>("Foo").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "operator fun invoke(i: Int): Int = TODO()",
-            "operator fun invoke(i1: Int, i2: Int): Int = TODO()",
-            "operator fun invoke(i1: Int, i2: Int, i3: Int): Int = TODO()"
-        )
-        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
-    }
-
-    fun testMultiResolveJvmOverloads() {
-        val file = myFixture.configureByText(
-            "s.kt", """
-
-                class MyClass {
-
-                    @JvmOverloads
-                    fun foo(i1: Int = 1, i2: Int = 2): Int = TODO()
-
-                }
-
-                fun main(args: Array<String>) {
-                    MyClass().foo(
-                }"""
-        )
-
-        val functionCall =
-            file.toUElement()!!.findElementByTextFromPsi<UElement>("main").getContainingUMethod()!!
-                .findElementByText<UElement>("foo").uastParent as KotlinUFunctionCallExpression
-
-        val resolvedDeclaration = functionCall.multiResolve()
-        val resolvedDeclarationsStrings = resolvedDeclaration.map { it.element.text ?: "<null>" }
-        assertContainsElements(
-            resolvedDeclarationsStrings,
-            "@JvmOverloads\n                    fun foo(i1: Int = 1, i2: Int = 2): Int = TODO()"
-        )
-        TestCase.assertEquals(PsiType.INT, functionCall.getExpressionType())
-    }
-
-}
-

prepare/compiler/build.gradle.kts

@@ -78,23 +78,11 @@ dependencies {
     fatJarContents(commonDep("io.javaslang", "javaslang"))
     fatJarContents(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
 
-    fatJarContents(intellijCoreDep()) { includeJars("intellij-core") }
+    fatJarContents(intellijCoreDep()) { includeJars("intellij-core", "java-compatibility-1.0.1") }
     fatJarContents(intellijDep()) { includeIntellijCoreJarDependencies(project, { !(it.startsWith("jdom") || it.startsWith("log4j")) }) }
-    when {
-        Platform[173].orLower() -> {
-            fatJarContents(intellijDep()) { includeJars("jna-platform") }
-            fatJarContentsStripMetadata(intellijDep()) { includeJars("oromatcher", "jdom", "log4j") }
-        }
-        Platform[181].orLower() -> {
-            fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-java-1.3") }
-            fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j") }
-        }
-        else -> {
-            fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-1.3.0") }
-            fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j") }
-        }
-    }
+    fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-1.3.0") }
     fatJarContentsStripServices(intellijDep("jps-standalone")) { includeJars("jps-model") }
+    fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j" ) }
 }
 
 noDefaultJar()

prepare/compiler/build.gradle.kts.182

@@ -78,11 +78,23 @@ dependencies {
     fatJarContents(commonDep("io.javaslang", "javaslang"))
     fatJarContents(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
 
-    fatJarContents(intellijCoreDep()) { includeJars("intellij-core", "java-compatibility-1.0.1") }
+    fatJarContents(intellijCoreDep()) { includeJars("intellij-core") }
     fatJarContents(intellijDep()) { includeIntellijCoreJarDependencies(project, { !(it.startsWith("jdom") || it.startsWith("log4j")) }) }
-    fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-1.3.0") }
+    when {
+        Platform[173].orLower() -> {
+            fatJarContents(intellijDep()) { includeJars("jna-platform") }
+            fatJarContentsStripMetadata(intellijDep()) { includeJars("oromatcher", "jdom", "log4j") }
+        }
+        Platform[181].orLower() -> {
+            fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-java-1.3") }
+            fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j") }
+        }
+        else -> {
+            fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-1.3.0") }
+            fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j") }
+        }
+    }
     fatJarContentsStripServices(intellijDep("jps-standalone")) { includeJars("jps-model") }
-    fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j" ) }
 }
 
 noDefaultJar()

versions.properties

@@ -1,14 +1,15 @@
-versions.intellijSdk=182.5107.16
+versions.intellijSdk=183.4588.61
 versions.androidBuildTools=r23.0.1
 versions.idea.NodeJS=181.3494.12
-versions.jar.guava=23.6-jre
+versions.jar.guava=25.1-jre
 versions.jar.groovy-all=2.4.15
 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.5
-versions.jar.gson=2.8.4
+versions.jar.streamex=0.6.7
+versions.jar.gson=2.8.5
 versions.jar.oro=2.0.8
 versions.jar.picocontainer=1.2
+versions.jar.asm-all=7.0
 ignore.jar.snappy-in-java=true
 versions.gradle-api=4.5.1

versions.properties.182

@@ -1,15 +1,14 @@
-versions.intellijSdk=183.4588.61
+versions.intellijSdk=182.5107.16
 versions.androidBuildTools=r23.0.1
 versions.idea.NodeJS=181.3494.12
-versions.jar.guava=25.1-jre
+versions.jar.guava=23.6-jre
 versions.jar.groovy-all=2.4.15
 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.7
-versions.jar.gson=2.8.5
+versions.jar.streamex=0.6.5
+versions.jar.gson=2.8.4
 versions.jar.oro=2.0.8
 versions.jar.picocontainer=1.2
-versions.jar.asm-all=7.0
 ignore.jar.snappy-in-java=true
 versions.gradle-api=4.5.1