Merge remote-tracking branch 'origin/master'

.bunch

@@ -4,6 +4,6 @@
 as31_173_181
 as32_181
 as33
-as34_as33
+as34_183
 183
 191_183

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -27,7 +27,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P173, P181, P182, P183;
+    P173, P181, P182, P183, P191;
 
     val version: Int = name.drop(1).toInt()
 
@@ -46,10 +46,12 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     IJ181(Platform.P181),
     IJ182(Platform.P182),
     IJ183(Platform.P183),
+    IJ191(Platform.P191),
 
     AS31(Platform.P173),
     AS32(Platform.P181),
-    AS33(Platform.P182);
+    AS33(Platform.P182),
+    AS34(Platform.P183);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

generators/build.gradle.kts.as34

@@ -0,0 +1,53 @@
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+sourceSets {
+    "main" { }
+    "test" { projectDefault() }
+}
+
+val builtinsSourceSet = sourceSets.create("builtins") {
+    java.srcDir("builtins")
+}
+val builtinsCompile by configurations
+
+dependencies {
+    compile(projectTests(":compiler:cli"))
+    compile(projectTests(":idea:idea-maven"))
+    compile(projectTests(":j2k"))
+    compile(projectTests(":idea:idea-android"))
+    compile(projectTests(":jps-plugin"))
+    compile(projectTests(":plugins:android-extensions-compiler"))
+    compile(projectTests(":plugins:android-extensions-ide"))
+    compile(projectTests(":plugins:android-extensions-jps"))
+    compile(projectTests(":kotlin-annotation-processing"))
+    compile(projectTests(":kotlin-allopen-compiler-plugin"))
+    compile(projectTests(":kotlin-noarg-compiler-plugin"))
+    compile(projectTests(":kotlin-sam-with-receiver-compiler-plugin"))
+    compile(projectTests(":generators:test-generator"))
+    // testCompileOnly(intellijDep("jps-build-test"))
+    builtinsCompile("org.jetbrains.kotlin:kotlin-stdlib:$bootstrapKotlinVersion")
+    testCompileOnly(project(":kotlin-reflect-api"))
+    testCompile(builtinsSourceSet.output)
+    testRuntime(intellijDep()) { includeJars("idea_rt") }
+    testRuntime(project(":kotlin-reflect"))
+}
+
+
+projectTest {
+    workingDir = rootDir
+}
+
+val generateTests by generator("org.jetbrains.kotlin.generators.tests.GenerateTestsKt")
+
+val generateProtoBuf by generator("org.jetbrains.kotlin.generators.protobuf.GenerateProtoBufKt")
+val generateProtoBufCompare by generator("org.jetbrains.kotlin.generators.protobuf.GenerateProtoBufCompare")
+
+val generateGradleOptions by generator("org.jetbrains.kotlin.generators.arguments.GenerateGradleOptionsKt")
+
+val generateBuiltins by generator("org.jetbrains.kotlin.generators.builtins.generateBuiltIns.GenerateBuiltInsKt", builtinsSourceSet)
+
+testsJar()

gradle.properties.as34

@@ -0,0 +1,16 @@
+org.gradle.daemon=true
+org.gradle.parallel=false
+org.gradle.configureondemand=false
+org.gradle.jvmargs=-Duser.country=US -Dkotlin.daemon.jvm.options=-Xmx1600m
+
+cacheRedirectorEnabled=true
+
+kotlin.compiler.effectSystemEnabled=true
+kotlin.compiler.newInferenceEnabled=true
+#maven.repository.mirror=http://repository.jetbrains.com/remote-repos/
+#bootstrap.kotlin.repo=https://dl.bintray.com/kotlin/kotlin-dev
+#bootstrap.kotlin.version=1.1.50-dev-1451
+#signingRequired=true
+
+intellijUltimateEnabled=false
+intellijEnforceCommunitySdk=true

idea/build.gradle.kts.as34

@@ -0,0 +1,196 @@
+import org.gradle.jvm.tasks.Jar
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+repositories.withRedirector(project) {
+    maven("https://jetbrains.bintray.com/markdown")
+}
+
+dependencies {
+    testRuntime(intellijDep())
+
+    compile(project(":kotlin-stdlib-jre8"))
+    compileOnly(project(":kotlin-reflect-api"))
+    compile(project(":core:descriptors"))
+    compile(project(":core:descriptors.jvm"))
+    compile(project(":compiler:backend"))
+    compile(project(":compiler:cli-common"))
+    compile(project(":compiler:frontend"))
+    compile(project(":compiler:frontend.java"))
+    compile(project(":compiler:frontend.script"))
+    compile(project(":js:js.frontend"))
+    compile(project(":js:js.serializer"))
+    compile(project(":compiler:light-classes"))
+    compile(project(":compiler:util"))
+    compile(project(":kotlin-build-common"))
+    compile(project(":compiler:daemon-common"))
+    compile(projectRuntimeJar(":kotlin-daemon-client"))
+    compile(project(":kotlin-compiler-runner")) { isTransitive = false }
+    compile(project(":compiler:plugin-api"))
+    compile(project(":eval4j"))
+    compile(project(":j2k"))
+    compile(project(":idea:formatter"))
+    compile(project(":idea:idea-core"))
+    compile(project(":idea:ide-common"))
+    compile(project(":idea:idea-jps-common"))
+    compile(project(":idea:kotlin-gradle-tooling"))
+    compile(project(":plugins:uast-kotlin"))
+    compile(project(":plugins:uast-kotlin-idea"))
+    compile(project(":kotlin-script-util")) { isTransitive = false }
+    compile(project(":kotlin-scripting-intellij"))
+
+    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
+
+    compileOnly(project(":kotlin-daemon-client"))
+
+    compileOnly(intellijDep())
+    compileOnly(commonDep("org.jetbrains", "markdown"))
+    compileOnly(commonDep("com.google.code.findbugs", "jsr305"))
+    compileOnly(intellijPluginDep("IntelliLang"))
+    compileOnly(intellijPluginDep("copyright"))
+    compileOnly(intellijPluginDep("properties"))
+    compileOnly(intellijPluginDep("java-i18n"))
+
+    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testCompile(projectTests(":compiler:tests-common"))
+    testCompile(projectTests(":idea:idea-test-framework")) { isTransitive = false }
+    testCompile(project(":idea:idea-jvm")) { isTransitive = false }
+    testCompile(project(":idea:idea-gradle")) { isTransitive = false }
+    testCompile(project(":idea:idea-maven")) { isTransitive = false }
+    testCompile(project(":idea:idea-native")) { isTransitive = false }
+    testCompile(project(":idea:idea-gradle-native")) { isTransitive = false }
+    testCompile(commonDep("junit:junit"))
+
+    testRuntime(project(":kotlin-native:kotlin-native-library-reader")) { isTransitive = false }
+    testRuntime(project(":kotlin-native:kotlin-native-utils")) { isTransitive = false }
+
+    testRuntime(commonDep("org.jetbrains", "markdown"))
+    testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false }
+    testRuntime(project(":kotlin-reflect"))
+    testRuntime(project(":kotlin-preloader"))
+
+    testCompile(project(":kotlin-sam-with-receiver-compiler-plugin")) { isTransitive = false }
+
+    testRuntime(project(":plugins:android-extensions-compiler"))
+    testRuntime(project(":plugins:android-extensions-ide")) { isTransitive = false }
+    testRuntime(project(":allopen-ide-plugin")) { isTransitive = false }
+    testRuntime(project(":kotlin-allopen-compiler-plugin"))
+    testRuntime(project(":noarg-ide-plugin")) { isTransitive = false }
+    testRuntime(project(":kotlin-noarg-compiler-plugin"))
+    testRuntime(project(":plugins:annotation-based-compiler-plugins-ide-support")) { isTransitive = false }
+    testRuntime(project(":kotlin-scripting-idea")) { isTransitive = false }
+    testRuntime(project(":kotlin-scripting-compiler"))
+    testRuntime(project(":sam-with-receiver-ide-plugin")) { isTransitive = false }
+    testRuntime(project(":kotlinx-serialization-compiler-plugin"))
+    testRuntime(project(":kotlinx-serialization-ide-plugin")) { isTransitive = false }
+    testRuntime(project(":idea:idea-android")) { isTransitive = false }
+    testRuntime(project(":plugins:lint")) { isTransitive = false }
+    testRuntime(project(":plugins:uast-kotlin"))
+
+    (rootProject.extra["compilerModules"] as Array<String>).forEach {
+        testRuntime(project(it))
+    }
+
+    testCompile(intellijPluginDep("IntelliLang"))
+    testCompile(intellijPluginDep("copyright"))
+    testCompile(intellijPluginDep("properties"))
+    testCompile(intellijPluginDep("java-i18n"))
+    testCompile(intellijPluginDep("stream-debugger"))
+    testCompileOnly(intellijDep())
+    testCompileOnly(commonDep("com.google.code.findbugs", "jsr305"))
+    testCompileOnly(intellijPluginDep("gradle"))
+    testCompileOnly(intellijPluginDep("Groovy"))
+    //testCompileOnly(intellijPluginDep("maven"))
+
+    testRuntime(intellijPluginDep("junit"))
+    testRuntime(intellijPluginDep("gradle"))
+    testRuntime(intellijPluginDep("Groovy"))
+    testRuntime(intellijPluginDep("coverage"))
+    //testRuntime(intellijPluginDep("maven"))
+    testRuntime(intellijPluginDep("android"))
+    testRuntime(intellijPluginDep("smali"))
+    testRuntime(intellijPluginDep("testng"))
+}
+
+sourceSets {
+    "main" {
+        projectDefault()
+        java.srcDirs(
+            "idea-completion/src",
+            "idea-live-templates/src",
+            "idea-repl/src"
+        )
+        resources.srcDirs("idea-repl/src").apply { include("META-INF/**") }
+    }
+    "test" {
+        projectDefault()
+        java.srcDirs(
+            "idea-completion/tests",
+            "idea-live-templates/tests"
+        )
+    }
+
+}
+
+val performanceTestCompile by configurations.creating {
+    extendsFrom(configurations["testCompile"])
+}
+
+val performanceTestRuntime by configurations.creating {
+    extendsFrom(configurations["testRuntime"])
+}
+
+val performanceTest by run {
+    sourceSets.creating {
+        compileClasspath += sourceSets["test"].output
+        compileClasspath += sourceSets["main"].output
+        runtimeClasspath += sourceSets["test"].output
+        runtimeClasspath += sourceSets["main"].output
+        java.srcDirs("performanceTests")
+    }
+}
+
+projectTest {
+    dependsOn(":dist")
+    workingDir = rootDir
+}
+
+
+projectTest(taskName = "performanceTest") {
+    dependsOn(":dist")
+    dependsOn(performanceTest.output)
+    testClassesDirs = performanceTest.output.classesDirs
+    classpath = performanceTest.runtimeClasspath
+    workingDir = rootDir
+
+    jvmArgs?.removeAll { it.startsWith("-Xmx") }
+
+    maxHeapSize = "3g"
+    jvmArgs("-XX:SoftRefLRUPolicyMSPerMB=50")
+    jvmArgs(
+        "-XX:ReservedCodeCacheSize=240m",
+        "-XX:+UseCompressedOops",
+        "-XX:+UseConcMarkSweepGC"
+    )
+    jvmArgs("-XX:+UnlockCommercialFeatures", "-XX:+FlightRecorder")
+
+    if (hasProperty("perf.flight.recorder.override")) {
+        jvmArgs(property("perf.flight.recorder.override"))
+    } else {
+        val settings = if (hasProperty("perf.flight.recorder.settings")) ",settings=${property("perf.flight.recorder.settings")}" else ""
+        jvmArgs("-XX:StartFlightRecording=delay=15m,duration=5h,filename=perf.jfr$settings")
+    }
+
+    doFirst {
+        systemProperty("idea.home.path", intellijRootDir().canonicalPath)
+    }
+}
+
+testsJar {}
+
+classesDirsArtifact()
+configureInstrumentation()
+

idea/idea-android/idea-android-output-parser/build.gradle.kts.as34

@@ -0,0 +1,25 @@
+
+plugins {
+    kotlin("jvm")
+}
+
+apply { plugin("jps-compatible") }
+
+dependencies {
+    compile(project(":compiler:util"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep())
+    compileOnly(intellijPluginDep("gradle"))
+    compileOnly(intellijPluginDep("android"))
+}
+
+sourceSets {
+    "main" {}
+    "test" {}
+}
+
+runtimeJar {
+    archiveName = "android-output-parser-ide.jar"
+}
+
+ideaPlugin()

idea/idea-gradle/build.gradle.kts.as34

@@ -0,0 +1,75 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    testRuntime(intellijDep())
+
+    compileOnly(project(":idea"))
+    compileOnly(project(":idea:idea-jvm"))
+    compile(project(":idea:kotlin-gradle-tooling"))
+
+    compile(project(":compiler:frontend"))
+    compile(project(":compiler:frontend.java"))
+    compile(project(":compiler:frontend.script"))
+
+    compile(project(":js:js.frontend"))
+
+    compileOnly(intellijDep())
+    compileOnly(intellijPluginDep("gradle"))
+    compileOnly(intellijPluginDep("Groovy"))
+    compileOnly(intellijPluginDep("junit"))
+    compileOnly(intellijPluginDep("testng"))
+
+    testCompile(projectTests(":idea"))
+    testCompile(projectTests(":idea:idea-test-framework"))
+
+    testCompile(intellijPluginDep("gradle"))
+    testCompileOnly(intellijPluginDep("Groovy"))
+    testCompileOnly(intellijDep())
+
+    testCompile(project(":idea:idea-native")) { isTransitive = false }
+    testCompile(project(":idea:idea-gradle-native")) { isTransitive = false }
+    testRuntime(project(":kotlin-native:kotlin-native-library-reader")) { isTransitive = false }
+    testRuntime(project(":kotlin-native:kotlin-native-utils")) { isTransitive = false }
+
+    testRuntime(project(":kotlin-reflect"))
+    testRuntime(project(":idea:idea-jvm"))
+    testRuntime(project(":idea:idea-android"))
+    testRuntime(project(":plugins:kapt3-idea"))
+    testRuntime(project(":plugins:android-extensions-ide"))
+    testRuntime(project(":plugins:lint"))
+    testRuntime(project(":sam-with-receiver-ide-plugin"))
+    testRuntime(project(":allopen-ide-plugin"))
+    testRuntime(project(":noarg-ide-plugin"))
+    testRuntime(project(":kotlin-scripting-idea"))
+    testRuntime(project(":kotlinx-serialization-ide-plugin"))
+    // TODO: the order of the plugins matters here, consider avoiding order-dependency
+    testRuntime(intellijPluginDep("junit"))
+    testRuntime(intellijPluginDep("testng"))
+    testRuntime(intellijPluginDep("properties"))
+    testRuntime(intellijPluginDep("gradle"))
+    testRuntime(intellijPluginDep("Groovy"))
+    testRuntime(intellijPluginDep("coverage"))
+    //testRuntime(intellijPluginDep("maven"))
+    testRuntime(intellijPluginDep("android"))
+    testRuntime(intellijPluginDep("smali"))
+}
+
+sourceSets {
+    "main" {
+        projectDefault()
+        resources.srcDir("res")
+    }
+    "test" { projectDefault() }
+}
+
+testsJar()
+
+projectTest {
+    workingDir = rootDir
+    useAndroidSdk()
+}
+
+configureInstrumentation()

idea/idea-gradle/tests/org/jetbrains/kotlin/gradle/GradleMultiplatformWizardTest.kt.as34

@@ -0,0 +1,9 @@
+/*
+ * 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.kotlin.gradle
+
+class GradleMultiplatformWizardTest : AbstractGradleMultiplatformWizardTest() {
+}

idea/idea-jvm/src/org/jetbrains/kotlin/idea/debugger/DebuggerUtils.kt

@@ -21,6 +21,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.io.FileUtilRt
 import com.intellij.psi.search.GlobalSearchScope
 import com.sun.jdi.Location
+import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.KotlinFileTypeFactory
@@ -42,6 +43,9 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
 object DebuggerUtils {
+    @TestOnly
+    var forceRanking = false
+
     fun findSourceFileForClassIncludeLibrarySources(
         project: Project,
         scope: GlobalSearchScope,
@@ -74,7 +78,7 @@ object DebuggerUtils {
 
         if (filesWithExactName.isEmpty()) return null
 
-        if (filesWithExactName.size == 1) {
+        if (filesWithExactName.size == 1 && !forceRanking) {
             return filesWithExactName.single()
         }
 

idea/idea-jvm/src/org/jetbrains/kotlin/idea/debugger/FileRankingCalculator.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.idea.debugger
 
 import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.psi.PsiElement
 import com.sun.jdi.*
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.state.IncompatibleClassTracker
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
@@ -28,10 +28,9 @@ import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypes2
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypes3
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.varargParameterPosition
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.typeUtil.builtIns
 import org.jetbrains.kotlin.utils.keysToMap
 import kotlin.jvm.internal.FunctionBase
 import org.jetbrains.org.objectweb.asm.Type as AsmType
@@ -40,30 +39,20 @@ object FileRankingCalculatorForIde : FileRankingCalculator() {
     override fun analyze(element: KtElement) = element.analyze(BodyResolveMode.PARTIAL)
 }
 
-abstract class FileRankingCalculator(
+abstract class FileRankingCalculator(private val checkClassFqName: Boolean = true) {
-    private val checkClassFqName: Boolean = true,
-    private val strictMode: Boolean = false
-) {
     abstract fun analyze(element: KtElement): BindingContext
 
     fun findMostAppropriateSource(files: Collection<KtFile>, location: Location): KtFile {
-        assert(files.isNotEmpty())
+        val fileWithRankings: Map<KtFile, Int> = rankFiles(files, location)
-
-        val fileWithRankings = files.keysToMap { fileRankingSafe(it, location) }
         val fileWithMaxScore = fileWithRankings.maxBy { it.value }!!
-
-        if (strictMode) {
-            require(fileWithMaxScore.value.value >= 0) { "Max score is negative" }
-
-            // Allow only one element with max ranking
-            require(fileWithRankings.count { it.value == fileWithMaxScore.value } == 1) {
-                "Score is the same for several files"
-            }
-        }
-
         return fileWithMaxScore.key
     }
 
+    fun rankFiles(files: Collection<KtFile>, location: Location): Map<KtFile, Int> {
+        assert(files.isNotEmpty())
+        return files.keysToMap { fileRankingSafe(it, location).value }
+    }
+
     private class Ranking(val value: Int) : Comparable<Ranking> {
         companion object {
             val LOW = Ranking(-1000)
@@ -119,6 +108,8 @@ abstract class FileRankingCalculator(
     }
 
     private fun rankingForClassName(fqName: String, descriptor: ClassDescriptor, bindingContext: BindingContext): Ranking {
+        if (DescriptorUtils.isLocal(descriptor)) return Ranking.ZERO
+
         val expectedFqName = makeTypeMapper(bindingContext).mapType(descriptor).className
         return when {
             checkClassFqName -> if (expectedFqName == fqName) MAJOR else LOW
@@ -207,6 +198,11 @@ abstract class FileRankingCalculator(
             ZERO
         } catch (e: InternalException) {
             ZERO
+        } catch (e: ProcessCanceledException) {
+            throw e
+        } catch (e: RuntimeException) {
+            LOG.error("Exception during Kotlin sources ranking", e)
+            ZERO
         }
     }
 

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

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("IncompatibleAPI")
+
+package org.jetbrains.kotlin.idea.run
+
+import com.intellij.execution.configurations.LocatableConfigurationBase
+import com.intellij.execution.configurations.ModuleBasedConfiguration
+import com.intellij.execution.configurations.RunConfigurationBase
+import org.jdom.Element
+
+// Generalized in 183
+// BUNCH: 183
+typealias RunConfigurationBaseAny = RunConfigurationBase
+
+// Generalized in 183
+// BUNCH: 183
+typealias ModuleBasedConfigurationAny = ModuleBasedConfiguration<*>
+
+// Generalized in 183
+// BUNCH: 183
+typealias LocatableConfigurationBaseAny = LocatableConfigurationBase
+
+// Generalized in 183
+// BUNCH: 183
+typealias ModuleBasedConfigurationElement<T> = ModuleBasedConfiguration<T>

idea/idea-maven/build.gradle.kts.as34

@@ -0,0 +1,74 @@
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    compile(project(":core:util.runtime"))
+    compile(project(":compiler:frontend"))
+    compile(project(":compiler:frontend.java"))
+    compile(project(":compiler:util"))
+    compile(project(":compiler:cli-common"))
+    compile(project(":kotlin-build-common"))
+
+    compile(project(":js:js.frontend"))
+
+    compile(project(":idea"))
+    compile(project(":idea:idea-jvm"))
+    compile(project(":idea:idea-jps-common"))
+
+    compileOnly(intellijDep())
+    excludeInAndroidStudio(rootProject) { compileOnly(intellijPluginDep("maven")) }
+
+    testCompile(projectTests(":idea"))
+    testCompile(projectTests(":compiler:tests-common"))
+    testCompile(projectTests(":idea:idea-test-framework"))
+
+    testCompileOnly(intellijDep())
+    //testCompileOnly(intellijPluginDep("maven"))
+
+    testCompile(project(":idea:idea-native")) { isTransitive = false }
+    testRuntime(project(":kotlin-native:kotlin-native-library-reader")) { isTransitive = false }
+    testRuntime(project(":kotlin-native:kotlin-native-utils")) { isTransitive = false }
+
+    testRuntime(project(":kotlin-reflect"))
+    testRuntime(project(":idea:idea-jvm"))
+    testRuntime(project(":idea:idea-android"))
+    testRuntime(project(":plugins:android-extensions-ide"))
+    testRuntime(project(":plugins:lint"))
+    testRuntime(project(":sam-with-receiver-ide-plugin"))
+    testRuntime(project(":allopen-ide-plugin"))
+    testRuntime(project(":noarg-ide-plugin"))
+    testRuntime(project(":kotlin-scripting-idea"))
+    testRuntime(project(":kotlinx-serialization-ide-plugin"))
+
+    testRuntime(intellijDep())
+    // TODO: the order of the plugins matters here, consider avoiding order-dependency
+    testRuntime(intellijPluginDep("junit"))
+    testRuntime(intellijPluginDep("testng"))
+    testRuntime(intellijPluginDep("properties"))
+    testRuntime(intellijPluginDep("gradle"))
+    testRuntime(intellijPluginDep("Groovy"))
+    testRuntime(intellijPluginDep("coverage"))
+    //testRuntime(intellijPluginDep("maven"))
+    testRuntime(intellijPluginDep("android"))
+    testRuntime(intellijPluginDep("smali"))
+}
+
+sourceSets {
+    "main" { /*projectDefault()*/ }
+    "test" { /*projectDefault()*/ }
+}
+
+testsJar()
+
+projectTest {
+    workingDir = rootDir
+}
+
+runtimeJar {
+    archiveName = "maven-ide.jar"
+}
+
+ideaPlugin()

idea/src/META-INF/android-lint.xml.as34

@@ -0,0 +1,5 @@
+<idea-plugin>
+    <extensions defaultExtensionNs="com.intellij">
+        <externalAnnotator language="kotlin" implementationClass="org.jetbrains.android.inspections.lint.AndroidLintExternalAnnotator"/>
+    </extensions>
+</idea-plugin>

idea/src/META-INF/extensions/ide.xml.as34

@@ -0,0 +1,77 @@
+<idea-plugin>
+    <extensionPoints>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.updater" beanClass="com.intellij.openapi.fileTypes.FileTypeExtensionPoint"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.projectConfigurator" interface="org.jetbrains.kotlin.idea.configuration.KotlinProjectConfigurator"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.declarationAttributeAltererExtension"
+                        interface="org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension"
+                        area="IDEA_PROJECT"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.idePlatformKindResolution"
+                        interface="org.jetbrains.kotlin.caches.resolve.IdePlatformKindResolution"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.highlighterExtension"
+                        interface="org.jetbrains.kotlin.idea.highlighter.HighlighterExtension"/>
+
+        <extensionPoint name="scratchFileLanguageProvider" beanClass="com.intellij.lang.LanguageExtensionPoint">
+            <with attribute="implementationClass" implements="org.jetbrains.kotlin.idea.scratch.ScratchFileLanguageProvider"/>
+        </extensionPoint>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.binaryExtension"
+                        interface="org.jetbrains.kotlin.idea.util.KotlinBinaryExtension"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.facetValidatorCreator"
+                        interface="org.jetbrains.kotlin.idea.facet.KotlinFacetValidatorCreator"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.clearBuildState"
+                        interface="org.jetbrains.kotlin.idea.compiler.configuration.ClearBuildStateExtension"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.newFileHook"
+                        interface="org.jetbrains.kotlin.idea.actions.NewKotlinFileHook"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.completionExtension"
+                        interface="org.jetbrains.kotlin.idea.completion.KotlinCompletionExtension"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.buildSystemTypeDetector"
+                        interface="org.jetbrains.kotlin.idea.configuration.BuildSystemTypeDetector"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.idePlatformKind"
+                        interface="org.jetbrains.kotlin.platform.IdePlatformKind"/>
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.idePlatformKindTooling"
+                        interface="org.jetbrains.kotlin.idea.platform.IdePlatformKindTooling"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.scriptRelatedModulesProvider"
+                        interface="org.jetbrains.kotlin.idea.core.script.dependencies.ScriptRelatedModulesProvider"
+                        area="IDEA_PROJECT"/>
+
+        <extensionPoint qualifiedName="org.jetbrains.kotlin.scriptDefinitionsProvider"
+                        interface="kotlin.script.experimental.intellij.ScriptDefinitionsProvider"
+                        area="IDEA_PROJECT"/>
+    </extensionPoints>
+
+    <extensions defaultExtensionNs="org.jetbrains.kotlin">
+        <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinJavaModuleConfigurator"/>
+        <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinJsModuleConfigurator"/>
+
+        <scriptDefinitionContributor
+            id="ScriptTemplatesFromCompilerSettingsProvider"
+            implementation="org.jetbrains.kotlin.idea.script.ScriptTemplatesFromCompilerSettingsProvider"/>
+
+        <scriptDefinitionContributor
+            id="BridgeScriptDefinitionsContributor"
+            implementation="org.jetbrains.kotlin.idea.script.BridgeScriptDefinitionsContributor"/>
+
+        <scriptDefinitionContributor
+            id="ScriptTemplatesFromDependenciesProvider"
+            implementation="org.jetbrains.kotlin.idea.script.ScriptTemplatesFromDependenciesProvider"/>
+
+        <scriptDefinitionContributor id="StandardScriptDefinitionContributor"
+                                 order="last"
+                                 implementation="org.jetbrains.kotlin.idea.core.script.StandardScriptDefinitionContributor"/>
+
+        <scriptDefinitionContributor id="ConsoleScriptDefinitionContributor"
+                                 implementation="org.jetbrains.kotlin.console.ConsoleScriptDefinitionContributor"/>
+
+        <idePlatformKindResolution implementation="org.jetbrains.kotlin.caches.resolve.JvmPlatformKindResolution"/>
+        <idePlatformKindResolution implementation="org.jetbrains.kotlin.caches.resolve.JsPlatformKindResolution"/>
+        <idePlatformKindResolution implementation="org.jetbrains.kotlin.caches.resolve.CommonPlatformKindResolution"/>
+
+        <scratchFileLanguageProvider language="kotlin" implementationClass="org.jetbrains.kotlin.idea.scratch.KtScratchFileLanguageProvider"/>
+        <scriptRelatedModulesProvider implementation="org.jetbrains.kotlin.idea.scratch.ScratchModuleDependencyProvider"/>
+    </extensions>
+</idea-plugin>

idea/src/META-INF/git4idea.xml.as34

@@ -0,0 +1,4 @@
+<idea-plugin>
+    <extensions defaultExtensionNs="Git4Idea">
+    </extensions>
+</idea-plugin>

idea/src/META-INF/gradle-java.xml.as34

@@ -0,0 +1,88 @@
+<idea-plugin>
+    <extensions defaultExtensionNs="org.jetbrains.plugins.gradle">
+        <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJavaFrameworkSupportProvider"/>
+        <frameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.GradleKotlinJSFrameworkSupportProvider"/>
+        <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJavaFrameworkSupportProvider"/>
+        <kotlinDslFrameworkSupport implementation="org.jetbrains.kotlin.idea.configuration.KotlinDslGradleKotlinJSFrameworkSupportProvider"/>
+        <pluginDescriptions implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradlePluginDescription"/>
+        <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectResolverExtension" order="first"/>
+        <projectResolve implementation="org.jetbrains.kotlin.kapt.idea.KaptProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.allopen.ide.AllOpenProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.noarg.ide.NoArgProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverProjectResolverExtension" order="last"/>
+        <projectResolve implementation="org.jetbrains.kotlin.idea.configuration.KotlinMPPGradleProjectResolver"/>
+    </extensions>
+
+    <extensions defaultExtensionNs="com.intellij">
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSourceSetDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleProjectDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleLibraryDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinSourceSetDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.configuration.KotlinTargetDataService"/>
+        <externalProjectDataService implementation="org.jetbrains.kotlin.idea.KotlinJavaMPPSourceSetDataService"/>
+        <externalSystemTaskNotificationListener implementation="org.jetbrains.kotlin.idea.core.script.ReloadGradleTemplatesOnSync"/>
+
+        <localInspection
+            implementationClass="org.jetbrains.kotlin.idea.inspections.gradle.DifferentKotlinGradleVersionInspection"
+            displayName="Kotlin Gradle and IDE plugins versions are different"
+            groupName="Kotlin"
+            enabledByDefault="true"
+            language="Groovy"
+            hasStaticDescription="true"
+            level="WARNING"/>
+
+        <localInspection
+            implementationClass="org.jetbrains.kotlin.idea.inspections.gradle.DifferentStdlibGradleVersionInspection"
+            displayName="Kotlin library and Gradle plugin versions are different"
+            groupName="Kotlin"
+            enabledByDefault="true"
+            language="Groovy"
+            hasStaticDescription="true"
+            level="WARNING"/>
+
+        <localInspection
+            implementationClass="org.jetbrains.kotlin.idea.inspections.gradle.DeprecatedGradleDependencyInspection"
+            displayName="Deprecated library is used in Gradle"
+            groupName="Kotlin"
+            enabledByDefault="true"
+            language="Groovy"
+            hasStaticDescription="true"
+            level="WARNING"/>
+
+        <localInspection
+            implementationClass="org.jetbrains.kotlin.idea.inspections.gradle.GradleKotlinxCoroutinesDeprecationInspection"
+            displayName="Incompatible kotlinx.coroutines dependency is used with Kotlin 1.3+ in Gradle"
+            groupPath="Kotlin,Migration"
+            groupName="Gradle"
+            enabledByDefault="true"
+            language="Groovy"
+            hasStaticDescription="true"
+            level="ERROR"/>
+
+        <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinTestClassGradleConfigurationProducer"/>
+        <runConfigurationProducer implementation="org.jetbrains.kotlin.idea.run.KotlinTestMethodGradleConfigurationProducer"/>
+
+    </extensions>
+
+    <extensions defaultExtensionNs="org.jetbrains.kotlin">
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.allopen.ide.AllOpenGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.scripting.idea.plugin.ScriptingGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.kapt.idea.KaptGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.noarg.ide.NoArgGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlin.samWithReceiver.ide.SamWithReceiverGradleProjectImportHandler"/>
+        <gradleProjectImportHandler implementation="org.jetbrains.kotlinx.serialization.idea.KotlinSerializationGradleImportHandler"/>
+
+        <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleModuleConfigurator"/>
+        <projectConfigurator implementation="org.jetbrains.kotlin.idea.configuration.KotlinJsGradleModuleConfigurator"/>
+        <gradleModelFacade implementation="org.jetbrains.kotlin.idea.inspections.gradle.DefaultGradleModelFacade"/>
+
+        <scriptDefinitionContributor implementation="org.jetbrains.kotlin.idea.core.script.GradleScriptDefinitionsContributor" order="first"/>
+        <scriptRelatedModulesProvider implementation="org.jetbrains.kotlin.idea.core.script.GradleBuildSrcModuleDependencyProvider"/>
+
+        <moduleBuilder implementation="org.jetbrains.kotlin.ide.konan.gradle.KotlinGradleNativeMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleWebMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleSharedMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileMultiplatformModuleBuilder"/>
+        <moduleBuilder implementation="org.jetbrains.kotlin.idea.configuration.KotlinGradleMobileSharedMultiplatformModuleBuilder"/>
+    </extensions>
+</idea-plugin>

idea/src/META-INF/plugin.xml.as34

@@ -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.4505.22.34" until-build="182.*"/>
+  <idea-version since-build="183.1" until-build="183.*"/>
 
   <depends>com.intellij.modules.platform</depends>
   <depends>com.intellij.modules.androidstudio</depends>

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/HasActualMarker.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.idea.highlighter.markers
 
-import com.intellij.codeInsight.daemon.impl.PsiElementListNavigator
 import com.intellij.ide.util.DefaultPsiElementCellRenderer
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.ModuleInfo
@@ -64,19 +63,26 @@ fun getPlatformActualTooltip(declaration: KtDeclaration): String? {
         }
 }
 
-fun navigateToPlatformActual(e: MouseEvent?, declaration: KtDeclaration) {
+fun KtDeclaration.allNavigatableActualDeclarations(): Set<KtDeclaration> =
-    val actualDeclarations =
+    actualsForExpected() + findMarkerBoundDeclarations().flatMap { it.actualsForExpected() }
-        declaration.actualsForExpected() + declaration.findMarkerBoundDeclarations().flatMap { it.actualsForExpected() }
-    if (actualDeclarations.isEmpty()) return
 
-    val renderer = object : DefaultPsiElementCellRenderer() {
+class ActualExpectedPsiElementCellRenderer : DefaultPsiElementCellRenderer() {
-        override fun getContainerText(element: PsiElement?, name: String?) = ""
+    override fun getContainerText(element: PsiElement?, name: String?) = ""
+}
+
+fun KtDeclaration.navigateToActualTitle() = "Choose actual for $name"
+
+fun KtDeclaration.navigateToActualUsagesTitle() = "Actuals for $name"
+
+fun buildNavigateToActualDeclarationsPopup(e: MouseEvent?, element: PsiElement?): NavigationPopupDescriptor? {
+    return element?.markerDeclaration?.let {
+        val navigatableActualDeclarations = it.allNavigatableActualDeclarations()
+        if (navigatableActualDeclarations.isEmpty()) return null
+        return NavigationPopupDescriptor(
+            navigatableActualDeclarations,
+            it.navigateToActualTitle(),
+            it.navigateToActualUsagesTitle(),
+            ActualExpectedPsiElementCellRenderer()
+        )
     }
-    PsiElementListNavigator.openTargets(
-        e,
-        actualDeclarations.toTypedArray(),
-        "Choose actual for ${declaration.name}",
-        "Actuals for ${declaration.name}",
-        renderer
-    )
 }

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/HasExpectedMarker.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.idea.highlighter.markers
 
-import com.intellij.codeInsight.daemon.impl.PsiElementListNavigator
-import com.intellij.ide.util.DefaultPsiElementCellRenderer
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.MemberDescriptor
 import org.jetbrains.kotlin.idea.caches.project.implementedDescriptors
@@ -38,20 +36,22 @@ fun getExpectedDeclarationTooltip(declaration: KtDeclaration): String? {
     return "Has declaration in common module"
 }
 
-fun navigateToExpectedDeclaration(e: MouseEvent?, declaration: KtDeclaration) {
+fun KtDeclaration.allNavigatableExpectedDeclarations(): List<KtDeclaration> =
-    val expectedDeclarations =
+    listOfNotNull(expectedDeclarationIfAny()) + findMarkerBoundDeclarations().mapNotNull { it.expectedDeclarationIfAny() }
-        listOfNotNull(declaration.expectedDeclarationIfAny()) +
-                declaration.findMarkerBoundDeclarations().mapNotNull { it.expectedDeclarationIfAny() }
-    if (expectedDeclarations.isEmpty()) return
 
-    val renderer = object : DefaultPsiElementCellRenderer() {
+fun KtDeclaration.navigateToExpectedTitle() = "Choose expected for $name"
-        override fun getContainerText(element: PsiElement?, name: String?) = ""
+
+fun KtDeclaration.navigateToExpectedUsagesTitle() = "Expected for $name"
+
+fun buildNavigateToExpectedDeclarationsPopup(e: MouseEvent?, element: PsiElement?): NavigationPopupDescriptor? {
+    return element?.markerDeclaration?.let {
+        val navigatableExpectedDeclarations = it.allNavigatableExpectedDeclarations()
+        if (navigatableExpectedDeclarations.isEmpty()) return null
+        return NavigationPopupDescriptor(
+            navigatableExpectedDeclarations,
+            it.navigateToExpectedTitle(),
+            it.navigateToExpectedUsagesTitle(),
+            ActualExpectedPsiElementCellRenderer()
+        )
     }
-    PsiElementListNavigator.openTargets(
-        e,
-        expectedDeclarations.toTypedArray(),
-        "Choose expected for ${declaration.name}",
-        "Expected for ${declaration.name}",
-        renderer
-    )
 }

idea/src/org/jetbrains/kotlin/idea/highlighter/markers/KotlinLineMarkerProvider.kt

@@ -198,28 +198,52 @@ private val OVERRIDDEN_PROPERTY = object : MarkerType(
     }
 }
 
-private val PsiElement.markerDeclaration
+val PsiElement.markerDeclaration
     get() = (this as? KtDeclaration) ?: (parent as? KtDeclaration)
 
-private val PLATFORM_ACTUAL = MarkerType(
+private val PLATFORM_ACTUAL = object : MarkerType(
     "PLATFORM_ACTUAL",
     { element -> element?.markerDeclaration?.let { getPlatformActualTooltip(it) } },
     object : LineMarkerNavigator() {
         override fun browse(e: MouseEvent?, element: PsiElement?) {
-            element?.markerDeclaration?.let { navigateToPlatformActual(e, it) }
+            buildNavigateToActualDeclarationsPopup(e, element)?.showPopup(e)
+        }
+    }) {
+    override fun getNavigationHandler(): GutterIconNavigationHandler<PsiElement> {
+        val superHandler = super.getNavigationHandler()
+        return object : GutterIconNavigationHandler<PsiElement>, TestableLineMarkerNavigator {
+            override fun navigate(e: MouseEvent?, elt: PsiElement?) {
+                superHandler.navigate(e, elt)
+            }
+
+            override fun getTargetsPopupDescriptor(element: PsiElement?): NavigationPopupDescriptor? {
+                return buildNavigateToActualDeclarationsPopup(null, element)
+            }
         }
     }
-)
+}
 
-private val EXPECTED_DECLARATION = MarkerType(
+private val EXPECTED_DECLARATION = object : MarkerType(
     "EXPECTED_DECLARATION",
     { element -> element?.markerDeclaration?.let { getExpectedDeclarationTooltip(it) } },
     object : LineMarkerNavigator() {
         override fun browse(e: MouseEvent?, element: PsiElement?) {
-            element?.markerDeclaration?.let { navigateToExpectedDeclaration(e, it) }
+            buildNavigateToExpectedDeclarationsPopup(e, element)?.showPopup(e)
+        }
+    }) {
+    override fun getNavigationHandler(): GutterIconNavigationHandler<PsiElement> {
+        val superHandler = super.getNavigationHandler()
+        return object : GutterIconNavigationHandler<PsiElement>, TestableLineMarkerNavigator {
+            override fun navigate(e: MouseEvent?, elt: PsiElement?) {
+                superHandler.navigate(e, elt)
+            }
+
+            override fun getTargetsPopupDescriptor(element: PsiElement?): NavigationPopupDescriptor? {
+                return buildNavigateToExpectedDeclarationsPopup(null, element)
+            }
         }
     }
-)
+}
 
 private fun isImplementsAndNotOverrides(
     descriptor: CallableMemberDescriptor,

idea/src/org/jetbrains/kotlin/idea/reporter/KotlinReportSubmitter.kt.as34

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.reporter
+
+import com.intellij.diagnostic.ITNReporter
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.diagnostic.IdeaLoggingEvent
+import com.intellij.openapi.diagnostic.SubmittedReportInfo
+import com.intellij.openapi.ui.Messages
+import com.intellij.util.Consumer
+import org.jetbrains.kotlin.idea.KotlinPluginUpdater
+import org.jetbrains.kotlin.idea.KotlinPluginUtil
+import org.jetbrains.kotlin.idea.PluginUpdateStatus
+import java.awt.Component
+
+/**
+ * We need to wrap ITNReporter for force showing or errors from kotlin plugin even from released version of IDEA.
+ */
+class KotlinReportSubmitter : ITNReporter() {
+    private var hasUpdate = false
+    private var hasLatestVersion = false
+
+    override fun showErrorInRelease(event: IdeaLoggingEvent): Boolean {
+        val notificationEnabled = "disabled" != System.getProperty("kotlin.fatal.error.notification", "enabled")
+        return notificationEnabled && (!hasUpdate || ApplicationManager.getApplication().isInternal)
+    }
+
+    override fun submit(events: Array<IdeaLoggingEvent>, additionalInfo: String?, parentComponent: Component?, consumer: Consumer<SubmittedReportInfo>): Boolean {
+        if (hasUpdate) {
+            if (ApplicationManager.getApplication().isInternal) {
+                return super.submit(events, additionalInfo, parentComponent, consumer)
+            }
+            return true
+        }
+
+        if (hasLatestVersion) {
+            return super.submit(events, additionalInfo, parentComponent, consumer)
+        }
+
+        KotlinPluginUpdater.getInstance().runUpdateCheck { status ->
+            if (status is PluginUpdateStatus.Update) {
+                hasUpdate = true
+                if (parentComponent != null) {
+
+                    if (ApplicationManager.getApplication().isInternal) {
+                        super.submit(events, additionalInfo, parentComponent, consumer)
+                    }
+
+                    val rc = Messages.showDialog(parentComponent,
+                                                 "You're running Kotlin plugin version ${KotlinPluginUtil.getPluginVersion()}, " +
+                                                 "while the latest version is ${status.pluginDescriptor.version}",
+                                                 "Update Kotlin Plugin",
+                                                 arrayOf("Update", "Ignore"),
+                                                 0, Messages.getInformationIcon())
+                    if (rc == 0) {
+                        KotlinPluginUpdater.getInstance().installPluginUpdate(status)
+                    }
+                }
+            }
+            else {
+                hasLatestVersion = true
+                super.submit(events, additionalInfo, parentComponent, consumer)
+            }
+            false
+        }
+        return true
+    }
+}

idea/src/org/jetbrains/kotlin/idea/testResourceBundle.kt.as34

@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DEPRECATION")
+
+package org.jetbrains.kotlin.idea
+
+import com.intellij.featureStatistics.FeatureStatisticsBundleProvider
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.extensions.Extensions
+import java.lang.IllegalStateException
+
+private const val CIDR_FEATURE_STATISTICS_PROVIDER_FQNAME = "com.jetbrains.cidr.lang.OCFeatureStatisticsBundleProvider"
+
+fun registerAdditionalResourceBundleInTests() {
+    if (!ApplicationManager.getApplication().isUnitTestMode) {
+        return
+    }
+
+    val isAlreadyRegistered = FeatureStatisticsBundleProvider.EP_NAME.extensions.any { provider ->
+        provider.javaClass.name == CIDR_FEATURE_STATISTICS_PROVIDER_FQNAME
+    }
+    if (isAlreadyRegistered) {
+        throw IllegalStateException("Remove this registration for the current platform: bundle is already registered.")
+    }
+
+    val cidrFSBundleProviderClass = try {
+        Class.forName(CIDR_FEATURE_STATISTICS_PROVIDER_FQNAME)
+    } catch (_: ClassNotFoundException) {
+        throw IllegalStateException("Remove this registration for the current platform: class wasn't found.")
+    }
+
+    val cidrFSBundleProvider = cidrFSBundleProviderClass.newInstance() as FeatureStatisticsBundleProvider
+
+    Extensions.getRootArea().getExtensionPoint(FeatureStatisticsBundleProvider.EP_NAME).registerExtension(cidrFSBundleProvider)
+}

idea/src/org/jetbrains/kotlin/idea/update/GooglePluginUpdateVerifier.kt.as34

@@ -0,0 +1,152 @@
+/*
+ * 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.kotlin.idea.update
+
+import com.intellij.ide.plugins.IdeaPluginDescriptor
+import com.intellij.ide.plugins.PluginManagerCore
+import com.intellij.ide.plugins.PluginNode
+import com.intellij.openapi.diagnostic.Logger
+import org.jetbrains.kotlin.idea.util.isDev
+import org.jetbrains.kotlin.idea.util.isEap
+import java.io.IOException
+import java.net.URL
+import java.util.*
+import javax.xml.bind.JAXBContext
+import javax.xml.bind.JAXBException
+import javax.xml.bind.annotation.*
+
+class GooglePluginUpdateVerifier : PluginUpdateVerifier() {
+    override val verifierName: String
+        get() = "Android Studio"
+
+    // Verifies if a plugin can be installed in Android Studio 3.2+.
+    // Currently used only by KotlinPluginUpdater.
+    override fun verify(pluginDescriptor: IdeaPluginDescriptor): PluginVerifyResult? {
+        if (pluginDescriptor.pluginId.idString != KOTLIN_PLUGIN_ID) {
+            return null
+        }
+
+        val version = pluginDescriptor.version
+        if (isEap(version) || isDev(version)) {
+            return PluginVerifyResult.accept()
+        }
+
+        try {
+            val url = URL(METADATA_FILE_URL)
+            val stream = url.openStream()
+            val context = JAXBContext.newInstance(PluginCompatibility::class.java)
+            val unmarshaller = context.createUnmarshaller()
+            val pluginCompatibility = unmarshaller.unmarshal(stream) as PluginCompatibility
+
+            val release = getRelease(pluginCompatibility)
+                    ?: return PluginVerifyResult.decline("No verified versions for this build.")
+
+            return if (release.plugins().any { KOTLIN_PLUGIN_ID == it.id && version == it.version })
+                PluginVerifyResult.accept()
+            else
+                PluginVerifyResult.decline("Version to be verified.")
+        } catch (e: Exception) {
+            LOG.info("Exception when verifying plugin ${pluginDescriptor.pluginId.idString} version $version", e)
+            return when (e) {
+                is IOException ->
+                    PluginVerifyResult.decline("unable to connect to compatibility verification repository")
+                is JAXBException -> PluginVerifyResult.decline("unable to parse compatibility verification metadata")
+                else -> PluginVerifyResult.decline("exception during verification ${e.message}")
+            }
+        }
+    }
+
+    private fun getRelease(pluginCompatibility: PluginCompatibility): StudioRelease? {
+        for (studioRelease in pluginCompatibility.releases()) {
+            if (buildInRange(studioRelease.name, studioRelease.sinceBuild, studioRelease.untilBuild)) {
+                return studioRelease
+            }
+        }
+        return null
+    }
+
+    private fun buildInRange(name: String?, sinceBuild: String?, untilBuild: String?): Boolean {
+        val descriptor = PluginNode()
+        descriptor.name = name
+        descriptor.sinceBuild = sinceBuild
+        descriptor.untilBuild = untilBuild
+        return PluginManagerCore.isCompatible(descriptor)
+    }
+
+    companion object {
+        private const val KOTLIN_PLUGIN_ID = "org.jetbrains.kotlin"
+        private const val METADATA_FILE_URL = "https://dl.google.com/android/studio/plugins/compatibility.xml"
+
+        private val LOG = Logger.getInstance(GooglePluginUpdateVerifier::class.java)
+
+        private fun PluginCompatibility.releases() = studioRelease ?: emptyArray()
+        private fun StudioRelease.plugins() = ideaPlugin ?: emptyArray()
+
+        @XmlRootElement(name = "plugin-compatibility")
+        @XmlAccessorType(XmlAccessType.FIELD)
+        class PluginCompatibility {
+            @XmlElement(name = "studio-release")
+            var studioRelease: Array<StudioRelease>? = null
+
+            override fun toString(): String {
+                return "PluginCompatibility(studioRelease=${Arrays.toString(studioRelease)})"
+            }
+        }
+
+        @XmlAccessorType(XmlAccessType.FIELD)
+        class StudioRelease {
+            @XmlAttribute(name = "until-build")
+            var untilBuild: String? = null
+            @XmlAttribute(name = "since-build")
+            var sinceBuild: String? = null
+            @XmlAttribute
+            var name: String? = null
+            @XmlAttribute
+            var channel: String? = null
+
+            @XmlElement(name = "idea-plugin")
+            var ideaPlugin: Array<IdeaPlugin>? = null
+
+            override fun toString(): String {
+                return "StudioRelease(" +
+                        "untilBuild=$untilBuild, name=$name, ideaPlugin=${Arrays.toString(ideaPlugin)}, " +
+                        "sinceBuild=$sinceBuild, channel=$channel" +
+                        ")"
+            }
+        }
+
+        @XmlAccessorType(XmlAccessType.FIELD)
+        class IdeaPlugin {
+            @XmlAttribute
+            var id: String? = null
+            @XmlAttribute
+            var sha256: String? = null
+            @XmlAttribute
+            var channel: String? = null
+            @XmlAttribute
+            var version: String? = null
+
+            @XmlElement(name = "idea-version")
+            var ideaVersion: IdeaVersion? = null
+
+            override fun toString(): String {
+                return "IdeaPlugin(id=$id, sha256=$sha256, ideaVersion=$ideaVersion, channel=$channel, version=$version)"
+            }
+        }
+
+        @XmlAccessorType(XmlAccessType.FIELD)
+        class IdeaVersion {
+            @XmlAttribute(name = "until-build")
+            var untilBuild: String? = null
+            @XmlAttribute(name = "since-build")
+            var sinceBuild: String? = null
+
+            override fun toString(): String {
+                return "IdeaVersion(untilBuild=$untilBuild, sinceBuild=$sinceBuild)"
+            }
+        }
+    }
+}

idea/src/org/jetbrains/kotlin/idea/update/verify.kt.as34

@@ -0,0 +1,35 @@
+/*
+ * 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.kotlin.idea.update
+
+import com.intellij.ide.plugins.IdeaPluginDescriptor
+import com.intellij.openapi.util.registry.Registry
+import org.jetbrains.kotlin.idea.PluginUpdateStatus
+
+// Do an additional verification with PluginUpdateVerifier. Enabled only in AS 3.2+
+fun verify(updateStatus: PluginUpdateStatus.Update): PluginUpdateStatus {
+    @Suppress("InvalidBundleOrProperty")
+    val pluginVerifierEnabled = Registry.`is`("kotlin.plugin.update.verifier.enabled", true)
+    if (!pluginVerifierEnabled) {
+        return updateStatus
+    }
+
+    val pluginDescriptor: IdeaPluginDescriptor = updateStatus.pluginDescriptor
+    val pluginVerifiers = PluginUpdateVerifier.EP_NAME.extensions
+
+    for (pluginVerifier in pluginVerifiers) {
+        val verifyResult = pluginVerifier.verify(pluginDescriptor) ?: continue
+        if (!verifyResult.verified) {
+            return PluginUpdateStatus.Unverified(
+                pluginVerifier.verifierName,
+                verifyResult.declineMessage,
+                updateStatus
+            )
+        }
+    }
+
+    return updateStatus
+}

idea/testData/debugger/fileRanking/anonymousClasses.kt

@@ -0,0 +1,22 @@
+//FILE: a/a.kt
+// DISABLE_STRICT_MODE
+package a
+
+abstract class R {
+    abstract fun run()
+}
+
+fun eval(r: R) {
+    r.run()
+}
+
+class Some {
+    fun foo() {
+        eval(object : R() {      // Line with negative score
+            override fun run() {
+                val a = 1        // R: 4 L: 17
+                val b = 12       // R: 4 L: 18
+            }
+        })
+    }
+}

idea/testData/debugger/fileRanking/lambdas.kt

@@ -1,11 +1,12 @@
 // DO_NOT_CHECK_CLASS_FQNAME
+// DISABLE_STRICT_MODE
 
 //FILE: a/a.kt
 package a
 
 fun block(l: () -> Unit) {}
 
-class A {
+class A {                        // Line with the same rank
     fun a() {
         block {
             val a = 5
@@ -18,12 +19,13 @@ class A {
 
 //FILE: b/a.kt
 package b
+// Fake Line
 
 import a.block
 
 class A {
     fun b() {
-        val g = 5
+        val g = 5               // Line with the same rank
         val x = 1
         block { val y = 2 }
         block {

idea/testData/debugger/tinyApp/src/stepping/stepOver/stopInObjectLiteralInInlineCallWithClosureInAnonymous.kt

@@ -1,5 +1,7 @@
 package stopInObjectLiteralInInlineCallWithClosureInAnonymous
 
+// FORCE_RANKING
+
 fun main(args: Array<String>) {
     val a = 12
 

idea/testData/multiModuleLineMarker/actualConstructorWithProperties/jvm/jvm.kt

@@ -1 +1,11 @@
-actual class <lineMarker>WithConstructor</lineMarker> actual constructor(actual val x: Int, actual val s: String)
+actual class <lineMarker descr="Has declaration in common module">WithConstructor</lineMarker> actual constructor(actual val x: Int, actual val s: String)
+
+/*
+LINEMARKER: Has declaration in common module
+TARGETS:
+common.kt
+expect class <1>WithConstructor(x: Int, s: String) {
+    val <3>x: Int
+
+    val <2>s: String
+*/

idea/testData/multiModuleLineMarker/actualEnumEntriesInOneLine/jvm/jvm.kt

@@ -1,3 +1,10 @@
 package test
 
-actual enum class <lineMarker>Enum</lineMarker> { A, B, C }
+actual enum class <lineMarker descr="Has declaration in common module">Enum</lineMarker> { A, B, C }
+
+/*
+LINEMARKER: Has declaration in common module
+TARGETS:
+common.kt
+expect enum class <4>Enum { <1>A, <2>B, <3>C }
+*/

idea/testData/multiModuleLineMarker/expectEnumEntriesInOneLine/common/common.kt

@@ -1,3 +1,10 @@
 package test
 
-expect enum class <lineMarker>Enum</lineMarker> { A, B, C, D }
+expect enum class <lineMarker descr="Has actuals in JVM">Enum</lineMarker> { A, B, C, D }
+
+/*
+LINEMARKER: Has actuals in JVM
+TARGETS:
+jvm.kt
+actual enum class <5>Enum { <1>A, <2>B, <3>C, <4>D }
+*/

idea/testData/multiModuleLineMarker/suspendImplInPlatformModules/common/common.kt

@@ -1,3 +1,12 @@
 interface <lineMarker>I</lineMarker> {
     suspend fun <lineMarker descr="<html><body>Is implemented in <br>&nbsp;&nbsp;&nbsp;&nbsp;KJs<br>&nbsp;&nbsp;&nbsp;&nbsp;KJvm</body></html>">foo</lineMarker>(s: String)
-}
+}
+
+/*
+LINEMARKER: <html><body>Is implemented in <br>&nbsp;&nbsp;&nbsp;&nbsp;KJs<br>&nbsp;&nbsp;&nbsp;&nbsp;KJvm</body></html>
+TARGETS:
+js.kt
+    suspend override fun <1>foo(s: String) {
+ jvm.kt
+    suspend override fun <2>foo(s: String) {
+*/

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

@@ -16,16 +16,30 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
+import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl
 import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.idea.codeInsight.AbstractLineMarkersTest
 import org.jetbrains.kotlin.idea.multiplatform.setupMppProjectFromDirStructure
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiHighlightingTest
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.idea.test.allJavaFiles
 import org.jetbrains.kotlin.idea.test.allKotlinFiles
+import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 
 abstract class AbstractMultiModuleHighlightingTest : AbstractMultiHighlightingTest() {
 
+    protected open fun checkLineMarkersInProject(
+        findFiles: () -> List<PsiFile> = { project.allKotlinFiles().excludeByDirective() }
+    ) {
+        checkFiles(findFiles) {
+            checkHighlighting(myEditor, true, false)
+
+            val markers = DaemonCodeAnalyzerImpl.getLineMarkers(getDocument(file), project)
+            AbstractLineMarkersTest.assertNavigationElements(project, myFile as KtFile, markers)
+        }
+    }
+
     protected open fun checkHighlightingInProject(
         findFiles: () -> List<PsiFile> = { project.allKotlinFiles().excludeByDirective() }
     ) {

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

@@ -32,6 +32,6 @@ abstract class AbstractMultiModuleLineMarkerTest : AbstractMultiModuleHighlighti
 
     protected fun doTest(path: String) {
         setupMppProjectFromDirStructure(File(path))
-        checkHighlightingInProject()
+        checkLineMarkersInProject()
     }
 }

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

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.caches.resolve
+
+import com.intellij.openapi.util.Key
+import com.intellij.psi.*
+import org.jetbrains.kotlin.asJava.elements.KtLightElement
+import org.jetbrains.kotlin.asJava.elements.KtLightModifierList
+import org.jetbrains.kotlin.idea.KotlinLanguage
+import org.junit.Assert
+
+object PsiElementChecker {
+    val TEST_DATA_KEY = Key.create<Int>("Test Key")
+
+    fun checkPsiElementStructure(lightClass: PsiClass) {
+        checkPsiElement(lightClass)
+
+        lightClass.methods.forEach {
+            it.parameterList.parameters.forEach { checkPsiElement(it) }
+            checkPsiElement(it)
+        }
+
+        lightClass.fields.forEach { checkPsiElement(it) }
+
+        lightClass.innerClasses.forEach { checkPsiElementStructure(it) }
+    }
+
+    private fun checkPsiElement(element: PsiElement) {
+        if (element !is KtLightElement<*, *> && element !is KtLightModifierList<*>) return
+
+        if (element is PsiModifierListOwner) {
+            val modifierList = element.modifierList
+            if (modifierList != null) {
+                checkPsiElement(modifierList)
+            }
+        }
+
+        if (element is PsiTypeParameterListOwner) {
+            val typeParameterList = element.typeParameterList
+            if (typeParameterList != null) {
+                checkPsiElement(typeParameterList)
+                typeParameterList.typeParameters.forEach { checkPsiElement(it) }
+            }
+        }
+
+        with(element) {
+            try {
+                Assert.assertEquals("Number of methods has changed. Please update test.", 55, PsiElement::class.java.methods.size)
+
+                project
+                Assert.assertTrue(language == KotlinLanguage.INSTANCE)
+                manager
+                children
+                parent
+                firstChild
+                lastChild
+                nextSibling
+                prevSibling
+                containingFile
+                textRange
+                //textRangeInParent - throws an exception for non-physical elements, it is expected behaviour
+                startOffsetInParent
+                textLength
+                findElementAt(0)
+                findReferenceAt(0)
+                textOffset
+                text
+                textToCharArray()
+                navigationElement
+                originalElement
+                textMatches("")
+                Assert.assertTrue(textMatches(this))
+                textContains('a')
+                accept(PsiElementVisitor.EMPTY_VISITOR)
+                acceptChildren(PsiElementVisitor.EMPTY_VISITOR)
+
+                val copy = copy()
+                Assert.assertTrue(copy == null || copy::class.java == this::class.java)
+
+                // Modify methods:
+                // add(this)
+                // addBefore(this, lastChild)
+                // addAfter(firstChild, this)
+                // checkAdd(this)
+                // addRange(firstChild, lastChild)
+                // addRangeBefore(firstChild, lastChild, lastChild)
+                // addRangeAfter(firstChild, lastChild, firstChild)
+                // delete()
+                // checkDelete()
+                // deleteChildRange(firstChild, lastChild)
+                // replace(this)
+
+                Assert.assertTrue(isValid)
+                isWritable
+                reference
+                references
+                putCopyableUserData(TEST_DATA_KEY, 12)
+
+                Assert.assertTrue(getCopyableUserData(TEST_DATA_KEY) == 12)
+                // Assert.assertTrue(copy().getCopyableUserData(TEST_DATA_KEY) == 12) { this } Doesn't work
+
+                // processDeclarations(...)
+
+                context
+                isPhysical
+                resolveScope
+                useScope
+                node
+                toString()
+                Assert.assertTrue(isEquivalentTo(this))
+            }
+            catch (t: Throwable) {
+                throw AssertionErrorWithCause("Failed for ${this::class.java} ${this}", t)
+            }
+        }
+    }
+}

idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractLineMarkersTest.kt

@@ -9,6 +9,7 @@ import com.intellij.codeInsight.daemon.DaemonCodeAnalyzerSettings
 import com.intellij.codeInsight.daemon.LineMarkerInfo
 import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl
 import com.intellij.openapi.editor.Document
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.rt.execution.junit.FileComparisonFailure
@@ -93,7 +94,7 @@ abstract class AbstractLineMarkersTest : KotlinLightCodeInsightFixtureTestCase()
 
             val markers = doAndCheckHighlighting(document, data, File(path))
 
-            assertNavigationElements(markers)
+            assertNavigationElements(myFixture.project, myFixture.file as KtFile, markers)
             additionalCheck()
         } catch (exc: Exception) {
             throw RuntimeException(exc)
@@ -104,45 +105,53 @@ abstract class AbstractLineMarkersTest : KotlinLightCodeInsightFixtureTestCase()
 
     }
 
-    private fun assertNavigationElements(markers: List<LineMarkerInfo<*>>) {
-        val navigationDataComments = KotlinTestUtils.getLastCommentsInFile(
-                myFixture.file as KtFile, KotlinTestUtils.CommentType.BLOCK_COMMENT, false)
-        if (navigationDataComments.isEmpty()) return
-
-        for (navigationComment in navigationDataComments) {
-            val description = getLineMarkerDescription(navigationComment)
-            val navigateMarker = markers.find { it.lineMarkerTooltip?.startsWith(description) == true }!!
-
-            TestCase.assertNotNull(
-                    String.format("Can't find marker for navigation check with description \"%s\"", description),
-                    navigateMarker)
-
-            val handler = navigateMarker.navigationHandler
-            if (handler is TestableLineMarkerNavigator) {
-                val navigateElements = handler.getTargetsPopupDescriptor(navigateMarker.element)?.targets?.sortedBy { it.renderAsGotoImplementation() }
-                val actualNavigationData = NavigationTestUtils.getNavigateElementsText(myFixture.project, navigateElements)
-
-                UsefulTestCase.assertSameLines(getExpectedNavigationText(navigationComment), actualNavigationData)
-            }
-            else {
-                Assert.fail("Only SuperDeclarationMarkerNavigationHandler are supported in navigate check")
-            }
-        }
-    }
-
     companion object {
 
-        private val LINE_MARKER_PREFIX = "LINEMARKER:"
+        @Suppress("SpellCheckingInspection")
-        private val TARGETS_PREFIX = "TARGETS"
+        private const val LINE_MARKER_PREFIX = "LINEMARKER:"
+        private const val TARGETS_PREFIX = "TARGETS"
+
+        fun assertNavigationElements(project: Project, file: KtFile, markers: List<LineMarkerInfo<*>>) {
+            val navigationDataComments = KotlinTestUtils.getLastCommentsInFile(
+                file, KotlinTestUtils.CommentType.BLOCK_COMMENT, false
+            )
+            if (navigationDataComments.isEmpty()) return
+
+            for (navigationComment in navigationDataComments) {
+                val description = getLineMarkerDescription(navigationComment)
+                val navigateMarker = markers.find { it.lineMarkerTooltip?.startsWith(description) == true }!!
+
+                TestCase.assertNotNull(
+                    String.format("Can't find marker for navigation check with description \"%s\"", description),
+                    navigateMarker
+                )
+
+                val handler = navigateMarker.navigationHandler
+                if (handler is TestableLineMarkerNavigator) {
+                    val navigateElements = handler.getTargetsPopupDescriptor(navigateMarker.element)?.targets?.sortedBy {
+                        it.renderAsGotoImplementation()
+                    }
+                    val actualNavigationData = NavigationTestUtils.getNavigateElementsText(project, navigateElements)
+
+                    UsefulTestCase.assertSameLines(getExpectedNavigationText(navigationComment), actualNavigationData)
+                } else {
+                    Assert.fail("Only TestableLineMarkerNavigator are supported in navigate check")
+                }
+            }
+        }
 
         private fun getLineMarkerDescription(navigationComment: String): String {
             val firstLineEnd = navigationComment.indexOf("\n")
-            TestCase.assertTrue("The first line in block comment must contain description of marker for navigation check", firstLineEnd != -1)
+            TestCase.assertTrue(
+                "The first line in block comment must contain description of marker for navigation check", firstLineEnd != -1
+            )
 
             var navigationMarkerText = navigationComment.substring(0, firstLineEnd)
 
-            TestCase.assertTrue(String.format("Add %s directive in first line of comment", LINE_MARKER_PREFIX),
+            TestCase.assertTrue(
-                                navigationMarkerText.startsWith(LINE_MARKER_PREFIX))
+                String.format("Add %s directive in first line of comment", LINE_MARKER_PREFIX),
+                navigationMarkerText.startsWith(LINE_MARKER_PREFIX)
+            )
 
             navigationMarkerText = navigationMarkerText.substring(LINE_MARKER_PREFIX.length)
 
@@ -155,8 +164,9 @@ abstract class AbstractLineMarkersTest : KotlinLightCodeInsightFixtureTestCase()
             var expectedNavigationText = navigationComment.substring(firstLineEnd + 1)
 
             TestCase.assertTrue(
-                    String.format("Marker %s is expected before navigation data", TARGETS_PREFIX),
+                String.format("Marker %s is expected before navigation data", TARGETS_PREFIX),
-                    expectedNavigationText.startsWith(TARGETS_PREFIX))
+                expectedNavigationText.startsWith(TARGETS_PREFIX)
+            )
 
             expectedNavigationText = expectedNavigationText.substring(expectedNavigationText.indexOf("\n") + 1)
 

idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractFileRankingTest.kt

@@ -1,40 +1,74 @@
 package org.jetbrains.kotlin.idea.debugger
 
 import com.sun.jdi.ThreadReference
+import org.jetbrains.kotlin.codegen.ClassFileFactory
 import org.jetbrains.kotlin.codegen.OriginCollectingClassBuilderFactory
+import org.jetbrains.kotlin.codegen.getClassFiles
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.org.objectweb.asm.tree.ClassNode
+import org.junit.Assert
 
 abstract class AbstractFileRankingTest : LowLevelDebuggerTestBase() {
     override fun doTest(
         options: Set<String>,
         mainThread: ThreadReference,
         factory: OriginCollectingClassBuilderFactory,
+        classFileFactory: ClassFileFactory,
         state: GenerationState
     ) {
-        val allKtFiles = factory.origins.mapNotNull { it.value.element?.containingFile as? KtFile }.distinct()
+        val allKtFiles = classFileFactory.inputFiles.distinct()
         fun getKtFiles(name: String) = allKtFiles.filter { it.name == name }
 
         val doNotCheckClassFqName = "DO_NOT_CHECK_CLASS_FQNAME" in options
+        val strictMode = "DISABLE_STRICT_MODE" !in options
 
-        val calculator = object : FileRankingCalculator(checkClassFqName = !doNotCheckClassFqName, strictMode = true) {
+        val expectedRanks: Map<Pair<KtFile, Int>, Int> = allKtFiles.asSequence().flatMap { ktFile ->
+            ktFile.text.lines()
+                .asSequence()
+                .withIndex()
+                .map {
+                    val matchResult = "^.*// (R: (-?\\d+)( L: (\\d+))?)\\s*$".toRegex().matchEntire(it.value) ?: return@map null
+
+                    val rank = matchResult.groupValues[2].toInt()
+                    val line = matchResult.groupValues.getOrNull(4)?.takeIf { !it.isEmpty() }?.toInt()
+
+                    if (line != null && line != it.index + 1) {
+                        throw IllegalArgumentException("Bad line in directive at ${ktFile.name}:${it.index + 1}\n${it.value}")
+                    }
+
+                    (ktFile to it.index + 1) to rank
+                }
+                .filterNotNull()
+        }.toMap()
+
+        val calculator = object : FileRankingCalculator(checkClassFqName = !doNotCheckClassFqName) {
             override fun analyze(element: KtElement) = state.bindingContext
         }
 
         val problems = mutableListOf<String>()
 
-        val skipClasses = skipLoadingClasses(options)
+        val classNameToKtFile = factory.origins.asSequence()
-        for ((node, origin) in factory.origins) {
+            .filter { it.key is ClassNode }
-            val classNode = node as? ClassNode ?: continue
+            .map {
-            val expectedFile = origin.element?.containingFile as? KtFile ?: continue
+                val ktFile = (it.value.element?.containingFile as? KtFile) ?: return@map null
-            val className = classNode.name.replace('/', '.')
+                val name = (it.key as ClassNode).name.replace('/', '.')
 
+                name to ktFile
+            }
+            .filterNotNull()
+            .toMap()
+
+        val skipClasses = skipLoadingClasses(options)
+        for (outputFile in classFileFactory.getClassFiles()) {
+            val className = outputFile.internalName.replace('/', '.')
             if (className in skipClasses) {
                 continue
             }
 
+            val expectedFile = classNameToKtFile[className] ?: throw IllegalStateException("Can't find source for $className")
+
             val jdiClass = mainThread.virtualMachine().classesByName(className).singleOrNull()
                 ?: error("Class '$className' was not found in the debuggee process class loader")
 
@@ -46,7 +80,27 @@ abstract class AbstractFileRankingTest : LowLevelDebuggerTestBase() {
             for (location in locations) {
                 if (location.method().isBridge || location.method().isSynthetic) continue
 
-                val actualFile = calculator.findMostAppropriateSource(allFilesWithSameName, location)
+                val fileWithRankings: Map<KtFile, Int> = calculator.rankFiles(allFilesWithSameName, location)
+
+                for ((ktFile, rank) in fileWithRankings) {
+                    val expectedRank = expectedRanks[ktFile to (location.lineNumber())]
+                    if (expectedRank != null) {
+                        Assert.assertEquals("Invalid expected rank at $location", expectedRank, rank)
+                    }
+                }
+
+                val fileWithMaxScore = fileWithRankings.maxBy { it.value }!!
+                val actualFile = fileWithMaxScore.key
+
+                if (strictMode) {
+                    require(fileWithMaxScore.value >= 0) { "Max score is negative at $location" }
+
+                    // Allow only one element with max ranking
+                    require(fileWithRankings.filter { it.value == fileWithMaxScore.value }.count() == 1) {
+                        "Score is the same for several files at $location"
+                    }
+                }
+
                 if (actualFile != expectedFile) {
                     problems += "Location ${location.sourceName()}:${location.lineNumber() - 1} is associated with a wrong KtFile:\n" +
                             "    - expected: ${expectedFile.virtualFilePath}\n" +

idea/tests/org/jetbrains/kotlin/idea/debugger/FileRankingTestGenerated.java

@@ -29,6 +29,11 @@ public class FileRankingTestGenerated extends AbstractFileRankingTest {
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/debugger/fileRanking"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
     }
 
+    @TestMetadata("anonymousClasses.kt")
+    public void testAnonymousClasses() throws Exception {
+        runTest("idea/testData/debugger/fileRanking/anonymousClasses.kt");
+    }
+
     @TestMetadata("differentFlags.kt")
     public void testDifferentFlags() throws Exception {
         runTest("idea/testData/debugger/fileRanking/differentFlags.kt");

idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt

@@ -65,7 +65,6 @@ import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPrefixes
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
 import java.io.File
-import java.lang.AssertionError
 import javax.swing.SwingUtilities
 
 abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
@@ -113,6 +112,8 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
         debuggerSettings.SKIP_CLASSLOADERS = fileText.getValueForSetting("SKIP_CLASSLOADERS", oldSettings!!.SKIP_CLASSLOADERS)
         debuggerSettings.TRACING_FILTERS_ENABLED = fileText.getValueForSetting("TRACING_FILTERS_ENABLED", oldSettings!!.TRACING_FILTERS_ENABLED)
         debuggerSettings.SKIP_GETTERS = fileText.getValueForSetting("SKIP_GETTERS", oldSettings!!.SKIP_GETTERS)
+
+        DebuggerUtils.forceRanking = InTextDirectivesUtils.isDirectiveDefined(fileText, "FORCE_RANKING")
     }
 
     private fun String.getValueForSetting(name: String, defaultValue: Boolean): Boolean {
@@ -137,6 +138,8 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() {
         debuggerSettings.SKIP_CLASSLOADERS = oldSettings!!.SKIP_CLASSLOADERS
         debuggerSettings.TRACING_FILTERS_ENABLED = oldSettings!!.TRACING_FILTERS_ENABLED
         debuggerSettings.SKIP_GETTERS = oldSettings!!.SKIP_GETTERS
+
+        DebuggerUtils.forceRanking = false
     }
 
     protected val dp: DebugProcessImpl

idea/tests/org/jetbrains/kotlin/idea/debugger/LowLevelDebuggerTestBase.kt

@@ -14,13 +14,12 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.test.ConfigurationKind
-import org.jetbrains.org.objectweb.asm.tree.ClassNode
-import org.jetbrains.org.objectweb.asm.Type as AsmType
 import java.io.File
 import java.io.IOException
 import java.net.Socket
 import java.nio.file.Files
 import kotlin.properties.Delegates
+import org.jetbrains.org.objectweb.asm.Type as AsmType
 
 abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
     private companion object {
@@ -34,7 +33,7 @@ abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
 
         val options = wholeFile.readLines()
             .asSequence()
-            .filter { it.matches("^// ?[\\w_]+(:.*)$".toRegex()) }
+            .filter { it.matches("^// ?[\\w_]+(:.*)?$".toRegex()) }
             .map { it.drop(2).trim() }
             .filter { !it.startsWith("FILE:") }
             .toSet()
@@ -63,8 +62,8 @@ abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
 
             try {
                 val mainThread = virtualMachine.allThreads().single { it.name() == "main" }
-                waitUntil { areCompiledClassesLoaded(mainThread, classBuilderFactory, skipLoadingClasses) }
+                waitUntil { areCompiledClassesLoaded(mainThread, classFileFactory, skipLoadingClasses) }
-                doTest(options, mainThread, classBuilderFactory, generationState)
+                doTest(options, mainThread, classBuilderFactory, classFileFactory, generationState)
             } finally {
                 virtualMachine.exit(0)
                 process.destroy()
@@ -78,6 +77,7 @@ abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
         options: Set<String>,
         mainThread: ThreadReference,
         factory: OriginCollectingClassBuilderFactory,
+        classFileFactory: ClassFileFactory,
         state: GenerationState
     )
 
@@ -92,13 +92,12 @@ abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
 
     private fun areCompiledClassesLoaded(
         mainThread: ThreadReference,
-        factory: OriginCollectingClassBuilderFactory,
+        classFileFactory: ClassFileFactory,
         skipLoadingClasses: Set<String>
     ): Boolean {
-        for ((node, _) in factory.origins) {
-            val classNode = node as? ClassNode ?: continue
 
-            val fqName = classNode.name.replace('/', '.')
+        for (outputFile in classFileFactory.getClassFiles()) {
+            val fqName = outputFile.internalName.replace('/', '.')
             if (fqName in skipLoadingClasses) {
                 continue
             }
@@ -155,10 +154,10 @@ abstract class LowLevelDebuggerTestBase : CodegenTestCase() {
         File(classesDir, mainClassResourceName).mkdirAndWriteBytes(mainClassBytes)
     }
 
-    private val OutputFile.internalName
+    internal val OutputFile.internalName
         get() = relativePath.substringBeforeLast(".class")
 
-    private val OutputFile.qualifiedName
+    internal val OutputFile.qualifiedName
         get() = internalName.replace('/', '.')
 }
 

j2k/build.gradle.kts.as34

@@ -0,0 +1,78 @@
+
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    testRuntime(intellijDep())
+
+    compile(project(":kotlin-stdlib"))
+    compile(project(":compiler:frontend"))
+    compile(project(":compiler:frontend.java"))
+    compile(project(":compiler:light-classes"))
+    compile(project(":compiler:util"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+
+    testCompile(project(":idea"))
+    testCompile(projectTests(":idea:idea-test-framework"))
+    testCompile(project(":compiler:light-classes"))
+    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testCompile(commonDep("junit:junit"))
+    testCompileOnly(intellijDep()) { includeJars("platform-api", "platform-impl") }
+    testCompile(project(":idea:idea-native")) { isTransitive = false }
+    testCompile(project(":idea:idea-gradle-native")) { isTransitive = false }
+
+    testRuntime(project(":kotlin-native:kotlin-native-library-reader")) { isTransitive = false }
+    testRuntime(project(":kotlin-native:kotlin-native-utils")) { isTransitive = false }
+    testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false }
+    testRuntime(project(":idea:idea-jvm"))
+    testRuntime(project(":idea:idea-android"))
+    testRuntime(project(":plugins:android-extensions-ide"))
+    testRuntime(project(":sam-with-receiver-ide-plugin"))
+    testRuntime(project(":allopen-ide-plugin"))
+    testRuntime(project(":noarg-ide-plugin"))
+    testRuntime(project(":kotlin-scripting-idea"))
+    testRuntime(project(":kotlinx-serialization-ide-plugin"))
+    testRuntime(intellijPluginDep("properties"))
+    testRuntime(intellijPluginDep("gradle"))
+    testRuntime(intellijPluginDep("Groovy"))
+    testRuntime(intellijPluginDep("coverage"))
+    //testRuntime(intellijPluginDep("maven"))
+    testRuntime(intellijPluginDep("android"))
+    testRuntime(intellijPluginDep("smali"))
+    testRuntime(intellijPluginDep("junit"))
+    testRuntime(intellijPluginDep("testng"))
+    testRuntime(intellijPluginDep("IntelliLang"))
+    testRuntime(intellijPluginDep("testng"))
+    testRuntime(intellijPluginDep("copyright"))
+    testRuntime(intellijPluginDep("properties"))
+    testRuntime(intellijPluginDep("java-i18n"))
+    testRuntime(intellijPluginDep("java-decompiler"))
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" { projectDefault() }
+}
+
+projectTest {
+    dependsOn(":dist")
+    workingDir = rootDir
+}
+
+testsJar()
+
+val testForWebDemo by task<Test> {
+    include("**/*JavaToKotlinConverterForWebDemoTestGenerated*")
+    classpath = testSourceSet.runtimeClasspath
+    workingDir = rootDir
+}
+
+val test: Test by tasks
+test.apply {
+    exclude("**/*JavaToKotlinConverterForWebDemoTestGenerated*")
+    dependsOn(testForWebDemo)
+}
+
+ideaPlugin()

jps-plugin/build.gradle.kts.as34

@@ -0,0 +1,55 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+val compilerModules: Array<String> by rootProject.extra
+
+dependencies {
+    compile(project(":kotlin-build-common"))
+    compile(project(":core:descriptors"))
+    compile(project(":core:descriptors.jvm"))
+    compile(project(":kotlin-compiler-runner"))
+    compile(project(":compiler:daemon-common"))
+    compile(projectRuntimeJar(":kotlin-daemon-client"))
+    compile(project(":compiler:frontend.java"))
+    compile(project(":js:js.frontend"))
+    compile(projectRuntimeJar(":kotlin-preloader"))
+    compile(project(":idea:idea-jps-common"))
+    compileOnly(group = "org.jetbrains", name = "annotations", version = "13.0")
+    compileOnly(intellijDep()) {
+        includeJars("jdom", "trove4j", "jps-model", "openapi", "platform-api", "util", "asm-all", rootProject = rootProject)
+    }
+    compileOnly(intellijDep("jps-standalone")) { includeJars("jps-builders", "jps-builders-6") }
+    testCompileOnly(project(":kotlin-reflect-api"))
+    testCompile(project(":compiler:incremental-compilation-impl"))
+    testCompile(projectTests(":compiler:tests-common"))
+    testCompile(projectTests(":compiler:incremental-compilation-impl"))
+    testCompile(commonDep("junit:junit"))
+    testCompile(project(":kotlin-test:kotlin-test-jvm"))
+    testCompile(projectTests(":kotlin-build-common"))
+    testCompileOnly(intellijDep("jps-standalone")) { includeJars("jps-builders", "jps-builders-6") }
+    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "platform-api", "log4j") }
+    testCompile(intellijDep("jps-build-test"))
+    compilerModules.forEach {
+        testRuntime(project(it))
+    }
+    testRuntime(intellijDep())
+    testRuntime(project(":kotlin-reflect"))
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {
+        /*java.srcDirs("jps-tests/test"
+                     /*, "kannotator-jps-plugin-test/test"*/ // Obsolete
+        )*/
+    }
+}
+
+projectTest {
+    dependsOn(":kotlin-compiler:dist")
+    workingDir = rootDir
+}
+
+testsJar {}

jps-plugin/src/org/jetbrains/kotlin/jps/build/ideaPlatform.kt.as34

@@ -0,0 +1,13 @@
+/*
+ * 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.kotlin.jps.build
+
+import org.jetbrains.jps.incremental.CompileContext
+import org.jetbrains.jps.incremental.messages.CompilerMessage
+
+fun jpsReportInternalBuilderError(context: CompileContext, error: Throwable) {
+    KotlinBuilder.LOG.info(error)
+}

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/groovyTraitsWithFields/build.gradle

@@ -9,7 +9,6 @@ buildscript {
 }
 
 apply plugin: "kotlin"
-apply plugin: "groovy"
 apply plugin: "java"
 
 repositories {
@@ -19,14 +18,7 @@ repositories {
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    compile 'org.codehaus.groovy:groovy-all:2.5.3'
+    compile project(":lib")
-}
-
-compileGroovy.dependsOn = compileGroovy.taskDependencies.values - 'compileJava'
-
-compileKotlin {
-    dependsOn compileGroovy
-    classpath += files(compileGroovy.destinationDir)
 }
 
 compileKotlin {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/groovyTraitsWithFields/lib/build.gradle

@@ -0,0 +1,9 @@
+apply plugin: "groovy"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile 'org.codehaus.groovy:groovy-all:2.5.3'
+}

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/groovyTraitsWithFields/settings.gradle

@@ -0,0 +1 @@
+include ":lib"

libraries/tools/kotlin-stdlib-gen/build.gradle

@@ -11,7 +11,7 @@ dependencies {
 
 compileKotlin {
     kotlinOptions {
-        freeCompilerArgs = ["-version", "-Xnormalize-constructor-calls=enable", "-XXLanguage:-ReleaseCoroutines"]
+        freeCompilerArgs = ["-version"]
     }
 }
 

libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt

@@ -749,7 +749,7 @@ object Filtering : TemplateGroupBase() {
         typeParam("reified R")
         typeParam("C : MutableCollection<in R>")
         inline()
-        receiverAsterisk = true
+        genericStarProjection = true
         returns("C")
         body {
             """
@@ -766,7 +766,7 @@ object Filtering : TemplateGroupBase() {
         typeParam("reified R")
         returns("List<@kotlin.internal.NoInfer R>")
         inline()
-        receiverAsterisk = true
+        genericStarProjection = true
         body {
             """
             return filterIsInstanceTo(ArrayList<R>())
@@ -790,7 +790,7 @@ object Filtering : TemplateGroupBase() {
         include(Iterables, ArraysOfObjects, Sequences)
     } builder {
         doc { "Appends all elements that are instances of specified class to the given [destination]." }
-        receiverAsterisk = true
+        genericStarProjection = true
         typeParam("C : MutableCollection<in R>")
         typeParam("R")
         returns("C")
@@ -808,7 +808,7 @@ object Filtering : TemplateGroupBase() {
         include(Iterables, ArraysOfObjects, Sequences)
     } builder {
         doc { "Returns a list containing all elements that are instances of specified class." }
-        receiverAsterisk= true
+        genericStarProjection = true
         typeParam("R")
         returns("List<R>")
         body {

libraries/tools/kotlin-stdlib-gen/src/templates/Numeric.kt

@@ -13,7 +13,6 @@ object Numeric : TemplateGroupBase() {
         }
     }
 
-    // TODO: use just numericPrimitives
     private val numericPrimitivesDefaultOrder = PrimitiveType.defaultPrimitives intersect PrimitiveType.numericPrimitives
 
     val f_sum = fn("sum()") {

libraries/tools/kotlin-stdlib-gen/src/templates/dsl/MemberBuilder.kt

@@ -60,7 +60,7 @@ class MemberBuilder(
     val typeParams = mutableListOf<String>()
     var primaryTypeParameter: String? = null; private set
     var customReceiver: String? = null; private set
-    var receiverAsterisk: Boolean = false // TODO: rename to genericStarProjection
+    var genericStarProjection: Boolean = false
     var toNullableT: Boolean = false
 
     var returns: String? = null; private set
@@ -246,19 +246,19 @@ class MemberBuilder(
             return answer.toString()
         }
 
-        val isAsteriskOrT = if (receiverAsterisk) "*" else primaryTypeParameter
+        val receiverT = if (genericStarProjection) "*" else primaryTypeParameter
         val self = (when (family) {
-            Iterables -> "Iterable<$isAsteriskOrT>"
+            Iterables -> "Iterable<$receiverT>"
-            Collections -> "Collection<$isAsteriskOrT>"
+            Collections -> "Collection<$receiverT>"
-            Lists -> "List<$isAsteriskOrT>"
+            Lists -> "List<$receiverT>"
             Maps -> "Map<out K, V>"
-            Sets -> "Set<$isAsteriskOrT>"
+            Sets -> "Set<$receiverT>"
-            Sequences -> "Sequence<$isAsteriskOrT>"
+            Sequences -> "Sequence<$receiverT>"
             InvariantArraysOfObjects -> "Array<$primaryTypeParameter>"
-            ArraysOfObjects -> "Array<${isAsteriskOrT.replace(primaryTypeParameter, "out $primaryTypeParameter")}>"
+            ArraysOfObjects -> "Array<${receiverT.replace(primaryTypeParameter, "out $primaryTypeParameter")}>"
             Strings -> "String"
             CharSequences -> "CharSequence"
-            Ranges -> "ClosedRange<$isAsteriskOrT>"
+            Ranges -> "ClosedRange<$receiverT>"
             ArraysOfPrimitives, ArraysOfUnsigned -> primitive?.let { it.name + "Array" } ?: throw IllegalArgumentException("Primitive array should specify primitive type")
             RangesOfPrimitives -> primitive?.let { it.name + "Range" } ?: throw IllegalArgumentException("Primitive range should specify primitive type")
             ProgressionsOfPrimitives -> primitive?.let { it.name + "Progression" } ?: throw IllegalArgumentException("Primitive progression should specify primitive type")

libraries/tools/kotlin-stdlib-gen/src/templates/dsl/TemplateGroups.kt

@@ -5,7 +5,6 @@
 
 package templates
 
-import kotlin.coroutines.experimental.buildSequence
 import kotlin.reflect.KTypeProjection
 import kotlin.reflect.full.createType
 import kotlin.reflect.full.isSubtypeOf
@@ -17,7 +16,7 @@ fun templateGroupOf(vararg templates: MemberTemplate): TemplateGroup = { templat
 
 abstract class TemplateGroupBase : TemplateGroup {
 
-    override fun invoke(): Sequence<MemberTemplate> = buildSequence {
+    override fun invoke(): Sequence<MemberTemplate> = sequence {
         with(this@TemplateGroupBase) {
             this::class.members.filter { it.name.startsWith("f_") }.forEach {
                 require(it.parameters.size == 1) { "Member $it violates naming convention" }

libraries/tools/kotlin-stdlib-gen/src/templates/dsl/Templates.kt

@@ -5,8 +5,6 @@
 
 package templates
 
-import kotlin.coroutines.experimental.*
-
 @DslMarker
 annotation class TemplateDsl
 
@@ -184,7 +182,7 @@ class FamilyPrimitiveMemberDefinition : MemberTemplateDefinition<PrimitiveType?>
         }
     }
 
-    override fun parametrize(): Sequence<Pair<Family, PrimitiveType?>> = buildSequence {
+    override fun parametrize(): Sequence<Pair<Family, PrimitiveType?>> = sequence {
         for ((family, primitives) in familyPrimitives) {
             if (primitives.isEmpty())
                 yield(family to null)

plugins/android-extensions/android-extensions-idea/src/org/jetbrains/kotlin/android/model/impl/AndroidModuleInfoProviderImpl.kt.as34

@@ -0,0 +1,78 @@
+/*
+ * 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.kotlin.android.model.impl
+
+import com.android.builder.model.SourceProvider
+import com.android.tools.idea.gradle.project.GradleProjectInfo
+import com.android.tools.idea.gradle.project.model.AndroidModuleModel
+import com.android.tools.idea.res.ResourceRepositoryManager
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.android.facet.AndroidFacet
+import org.jetbrains.kotlin.android.model.AndroidModuleInfoProvider
+import java.io.File
+
+class AndroidModuleInfoProviderImpl(override val module: Module) : AndroidModuleInfoProvider {
+    private val androidFacet: AndroidFacet?
+        get() = AndroidFacet.getInstance(module)
+
+    private val androidModuleModel: AndroidModuleModel?
+        get() = AndroidModuleModel.get(module)
+
+    override fun isAndroidModule() = androidFacet != null
+    override fun isGradleModule() = GradleProjectInfo.getInstance(module.project).isBuildWithGradle
+
+    override fun getAllResourceDirectories(): List<VirtualFile> {
+        return androidFacet?.allResourceDirectories ?: emptyList()
+    }
+
+    override fun getApplicationPackage() = androidFacet?.manifest?.`package`?.toString()
+
+    override fun getMainSourceProvider(): AndroidModuleInfoProvider.SourceProviderMirror? {
+        return androidFacet?.mainSourceProvider?.let(::SourceProviderMirrorImpl)
+    }
+
+    override fun getApplicationResourceDirectories(createIfNecessary: Boolean): Collection<VirtualFile> {
+        return ResourceRepositoryManager.getOrCreateInstance(module)?.getAppResources(createIfNecessary)?.resourceDirs ?: emptyList()
+    }
+
+    override fun getAllSourceProviders(): List<AndroidModuleInfoProvider.SourceProviderMirror> {
+        val androidModuleModel = this.androidModuleModel ?: return emptyList()
+        return androidModuleModel.allSourceProviders.map(::SourceProviderMirrorImpl)
+    }
+
+    override fun getActiveSourceProviders(): List<AndroidModuleInfoProvider.SourceProviderMirror> {
+        val androidModuleModel = this.androidModuleModel ?: return emptyList()
+        return androidModuleModel.activeSourceProviders.map(::SourceProviderMirrorImpl)
+    }
+
+    override fun getFlavorSourceProviders(): List<AndroidModuleInfoProvider.SourceProviderMirror> {
+        val androidModuleModel = this.androidModuleModel ?: return emptyList()
+
+        val getFlavorSourceProvidersMethod = try {
+            AndroidFacet::class.java.getMethod("getFlavorSourceProviders")
+        } catch (e: NoSuchMethodException) {
+            null
+        }
+
+        return if (getFlavorSourceProvidersMethod != null) {
+            @Suppress("UNCHECKED_CAST")
+            val sourceProviders = getFlavorSourceProvidersMethod.invoke(androidFacet) as? List<SourceProvider>
+            sourceProviders?.map(::SourceProviderMirrorImpl) ?: emptyList()
+        } else {
+            androidModuleModel.flavorSourceProviders.map(::SourceProviderMirrorImpl)
+        }
+    }
+
+    private class SourceProviderMirrorImpl(val sourceProvider: SourceProvider) :
+        AndroidModuleInfoProvider.SourceProviderMirror {
+        override val name: String
+            get() = sourceProvider.name
+
+        override val resDirectories: Collection<File>
+            get() = sourceProvider.resDirectories
+    }
+}

plugins/kapt3/kapt3-idea/src/org/jetbrains/kotlin/kapt/idea/KaptProjectResolverExtension.kt.as34

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.kapt.idea
+
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.externalSystem.model.DataNode
+import com.intellij.openapi.externalSystem.model.ProjectKeys
+import com.intellij.openapi.externalSystem.model.project.*
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.tooling.model.idea.IdeaModule
+import org.jetbrains.kotlin.gradle.AbstractKotlinGradleModelBuilder
+import org.jetbrains.kotlin.idea.framework.GRADLE_SYSTEM_ID
+import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData
+import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
+import org.jetbrains.plugins.gradle.tooling.ErrorMessageBuilder
+import java.io.File
+import java.io.Serializable
+import java.lang.Exception
+import java.lang.reflect.Modifier
+
+interface KaptSourceSetModel : Serializable {
+    val sourceSetName: String
+    val isTest: Boolean
+    val generatedSourcesDir: String
+    val generatedClassesDir: String
+    val generatedKotlinSourcesDir: String
+
+    val generatedSourcesDirFile get() = generatedSourcesDir.takeIf { it.isNotEmpty() }?.let(::File)
+    val generatedClassesDirFile get() = generatedClassesDir.takeIf { it.isNotEmpty() }?.let(::File)
+    val generatedKotlinSourcesDirFile get() = generatedKotlinSourcesDir.takeIf { it.isNotEmpty() }?.let(::File)
+}
+
+class KaptSourceSetModelImpl(
+        override val sourceSetName: String,
+        override val isTest: Boolean,
+        override val generatedSourcesDir: String,
+        override val generatedClassesDir: String,
+        override val generatedKotlinSourcesDir: String
+) : KaptSourceSetModel
+
+interface KaptGradleModel : Serializable {
+    val isEnabled: Boolean
+    val buildDirectory: File
+    val sourceSets: List<KaptSourceSetModel>
+}
+
+class KaptGradleModelImpl(
+        override val isEnabled: Boolean,
+        override val buildDirectory: File,
+        override val sourceSets: List<KaptSourceSetModel>
+) : KaptGradleModel
+
+@Suppress("unused")
+class KaptProjectResolverExtension : AbstractProjectResolverExtension() {
+    private companion object {
+        private val LOG = Logger.getInstance(KaptProjectResolverExtension::class.java)
+    }
+
+    override fun getExtraProjectModelClasses() = setOf(KaptGradleModel::class.java)
+    override fun getToolingExtensionsClasses() = setOf(KaptModelBuilderService::class.java, Unit::class.java)
+
+    override fun populateModuleExtraModels(gradleModule: IdeaModule, ideModule: DataNode<ModuleData>) {
+        val kaptModel = resolverCtx.getExtraProject(gradleModule, KaptGradleModel::class.java) ?: return
+
+        if (kaptModel.isEnabled) {
+            for (sourceSet in kaptModel.sourceSets) {
+                val sourceSetDataNode = ideModule.findGradleSourceSet(sourceSet.sourceSetName) ?: continue
+
+                fun addSourceSet(path: String, type: ExternalSystemSourceType) {
+                    val contentRootData = ContentRootData(GRADLE_SYSTEM_ID, path)
+                    contentRootData.storePath(type, path)
+                    sourceSetDataNode.createChild(ProjectKeys.CONTENT_ROOT, contentRootData)
+                }
+
+                val sourceType = if (sourceSet.isTest) ExternalSystemSourceType.TEST_GENERATED else ExternalSystemSourceType.SOURCE_GENERATED
+                sourceSet.generatedSourcesDirFile?.let { addSourceSet(it.absolutePath, sourceType) }
+                sourceSet.generatedKotlinSourcesDirFile?.let { addSourceSet(it.absolutePath, sourceType) }
+
+                sourceSet.generatedClassesDirFile?.let { generatedClassesDir ->
+                    val libraryData = LibraryData(GRADLE_SYSTEM_ID, "kaptGeneratedClasses")
+                    libraryData.addPath(LibraryPathType.BINARY, generatedClassesDir.absolutePath)
+                    val libraryDependencyData = LibraryDependencyData(sourceSetDataNode.data, libraryData, LibraryLevel.MODULE)
+                    sourceSetDataNode.createChild(ProjectKeys.LIBRARY_DEPENDENCY, libraryDependencyData)
+                }
+            }
+        }
+
+        super.populateModuleExtraModels(gradleModule, ideModule)
+    }
+
+    private fun DataNode<ModuleData>.findGradleSourceSet(sourceSetName: String): DataNode<GradleSourceSetData>? {
+        val moduleName = data.id
+        for (child in children) {
+            val gradleSourceSetData = child.data as? GradleSourceSetData ?: continue
+            if (gradleSourceSetData.id == "$moduleName:$sourceSetName") {
+                @Suppress("UNCHECKED_CAST")
+                return child as DataNode<GradleSourceSetData>?
+            }
+        }
+
+        return null
+    }
+}
+
+class KaptModelBuilderService : AbstractKotlinGradleModelBuilder() {
+    override fun getErrorMessageBuilder(project: Project, e: Exception): ErrorMessageBuilder {
+        return ErrorMessageBuilder.create(project, e, "Gradle import errors")
+                .withDescription("Unable to build kotlin-kapt plugin configuration")
+    }
+
+    override fun canBuild(modelName: String?): Boolean = modelName == KaptGradleModel::class.java.name
+
+    override fun buildAll(modelName: String?, project: Project): Any {
+        val kaptPlugin: Plugin<*>? = project.plugins.findPlugin("kotlin-kapt")
+        val kaptIsEnabled = kaptPlugin != null
+
+        val sourceSets = mutableListOf<KaptSourceSetModel>()
+
+        if (kaptIsEnabled) {
+            project.getAllTasks(false)[project]?.forEach { compileTask ->
+                if (compileTask.javaClass.name !in kotlinCompileTaskClasses) return@forEach
+
+                val sourceSetName = compileTask.getSourceSetName()
+                val isTest = sourceSetName.toLowerCase().endsWith("test")
+
+                val kaptGeneratedSourcesDir = getKaptDirectory("getKaptGeneratedSourcesDir", project, sourceSetName)
+                val kaptGeneratedClassesDir = getKaptDirectory("getKaptGeneratedClassesDir", project, sourceSetName)
+                val kaptGeneratedKotlinSourcesDir = getKaptDirectory("getKaptGeneratedKotlinSourcesDir", project, sourceSetName)
+                sourceSets += KaptSourceSetModelImpl(
+                        sourceSetName, isTest, kaptGeneratedSourcesDir, kaptGeneratedClassesDir, kaptGeneratedKotlinSourcesDir)
+            }
+        }
+
+        return KaptGradleModelImpl(kaptIsEnabled, project.buildDir, sourceSets)
+    }
+
+    private fun getKaptDirectory(funName: String, project: Project, sourceSetName: String): String {
+        val kotlinKaptPlugin = project.plugins.findPlugin("kotlin-kapt") ?: return ""
+
+        val targetMethod = kotlinKaptPlugin::class.java.methods.firstOrNull {
+            Modifier.isStatic(it.modifiers) && it.name == funName && it.parameterCount == 2
+        } ?: return ""
+
+        return (targetMethod(null, project, sourceSetName) as? File)?.absolutePath ?: ""
+    }
+}

prepare/compiler/build.gradle.kts.as34

@@ -0,0 +1,155 @@
+import java.io.File
+import proguard.gradle.ProGuardTask
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.artifacts.maven.Conf2ScopeMappingContainer.COMPILE
+import org.gradle.api.file.DuplicatesStrategy
+
+description = "Kotlin Compiler"
+
+plugins {
+    // HACK: java plugin makes idea import dependencies on this project as source (with empty sources however),
+    // this prevents reindexing of kotlin-compiler.jar after build on every change in compiler modules
+    java
+}
+
+// You can run Gradle with "-Pkotlin.build.proguard=true" to enable ProGuard run on kotlin-compiler.jar (on TeamCity, ProGuard always runs)
+val shrink =
+    findProperty("kotlin.build.proguard")?.toString()?.toBoolean()
+    ?: hasProperty("teamcity")
+
+val compilerManifestClassPath = "kotlin-stdlib.jar kotlin-reflect.jar kotlin-script-runtime.jar"
+
+val fatJarContents by configurations.creating
+
+val fatJarContentsStripMetadata by configurations.creating
+val fatJarContentsStripServices by configurations.creating
+val fatSourcesJarContents by configurations.creating
+val fatJar by configurations.creating
+val compilerJar by configurations.creating
+val runtimeJar by configurations.creating
+val compile by configurations  // maven plugin writes pom compile scope from compile configuration by default
+val libraries by configurations.creating {
+    extendsFrom(compile)
+}
+
+val default by configurations
+default.extendsFrom(runtimeJar)
+
+val compilerBaseName = name
+
+val outputJar = fileFrom(buildDir, "libs", "$compilerBaseName.jar")
+
+val compilerModules: Array<String> by rootProject.extra
+
+compilerModules.forEach { evaluationDependsOn(it) }
+
+val compiledModulesSources = compilerModules.map {
+    project(it).mainSourceSet.allSource
+}
+
+dependencies {
+    compile(project(":kotlin-stdlib"))
+    compile(project(":kotlin-script-runtime"))
+    compile(project(":kotlin-reflect"))
+
+    libraries(project(":kotlin-annotations-jvm"))
+    libraries(
+        files(
+            firstFromJavaHomeThatExists("jre/lib/rt.jar", "../Classes/classes.jar"),
+            firstFromJavaHomeThatExists("jre/lib/jsse.jar", "../Classes/jsse.jar"),
+            toolsJar()
+        )
+    )
+
+    compilerModules.forEach {
+        fatJarContents(project(it)) { isTransitive = false }
+    }
+
+    compiledModulesSources.forEach {
+        fatSourcesJarContents(it)
+    }
+
+    fatJarContents(project(":core:builtins", configuration = "builtins"))
+    fatJarContents(commonDep("javax.inject"))
+    fatJarContents(commonDep("org.jline", "jline"))
+    fatJarContents(commonDep("org.fusesource.jansi", "jansi"))
+    fatJarContents(protobufFull())
+    fatJarContents(commonDep("com.google.code.findbugs", "jsr305"))
+    fatJarContents(commonDep("io.javaslang", "javaslang"))
+    fatJarContents(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
+
+    fatJarContents(intellijCoreDep()) { includeJars("intellij-core") }
+    fatJarContents(intellijDep()) { includeIntellijCoreJarDependencies(project, { !(it.startsWith("jdom") || it.startsWith("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()
+
+val packCompiler by task<ShadowJar> {
+    configurations = listOf(fatJar)
+    setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
+    destinationDir = File(buildDir, "libs")
+
+    setupPublicJar(compilerBaseName, "before-proguard")
+
+    from(fatJarContents)
+
+    dependsOn(fatJarContentsStripServices)
+    from {
+        fatJarContentsStripServices.files.map {
+            zipTree(it).matching { exclude("META-INF/services/**") }
+        }
+    }
+
+    dependsOn(fatJarContentsStripMetadata)
+    from {
+        fatJarContentsStripMetadata.files.map {
+            zipTree(it).matching { exclude("META-INF/jb/**", "META-INF/LICENSE") }
+        }
+    }
+
+    manifest.attributes["Class-Path"] = compilerManifestClassPath
+    manifest.attributes["Main-Class"] = "org.jetbrains.kotlin.cli.jvm.K2JVMCompiler"
+}
+
+val proguard by task<ProGuardTask> {
+    dependsOn(packCompiler)
+    configuration("$rootDir/compiler/compiler.pro")
+
+    val outputJar = fileFrom(buildDir, "libs", "$compilerBaseName-after-proguard.jar")
+
+    inputs.files(packCompiler.outputs.files.singleFile)
+    outputs.file(outputJar)
+
+    // TODO: remove after dropping compatibility with ant build
+    doFirst {
+        System.setProperty("kotlin-compiler-jar-before-shrink", packCompiler.outputs.files.singleFile.canonicalPath)
+        System.setProperty("kotlin-compiler-jar", outputJar.canonicalPath)
+    }
+
+    libraryjars(mapOf("filter" to "!META-INF/versions/**"), libraries)
+
+    printconfiguration("$buildDir/compiler.pro.dump")
+}
+
+val pack = if (shrink) proguard else packCompiler
+
+dist(
+    targetName = "$compilerBaseName.jar",
+    fromTask = pack
+)
+
+runtimeJarArtifactBy(pack, pack.outputs.files.singleFile) {
+    name = compilerBaseName
+    classifier = ""
+}
+
+sourcesJar {
+    from(fatSourcesJarContents)
+}
+
+javadocJar()
+
+publish()

prepare/jps-plugin/build.gradle.kts.as34

@@ -0,0 +1,37 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+description = "Kotlin JPS plugin"
+
+plugins {
+    `java-base`
+    id("pill-configurable")
+}
+
+val projectsToShadow = listOf(
+        ":kotlin-build-common",
+        ":compiler:cli-common",
+        ":kotlin-compiler-runner",
+        ":compiler:daemon-common",
+        ":core:descriptors",
+        ":core:descriptors.jvm",
+        ":idea:idea-jps-common",
+        ":jps-plugin",
+        ":kotlin-preloader",
+        ":compiler:util",
+        ":core:util.runtime")
+
+dependencies {
+    projectsToShadow.forEach {
+        embeddedComponents(project(it)) { isTransitive = false }
+    }
+    embeddedComponents(projectRuntimeJar(":kotlin-daemon-client"))
+}
+
+runtimeJar<ShadowJar>(task<ShadowJar>("jar")) {
+    manifest.attributes.put("Main-Class", "org.jetbrains.kotlin.runner.Main")
+    manifest.attributes.put("Class-Path", "kotlin-stdlib.jar")
+    from(files("$rootDir/resources/kotlinManifest.properties"))
+    fromEmbeddedComponents()
+}
+
+ideaPlugin("lib/jps")

versions.gradle.kts.as34

@@ -1,8 +1,8 @@
-extra["versions.intellijSdk"] = "182.4505.22"
+extra["versions.intellijSdk"] = "183.2153.8"
 extra["versions.androidBuildTools"] = "r23.0.1"
 extra["versions.idea.NodeJS"] = "181.3494.12"
-extra["versions.androidStudioRelease"] = "3.4.0.0"
+extra["versions.androidStudioRelease"] = "3.4.0.1"
-extra["versions.androidStudioBuild"] = "182.5070326"
+extra["versions.androidStudioBuild"] = "183.5081642"
 
 val gradleJars = listOf(
     "gradle-api",
@@ -153,17 +153,17 @@ when (platform) {
         extra["ignore.jar.lombok-ast"] = true
     }
     "AS34" -> {
-        extra["versions.jar.guava"] = "23.6-jre"
+        extra["versions.jar.guava"] = "25.1-jre"
         extra["versions.jar.groovy-all"] = "2.4.15"
         extra["versions.jar.lombok-ast"] = "0.2.3"
         extra["versions.jar.swingx-core"] = "1.6.2-2"
         extra["versions.jar.kxml2"] = "2.3.0"
-        extra["versions.jar.streamex"] = "0.6.5"
+        extra["versions.jar.streamex"] = "0.6.7"
         extra["versions.jar.gson"] = "2.8.4"
         extra["versions.jar.oro"] = "2.0.8"
         extra["versions.jar.picocontainer"] = "1.2"
         for (jar in gradleJars) {
-            extra["versions.jar.$jar"] = "4.4"
+            extra["versions.jar.$jar"] = "4.5.1"
         }
 
         extra["ignore.jar.snappy-in-java"] = true