Disable cleaner tests

This commit is required for FP test to pass,
because FP test does not see module -Xopt-in=... flags.

.bunch

@@ -1,3 +1,2 @@
-202
-203_202
-as42
+203
+202

.idea/runConfigurations/IDEA.xml

@@ -1,20 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA" type="GradleRunConfiguration" factoryName="Gradle" singleton="true" folderName="IDEA">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runIde" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <method />
-  </configuration>
-</component>

.idea/runConfigurations/IDEA_Ultimate.xml

@@ -1,20 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA Ultimate" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="-P intellijUltimateEnabled" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runUltimate" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <method />
-  </configuration>
-</component>

.idea/runConfigurations/IDEA_Ultimate__No_ProcessCanceledException__.xml

@@ -1,20 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA Ultimate (No ProcessCanceledException) " type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="-PnoPCE" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runUltimate" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <method />
-  </configuration>
-</component>

.idea/runConfigurations/IDEA__No_ProcessCanceledException_.xml

@@ -1,20 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA (No ProcessCanceledException)" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="-PnoPCE" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runIde" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <method />
-  </configuration>
-</component>

.idea/runConfigurations/IDEA__Not_Internal_.xml

@@ -1,19 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="IDEA (Not Internal)" type="GradleRunConfiguration" factoryName="Gradle" folderName="IDEA">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="-Pidea.is.internal=false" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runIde" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-  </configuration>
-</component>

ReadMe.md

@@ -56,7 +56,7 @@ Alternatively, it is still possible to only provide required JDKs via environmen
 from environmental variables - disable Gradle toolchain auto-detection by passing `-Porg.gradle.java.installations.auto-detect=false` option
 (or put it into `$GRADLE_USER_HOME/gradle.properties`).
 
-For local development, if you're not working on bytecode generation or the standard library, it's OK to avoid installing JDK 1.6 and JDK 1.7.
+For local development, if you're not working on the standard library, it's OK to avoid installing JDK 1.6 and JDK 1.7.
 Add `kotlin.build.isObsoleteJdkOverrideEnabled=true` to the `local.properties` file, so build will only use JDK 1.8+. Note, that in this
 case, build will have Gradle remote build cache misses for some tasks. 
 

build.gradle.kts

@@ -161,11 +161,7 @@ extra["intellijSeparateSdks"] = intellijSeparateSdks
 
 extra["IntellijCoreDependencies"] =
     listOf(
-        when {
-            Platform[203].orHigher() -> "asm-all-9.0"
-            Platform[202].orHigher() -> "asm-all-8.0.1"
-            else -> "asm-all-7.0.1"
-        },
+        "asm-all-9.0",
         "guava",
         "jdom",
         "jna",
@@ -481,7 +477,7 @@ allprojects {
         }
     }
 
-    if (!kotlinBuildProperties.isInJpsBuildIdeaSync && !kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
+    if (!kotlinBuildProperties.disableWerror) {
         // For compiler and stdlib, allWarningsAsErrors is configured in the corresponding "root" projects
         // (compiler/build.gradle.kts and libraries/commonConfiguration.gradle).
         val projectsWithWarningsAsErrors = listOf("core", "plugins").map { File(it).absoluteFile }
@@ -734,14 +730,6 @@ tasks {
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
         dependsOn(":kotlin-main-kts-test:testWithIr")
-
-        if (kotlinBuildProperties.getOrNull("attachedIntellijVersion") == null &&
-            !kotlinBuildProperties.getBoolean("disableKotlinPluginModules", false)
-        ) {
-            dependsOn(":kotlin-scripting-ide-services-test:test")
-            dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
-        }
-
         dependsOn(":kotlin-scripting-js-test:test")
     }
 

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

@@ -19,7 +19,8 @@ val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.bui
 
 val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)
 
-val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
+val KotlinBuildProperties.disableWerror: Boolean
+    get() = getBoolean("kotlin.build.disable.werror") || useFir || isInJpsBuildIdeaSync || getBoolean("test.progressive.mode")
 
 val KotlinBuildProperties.isObsoleteJdkOverrideEnabled: Boolean
     get() = getBoolean("kotlin.build.isObsoleteJdkOverrideEnabled", false)

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P202, P203;
+    P203;
 
     val version: Int = name.drop(1).toInt()
 
@@ -43,10 +43,7 @@ enum class Platform : CompatibilityPredicate {
 }
 
 enum class Ide(val platform: Platform) : CompatibilityPredicate {
-    IJ202(Platform.P202),
-    IJ203(Platform.P203),
-
-    AS42(Platform.P202);
+    IJ203(Platform.P203);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

buildSrc/src/main/kotlin/LibrariesCommon.kt

@@ -61,7 +61,7 @@ private class Java9AdditionalArgumentsProvider(
 }
 
 fun Project.disableDeprecatedJvmTargetWarning() {
-    if (!kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
+    if (!kotlinBuildProperties.disableWerror) {
         val tasksWithWarnings: List<String> by rootProject.extra
         tasks.withType<KotlinCompile>().configureEach {
             if (!tasksWithWarnings.contains(path)) {
@@ -72,4 +72,4 @@ fun Project.disableDeprecatedJvmTargetWarning() {
             }
         }
     }
-}
+}

buildSrc/src/main/kotlin/localDependencies.kt

@@ -17,16 +17,11 @@
 // usages in build scripts are not tracked properly
 @file:Suppress("unused")
 
-import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
-import org.gradle.api.tasks.JavaExec
-import org.gradle.api.tasks.TaskProvider
-import org.gradle.kotlin.dsl.DependencyHandlerScope
 import org.gradle.kotlin.dsl.extra
-import org.gradle.kotlin.dsl.register
 import java.io.File
 
 private fun Project.kotlinBuildLocalDependenciesDir(): File =
@@ -146,70 +141,4 @@ fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFi
         rootProject = project.rootProject
     )
 
-fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
-
-fun DependencyHandlerScope.excludeInAndroidStudio(rootProject: Project, block: DependencyHandlerScope.() -> Unit) {
-    if (!rootProject.extra.has("versions.androidStudioRelease")) {
-        block()
-    }
-}
-
-fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File, body: JavaExec.() -> Unit): TaskProvider<JavaExec> {
-
-    return tasks.register<JavaExec>(name) {
-        val ideaSandboxConfigDir = File(ideaSandboxDir, "config")
-
-        classpath = mainSourceSet.runtimeClasspath
-
-        mainClass.set("com.intellij.idea.Main")
-
-        workingDir = File(intellijRootDir(), "bin")
-
-        jvmArgs(
-            "-Xmx1250m",
-            "-XX:ReservedCodeCacheSize=240m",
-            "-XX:+HeapDumpOnOutOfMemoryError",
-            "-ea",
-            "-Didea.debug.mode=true",
-            "-Didea.system.path=$ideaSandboxDir",
-            "-Didea.config.path=$ideaSandboxConfigDir",
-            "-Didea.tooling.debug=true",
-            "-Dfus.internal.test.mode=true",
-            "-Dapple.laf.useScreenMenuBar=true",
-            "-Dapple.awt.graphics.UseQuartz=true",
-            "-Dsun.io.useCanonCaches=false",
-            "-Dplugin.path=${ideaPluginDir.absolutePath}"
-        )
-
-        jvmArgs("-Didea.platform.prefix=Idea")
-
-        if (rootProject.findProperty("versions.androidStudioRelease") != null) {
-            jvmArgs("-Didea.platform.prefix=AndroidStudio")
-        }
-
-        if (project.hasProperty("noPCE")) {
-            jvmArgs("-Didea.ProcessCanceledException=disabled")
-        }
-
-        jvmArgs("-Didea.is.internal=${project.findProperty("idea.is.internal") ?: true}")
-
-        project.findProperty("idea.args")?.let { arguments ->
-            jvmArgs(arguments.toString().split(" "))
-        }
-
-        args()
-
-        doFirst {
-            val disabledPluginsFile = File(ideaSandboxConfigDir, "disabled_plugins.txt")
-            val disabledPluginsContents = disabledPluginsFile.takeIf { it.isFile }?.readLines()
-            val filteredContents = disabledPluginsContents?.filterNot { it.contains("org.jetbrains.kotlin") }
-            if (filteredContents != null && filteredContents.size != disabledPluginsContents.size) {
-                with(disabledPluginsFile.printWriter()) {
-                    filteredContents.forEach(this::println)
-                }
-            }
-        }
-
-        body()
-    }
-}
+fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/processUninitializedStores.kt

@@ -73,8 +73,8 @@ import kotlin.math.max
  *   - restore constructor arguments
  */
 class UninitializedStoresProcessor(
-        private val methodNode: MethodNode,
-        private val shouldPreserveClassInitialization: Boolean
+    private val methodNode: MethodNode,
+    private val shouldPreserveClassInitialization: Boolean
 ) {
     // <init> method is "special", because it will invoke <init> from this class or from a base class for #0
     //
@@ -87,10 +87,10 @@ class UninitializedStoresProcessor(
     fun run() {
         val interpreter = UninitializedNewValueMarkerInterpreter(methodNode.instructions)
 
-        val frames = CustomFramesMethodAnalyzer(
-                "fake", methodNode, interpreter,
-                this::UninitializedNewValueFrame
-        ).analyze()
+        if (methodNode.instructions.toArray().none { it.opcode == Opcodes.NEW })
+            return
+
+        val frames = CustomFramesMethodAnalyzer("fake", methodNode, interpreter, this::UninitializedNewValueFrame).analyze()
 
         interpreter.analyzePopInstructions(frames)
 
@@ -115,12 +115,12 @@ class UninitializedStoresProcessor(
                     //      POP
                     val typeNameForClass = newInsn.desc.replace('/', '.')
                     insertBefore(newInsn, LdcInsnNode(typeNameForClass))
-                    insertBefore(newInsn, MethodInsnNode(
-                            Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false
-                    ))
+                    insertBefore(
+                        newInsn,
+                        MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
+                    )
                     set(newInsn, InsnNode(Opcodes.POP))
-                }
-                else {
+                } else {
                     remove(newInsn)
                 }
             }
@@ -138,10 +138,7 @@ class UninitializedStoresProcessor(
             }
             methodNode.maxLocals = max(methodNode.maxLocals, nextVarIndex)
 
-            methodNode.instructions.insertBefore(insn, insnListOf(
-                    TypeInsnNode(Opcodes.NEW, newInsn.desc),
-                    InsnNode(Opcodes.DUP)
-            ))
+            methodNode.instructions.insertBefore(insn, insnListOf(TypeInsnNode(Opcodes.NEW, newInsn.desc), InsnNode(Opcodes.DUP)))
 
             for (type in storedTypes.reversed()) {
                 nextVarIndex -= type.size
@@ -174,11 +171,11 @@ class UninitializedStoresProcessor(
 
         assert(insn.opcode == Opcodes.INVOKESPECIAL) { "Expected opcode Opcodes.INVOKESPECIAL for <init>, but ${insn.opcode} found" }
         val paramsCountIncludingReceiver = Type.getArgumentTypes((insn as MethodInsnNode).desc).size + 1
-        val newValue = peek(paramsCountIncludingReceiver) as? UninitializedNewValue ?:
-                       if (isInSpecialMethod)
-                           return null
-                       else
-                           error("Expected value generated with NEW")
+        val newValue = peek(paramsCountIncludingReceiver) as? UninitializedNewValue
+            ?: if (isInSpecialMethod)
+                return null
+            else
+                error("Expected value generated with NEW")
 
         assert(peek(paramsCountIncludingReceiver - 1) is UninitializedNewValue) {
             "Next value after NEW should be one generated by DUP"
@@ -188,8 +185,8 @@ class UninitializedStoresProcessor(
     }
 
     private class UninitializedNewValue(
-            val newInsn: TypeInsnNode,
-            val internalName: String
+        val newInsn: TypeInsnNode,
+        val internalName: String
     ) : StrictBasicValue(Type.getObjectType(internalName)) {
         override fun toString() = "UninitializedNewValue(internalName='$internalName')"
     }
@@ -236,7 +233,8 @@ class UninitializedStoresProcessor(
 
         private fun checkUninitializedObjectCopy(newInsn: TypeInsnNode, usageInsn: AbstractInsnNode) {
             when (usageInsn.opcode) {
-                Opcodes.DUP, Opcodes.ASTORE, Opcodes.ALOAD -> {}
+                Opcodes.DUP, Opcodes.ASTORE, Opcodes.ALOAD -> {
+                }
                 else -> error("Unexpected copy instruction for ${newInsn.debugText}: ${usageInsn.debugText}")
             }
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt

@@ -187,6 +187,9 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                 val splitBy = SimpleInterval(start.info as LabelNode, extension.finallyIntervalEnd)
                 processor.tryBlocksMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
                 processor.localVarsMetaInfo.splitAndRemoveCurrentIntervals(splitBy, true)
+                finallyNode.localVariables.forEach {
+                    processor.localVarsMetaInfo.addNewInterval(LocalVarNodeWrapper(it))
+                }
             }
 
             curInstr = curInstr.next

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt

@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.codegen.optimization.common.ControlFlowGraph
 import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
-import org.jetbrains.kotlin.codegen.optimization.fixStack.peek
-import org.jetbrains.kotlin.codegen.optimization.fixStack.top
+import org.jetbrains.kotlin.codegen.optimization.fixStack.*
+import org.jetbrains.kotlin.codegen.optimization.fixStack.FastStackAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.config.LanguageFeature
@@ -36,8 +36,6 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.commons.LocalVariablesSorter
 import org.jetbrains.org.objectweb.asm.commons.MethodRemapper
 import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.util.Printer
 import java.util.*
@@ -57,8 +55,10 @@ class MethodInliner(
 ) {
     private val languageVersionSettings = inliningContext.state.languageVersionSettings
     private val invokeCalls = ArrayList<InvokeCall>()
+
     //keeps order
     private val transformations = ArrayList<TransformationInfo>()
+
     //current state
     private val currentTypeMapping = HashMap<String, String?>()
     private val result = InlineResult.create()
@@ -273,7 +273,8 @@ class MethodInliner(
 
                     val varRemapper = LocalVarRemapper(lambdaParameters, valueParamShift)
                     //TODO add skipped this and receiver
-                    val lambdaResult = inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
+                    val lambdaResult =
+                        inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
                     result.mergeWithNotChangeInfo(lambdaResult)
                     result.reifiedTypeParametersUsages.mergeAll(lambdaResult.reifiedTypeParametersUsages)
                     result.reifiedTypeParametersUsages.mergeAll(info.reifiedTypeParametersUsages)
@@ -303,7 +304,7 @@ class MethodInliner(
                             } else capturedParamDesc
                             visitFieldInsn(
                                 Opcodes.GETSTATIC, realDesc.containingLambdaName,
-                                FieldRemapper.foldName(realDesc.fieldName), realDesc.type.descriptor
+                                foldName(realDesc.fieldName), realDesc.type.descriptor
                             )
                         }
                         super.visitMethodInsn(opcode, info.newClassName, name, info.newConstructorDescriptor, itf)
@@ -441,7 +442,7 @@ class MethodInliner(
                         else -> ""
                     }
 
-                    val varName = if (!varSuffix.isEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
+                    val varName = if (varSuffix.isNotEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
                     super.visitLocalVariable(varName + varSuffix, desc, signature, start, end, getNewIndex(index))
                 }
             }
@@ -533,33 +534,37 @@ class MethodInliner(
                     cur.opcode == Opcodes.GETSTATIC -> {
                         val fieldInsnNode = cur as FieldInsnNode?
                         val className = fieldInsnNode!!.owner
-                        if (isAnonymousSingletonLoad(className, fieldInsnNode.name)) {
-                            recordTransformation(
-                                AnonymousObjectTransformationInfo(
-                                    className, awaitClassReification, isAlreadyRegenerated(className), true,
-                                    inliningContext.nameGenerator
+                        when {
+                            isAnonymousSingletonLoad(className, fieldInsnNode.name) -> {
+                                recordTransformation(
+                                    AnonymousObjectTransformationInfo(
+                                        className, awaitClassReification, isAlreadyRegenerated(className), true,
+                                        inliningContext.nameGenerator
+                                    )
                                 )
-                            )
-                            awaitClassReification = false
-                        } else if (isWhenMappingAccess(className, fieldInsnNode.name)) {
-                            recordTransformation(
-                                WhenMappingTransformationInfo(
-                                    className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
+                                awaitClassReification = false
+                            }
+                            isWhenMappingAccess(className, fieldInsnNode.name) -> {
+                                recordTransformation(
+                                    WhenMappingTransformationInfo(
+                                        className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
+                                    )
                                 )
-                            )
-                        } else if (fieldInsnNode.isCheckAssertionsStatus()) {
-                            fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
-                            when {
-                                // In inline function itself:
-                                inliningContext.parent == null -> inliningContext
-                                // In method of regenerated object - field should already exist:
-                                inliningContext.parent is RegeneratedClassContext -> inliningContext.parent
-                                // In lambda inlined into the root function:
-                                inliningContext.parent.parent == null -> inliningContext.parent
-                                // In lambda inlined into a method of a regenerated object:
-                                else -> inliningContext.parent.parent as? RegeneratedClassContext
-                                    ?: throw AssertionError("couldn't find class for \$assertionsDisabled (context = $inliningContext)")
-                            }.generateAssertField = true
+                            }
+                            fieldInsnNode.isCheckAssertionsStatus() -> {
+                                fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
+                                when {
+                                    // In inline function itself:
+                                    inliningContext.parent == null -> inliningContext
+                                    // In method of regenerated object - field should already exist:
+                                    inliningContext.parent is RegeneratedClassContext -> inliningContext.parent
+                                    // In lambda inlined into the root function:
+                                    inliningContext.parent.parent == null -> inliningContext.parent
+                                    // In lambda inlined into a method of a regenerated object:
+                                    else -> inliningContext.parent.parent as? RegeneratedClassContext
+                                        ?: throw AssertionError("couldn't find class for \$assertionsDisabled (context = $inliningContext)")
+                                }.generateAssertField = true
+                            }
                         }
                     }
 
@@ -588,7 +593,7 @@ class MethodInliner(
                                 assert(lambdaInfo.lambdaClassType.internalName == nodeRemapper.originalLambdaInternalName) {
                                     "Wrong bytecode template for contract template: ${lambdaInfo.lambdaClassType.internalName} != ${nodeRemapper.originalLambdaInternalName}"
                                 }
-                                fieldInsn.name = FieldRemapper.foldName(fieldInsn.name)
+                                fieldInsn.name = foldName(fieldInsn.name)
                                 fieldInsn.opcode = Opcodes.PUTSTATIC
                                 toDelete.addAll(stackTransformations)
                             }
@@ -742,7 +747,7 @@ class MethodInliner(
             ApiVersionCallsPreprocessingMethodTransformer(targetApiVersion).transform("fake", node)
         }
 
-        val frames = analyzeMethodNodeWithInterpreter(node, BasicInterpreter())
+        val frames = FastStackAnalyzer("<fake>", node, FixStackInterpreter()).analyze()
 
         val localReturnsNormalizer = LocalReturnsNormalizer()
 
@@ -831,9 +836,9 @@ class MethodInliner(
         if (inliningContext.isInliningLambda && inliningContext.lambdaInfo is IrExpressionLambda && !inliningContext.parent!!.isInliningLambda) {
             val capturedVars = inliningContext.lambdaInfo.capturedVars
             var offset = parameters.realParametersSizeOnStack
-            val map = capturedVars.map {
+            val map = capturedVars.associate {
                 offset to it.also { offset += it.type.size }
-            }.toMap()
+            }
 
             var cur: AbstractInsnNode? = node.instructions.first
             while (cur != null) {
@@ -878,6 +883,7 @@ class MethodInliner(
         }
     }
 
+    @Suppress("SameParameterValue")
     private fun wrapException(originalException: Throwable, node: MethodNode, errorSuffix: String): RuntimeException {
         return if (originalException is InlineException) {
             InlineException("$errorPrefix: $errorSuffix", originalException)
@@ -890,7 +896,7 @@ class MethodInliner(
         private class LocalReturn(
             private val returnInsn: AbstractInsnNode,
             private val insertBeforeInsn: AbstractInsnNode,
-            private val frame: Frame<BasicValue>
+            private val frame: Frame<FixStackValue>
         ) {
 
             fun transform(insnList: InsnList, returnVariableIndex: Int) {
@@ -901,22 +907,19 @@ class MethodInliner(
                 if (expectedStackSize == actualStackSize) return
 
                 var stackSize = actualStackSize
+                val topValue = frame.getStack(stackSize - 1)
                 if (isReturnWithValue) {
-                    val storeOpcode = Opcodes.ISTORE + returnInsn.opcode - Opcodes.IRETURN
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(storeOpcode, returnVariableIndex))
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.storeOpcode, returnVariableIndex))
                     stackSize--
                 }
 
                 while (stackSize > 0) {
-                    val stackElementSize = frame.getStack(stackSize - 1).size
-                    val popOpcode = if (stackElementSize == 1) Opcodes.POP else Opcodes.POP2
-                    insnList.insertBefore(insertBeforeInsn, InsnNode(popOpcode))
+                    insnList.insertBefore(insertBeforeInsn, InsnNode(frame.getStack(stackSize - 1).popOpcode))
                     stackSize--
                 }
 
                 if (isReturnWithValue) {
-                    val loadOpcode = Opcodes.ILOAD + returnInsn.opcode - Opcodes.IRETURN
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(loadOpcode, returnVariableIndex))
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.loadOpcode, returnVariableIndex))
                 }
             }
         }
@@ -926,10 +929,10 @@ class MethodInliner(
         private var returnVariableSize = 0
         private var returnOpcode = -1
 
-        internal fun addLocalReturnToTransform(
+        fun addLocalReturnToTransform(
             returnInsn: AbstractInsnNode,
             insertBeforeInsn: AbstractInsnNode,
-            sourceValueFrame: Frame<BasicValue>
+            sourceValueFrame: Frame<FixStackValue>
         ) {
             assert(isReturnOpcode(returnInsn.opcode)) { "return instruction expected" }
             assert(returnOpcode < 0 || returnOpcode == returnInsn.opcode) { "Return op should be " + Printer.OPCODES[returnOpcode] + ", got " + Printer.OPCODES[returnInsn.opcode] }
@@ -938,11 +941,7 @@ class MethodInliner(
             localReturns.add(LocalReturn(returnInsn, insertBeforeInsn, sourceValueFrame))
 
             if (returnInsn.opcode != Opcodes.RETURN) {
-                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) {
-                    2
-                } else {
-                    1
-                }
+                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) 2 else 1
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -12,12 +13,12 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.TYPEOF_SUSPEND_TYPE
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.*
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.Type
@@ -72,6 +73,14 @@ class PsiInlineIntrinsicsSupport(
 
     override fun toKotlinType(type: KotlinType): KotlinType = type
 
+    override fun checkAnnotatedType(type: KotlinType) {
+        if (type.annotations.hasAnnotation(StandardNames.FqNames.extensionFunctionType)) {
+            state.diagnostics.report(TYPEOF_EXTENSION_FUNCTION_TYPE.on(reportErrorsOn))
+        } else if (type.annotations.any { it.fqName != JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION }) {
+            state.diagnostics.report(TYPEOF_ANNOTATED_TYPE.on(reportErrorsOn))
+        }
+    }
+
     override fun reportSuspendTypeUnsupported() {
         state.diagnostics.report(TYPEOF_SUSPEND_TYPE.on(reportErrorsOn))
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt

@@ -75,6 +75,7 @@ class ReifiedTypeInliner<KT : KotlinTypeMarker>(
 
         fun toKotlinType(type: KT): KotlinType
 
+        fun checkAnnotatedType(type: KT)
         fun reportSuspendTypeUnsupported()
         fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name)
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt

@@ -95,6 +95,8 @@ fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeOf(
         intrinsicsSupport.reportSuspendTypeUnsupported()
     }
 
+    intrinsicsSupport.checkAnnotatedType(type)
+
     if (intrinsicsSupport.state.stableTypeOf) {
         if (intrinsicsSupport.isMutableCollectionType(type)) {
             v.invokestatic(REFLECTION, "mutableCollectionType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt

@@ -73,24 +73,29 @@ class OptimizationMethodVisitor(
 
     companion object {
         private const val MEMORY_LIMIT_BY_METHOD_MB = 50
-        private const val TRY_CATCH_BLOCKS_LIMIT = 512
+        private const val TRY_CATCH_BLOCKS_SOFT_LIMIT = 16
 
         fun canBeOptimized(node: MethodNode): Boolean {
-            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_LIMIT)
-                return false
-
-            val totalFramesSizeMb = node.instructions.size() * (node.maxLocals + node.maxStack) / (1024 * 1024)
-            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
+            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_SOFT_LIMIT) {
+                if (getTotalFramesWeight(getTotalTcbSize(node), node) > MEMORY_LIMIT_BY_METHOD_MB)
+                    return false
+            }
+            return getTotalFramesWeight(node.instructions.size(), node) < MEMORY_LIMIT_BY_METHOD_MB
         }
 
         fun canBeOptimizedUsingSourceInterpreter(node: MethodNode): Boolean {
-            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_LIMIT)
-                return false
-
-            val frameSize = node.maxLocals + node.maxStack
-            val methodSize = node.instructions.size().toLong()
-            val totalFramesSizeMb = methodSize * methodSize * frameSize / (1024 * 1024)
-            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
+            val methodSize = node.instructions.size()
+            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_SOFT_LIMIT) {
+                if (getTotalFramesWeight(getTotalTcbSize(node) * methodSize, node) > MEMORY_LIMIT_BY_METHOD_MB)
+                    return false
+            }
+            return getTotalFramesWeight(methodSize * methodSize, node) < MEMORY_LIMIT_BY_METHOD_MB
         }
+
+        private fun getTotalFramesWeight(size: Int, node: MethodNode) =
+            size.toLong() * (node.maxLocals + node.maxStack) / (1024 * 1024)
+
+        private fun getTotalTcbSize(node: MethodNode) =
+            node.tryCatchBlocks.sumOf { node.instructions.indexOf(it.end) - node.instructions.indexOf(it.start) }
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt

@@ -56,7 +56,7 @@ class TaintedBoxedValue(private val boxedBasicValue: CleanBoxedValue) : BoxedBas
 
 
 class BoxedValueDescriptor(
-    private val boxedType: Type,
+    boxedType: Type,
     val boxingInsn: AbstractInsnNode,
     val progressionIterator: ProgressionIteratorBasicValue?,
     val generationState: GenerationState

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt

@@ -38,6 +38,10 @@ import java.util.*
 class RedundantBoxingMethodTransformer(private val generationState: GenerationState) : MethodTransformer() {
 
     override fun transform(internalClassName: String, node: MethodNode) {
+        val insns = node.instructions.toArray()
+        if (insns.none { it.isBoxing(generationState) || it.isMethodInsnWith(Opcodes.INVOKEINTERFACE) { name == "next" } })
+            return
+
         val interpreter = RedundantBoxingInterpreter(node.instructions, generationState)
         val frames = analyze(internalClassName, node, interpreter)
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FastMethodAnalyzer.kt

@@ -45,7 +45,7 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.Value
 
 /**
- * @see FlexibleMethodAnalyzer
+ * @see org.jetbrains.kotlin.codegen.optimization.fixStack.FastStackAnalyzer
  */
 @Suppress("DuplicatedCode")
 open class FastMethodAnalyzer<V : Value>(

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FlexibleMethodAnalyzer.kt

@@ -1,346 +0,0 @@
-/*
- * 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.
- *
- *
- * ASM: a very small and fast Java bytecode manipulation framework
- * Copyright (c) 2000-2011 INRIA, France Telecom
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the copyright holders nor the names of its
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-package org.jetbrains.kotlin.codegen.optimization.common
-
-import org.jetbrains.kotlin.codegen.inline.insnText
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
-import org.jetbrains.org.objectweb.asm.tree.analysis.Value
-
-/**
- * This class is a modified version of `org.objectweb.asm.tree.analysis.Analyzer`
- *
- * @see FastMethodAnalyzer
- *
- * @author Eric Bruneton
- * @author Dmitry Petrov
- */
-@Suppress("DuplicatedCode")
-open class FlexibleMethodAnalyzer<V : Value>(
-    private val owner: String,
-    val method: MethodNode,
-    protected val interpreter: Interpreter<V>
-) {
-    protected val insnsArray: Array<AbstractInsnNode> = method.instructions.toArray()
-    private val nInsns = insnsArray.size
-
-    val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
-
-    private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
-    private val queued = BooleanArray(nInsns)
-    private val queue = IntArray(nInsns)
-    private var top = 0
-
-    private val singlePredBlock = IntArray(nInsns)
-
-    protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
-
-    protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
-
-    protected open fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean = true
-
-    fun analyze(): Array<Frame<V>?> {
-        if (nInsns == 0) return frames
-
-        checkAssertions()
-
-        computeExceptionHandlersForEachInsn()
-
-        initSinglePredBlocks()
-
-        val current = newFrame(method.maxLocals, method.maxStack)
-        val handler = newFrame(method.maxLocals, method.maxStack)
-        initControlFlowAnalysis(current, method, owner)
-
-        while (top > 0) {
-            val insn = queue[--top]
-            val f = frames[insn]!!
-            queued[insn] = false
-
-            val insnNode = method.instructions[insn]
-            try {
-                val insnOpcode = insnNode.opcode
-                val insnType = insnNode.type
-
-                if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) {
-                    visitNopInsn(f, insn)
-                } else {
-                    current.init(f).execute(insnNode, interpreter)
-
-                    when {
-                        insnNode is JumpInsnNode ->
-                            visitJumpInsnNode(insnNode, current, insn, insnOpcode)
-                        insnNode is LookupSwitchInsnNode ->
-                            visitLookupSwitchInsnNode(insnNode, current, insn)
-                        insnNode is TableSwitchInsnNode ->
-                            visitTableSwitchInsnNode(insnNode, current, insn)
-                        insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN) ->
-                            visitOpInsn(current, insn)
-                        else -> {
-                        }
-                    }
-                }
-
-                handlers[insn]?.forEach { tcb ->
-                    val exnType = Type.getObjectType(tcb.type ?: "java/lang/Throwable")
-                    val jump = tcb.handler.indexOf()
-                    if (visitControlFlowExceptionEdge(insn, tcb.handler.indexOf())) {
-                        handler.init(f)
-                        handler.clearStack()
-                        handler.push(interpreter.newValue(exnType))
-                        mergeControlFlowEdge(insn, jump, handler)
-                    }
-                }
-
-            } catch (e: AnalyzerException) {
-                throw AnalyzerException(e.node, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
-            } catch (e: Exception) {
-                throw AnalyzerException(insnNode, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
-            }
-
-        }
-
-        return frames
-    }
-
-    private fun initSinglePredBlocks() {
-        markSinglePredBlockEntries()
-        markSinglePredBlockBodies()
-    }
-
-    private fun markSinglePredBlockEntries() {
-        // Method entry point is SPB entry point.
-        var blockId = 0
-        singlePredBlock[0] = ++blockId
-
-        // Every jump target is SPB entry point.
-        for (insn in insnsArray) {
-            when (insn) {
-                is JumpInsnNode -> {
-                    val labelIndex = insn.label.indexOf()
-                    if (singlePredBlock[labelIndex] == 0) {
-                        singlePredBlock[labelIndex] = ++blockId
-                    }
-                }
-                is LookupSwitchInsnNode -> {
-                    insn.dflt?.let { dfltLabel ->
-                        val dfltIndex = dfltLabel.indexOf()
-                        if (singlePredBlock[dfltIndex] == 0) {
-                            singlePredBlock[dfltIndex] = ++blockId
-                        }
-                    }
-                    for (label in insn.labels) {
-                        val labelIndex = label.indexOf()
-                        if (singlePredBlock[labelIndex] == 0) {
-                            singlePredBlock[labelIndex] = ++blockId
-                        }
-                    }
-                }
-                is TableSwitchInsnNode -> {
-                    insn.dflt?.let { dfltLabel ->
-                        val dfltIndex = dfltLabel.indexOf()
-                        if (singlePredBlock[dfltIndex] == 0) {
-                            singlePredBlock[dfltIndex] = ++blockId
-                        }
-                    }
-                    for (label in insn.labels) {
-                        val labelIndex = label.indexOf()
-                        if (singlePredBlock[labelIndex] == 0) {
-                            singlePredBlock[labelIndex] = ++blockId
-                        }
-                    }
-                }
-            }
-        }
-
-        // Every try-catch block handler entry point is SPB entry point
-        for (tcb in method.tryCatchBlocks) {
-            val handlerIndex = tcb.handler.indexOf()
-            if (singlePredBlock[handlerIndex] == 0) {
-                singlePredBlock[handlerIndex] = ++blockId
-            }
-        }
-    }
-
-    private fun markSinglePredBlockBodies() {
-        var current = 0
-        for ((i, insn) in insnsArray.withIndex()) {
-            if (singlePredBlock[i] == 0) {
-                singlePredBlock[i] = current
-            } else {
-                // Entered a new SPB.
-                current = singlePredBlock[i]
-            }
-
-            // GOTO, ATHROW, *RETURN instructions terminate current SPB.
-            when (insn.opcode) {
-                Opcodes.GOTO,
-                Opcodes.ATHROW,
-                in Opcodes.IRETURN..Opcodes.RETURN ->
-                    current = 0
-            }
-        }
-    }
-
-    private fun AbstractInsnNode.indexOf() = method.instructions.indexOf(this)
-
-    fun getFrame(insn: AbstractInsnNode): Frame<V>? =
-        frames[insn.indexOf()]
-
-    private fun checkAssertions() {
-        if (insnsArray.any { it.opcode == Opcodes.JSR || it.opcode == Opcodes.RET })
-            throw AssertionError("Subroutines are deprecated since Java 6")
-    }
-
-    private fun visitOpInsn(current: Frame<V>, insn: Int) {
-        processControlFlowEdge(current, insn, insn + 1)
-    }
-
-    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = insnNode.dflt.indexOf()
-        processControlFlowEdge(current, insn, jump)
-        // In most cases order of visiting switch labels should not matter
-        // The only one is a tableswitch being added in the beginning of coroutine method, these switch' labels may lead
-        // in the middle of try/catch block, and FixStackAnalyzer is not ready for this (trying to restore stack before it was saved)
-        // So we just fix the order of labels being traversed: the first one should be one at the method beginning
-        // Using 'reversed' is because nodes are processed in LIFO order
-        for (label in insnNode.labels.reversed()) {
-            jump = label.indexOf()
-            processControlFlowEdge(current, insn, jump)
-        }
-    }
-
-    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = insnNode.dflt.indexOf()
-        processControlFlowEdge(current, insn, jump)
-        for (label in insnNode.labels) {
-            jump = label.indexOf()
-            processControlFlowEdge(current, insn, jump)
-        }
-    }
-
-    private fun visitJumpInsnNode(insnNode: JumpInsnNode, current: Frame<V>, insn: Int, insnOpcode: Int) {
-        if (insnOpcode != Opcodes.GOTO && insnOpcode != Opcodes.JSR) {
-            processControlFlowEdge(current, insn, insn + 1)
-        }
-        val jump = insnNode.label.indexOf()
-        processControlFlowEdge(current, insn, jump)
-    }
-
-    private fun visitNopInsn(f: Frame<V>, insn: Int) {
-        processControlFlowEdge(f, insn, insn + 1)
-    }
-
-    private fun processControlFlowEdge(current: Frame<V>, insn: Int, jump: Int) {
-        if (visitControlFlowEdge(insn, jump)) {
-            mergeControlFlowEdge(insn, jump, current)
-        }
-    }
-
-    private fun initControlFlowAnalysis(current: Frame<V>, m: MethodNode, owner: String) {
-        current.setReturn(interpreter.newValue(Type.getReturnType(m.desc)))
-        val args = Type.getArgumentTypes(m.desc)
-        var local = 0
-        if ((m.access and Opcodes.ACC_STATIC) == 0) {
-            val ctype = Type.getObjectType(owner)
-            current.setLocal(local++, interpreter.newValue(ctype))
-        }
-        for (arg in args) {
-            current.setLocal(local++, interpreter.newValue(arg))
-            if (arg.size == 2) {
-                current.setLocal(local++, interpreter.newValue(null))
-            }
-        }
-        while (local < m.maxLocals) {
-            current.setLocal(local++, interpreter.newValue(null))
-        }
-        mergeControlFlowEdge(0, 0, current)
-    }
-
-    private fun computeExceptionHandlersForEachInsn() {
-        for (tcb in method.tryCatchBlocks) {
-            val begin = tcb.start.indexOf()
-            val end = tcb.end.indexOf()
-            for (j in begin until end) {
-                val insn = insnsArray[j]
-                if (!insn.isMeaningful) continue
-                var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[j]
-                if (insnHandlers == null) {
-                    insnHandlers = ArrayList<TryCatchBlockNode>()
-                    handlers[j] = insnHandlers
-                }
-                insnHandlers.add(tcb)
-            }
-        }
-    }
-
-    private fun mergeControlFlowEdge(src: Int, dest: Int, frame: Frame<V>) {
-        val oldFrame = frames[dest]
-        val changes = when {
-            oldFrame == null -> {
-                frames[dest] = newFrame(frame.locals, frame.maxStackSize).apply { init(frame) }
-                true
-            }
-            dest == src + 1 && singlePredBlock[src] == singlePredBlock[dest] -> {
-                // Forward jump within a single predecessor block, no need to merge.
-                oldFrame.init(frame)
-                true
-            }
-            else ->
-                oldFrame.merge(frame, interpreter)
-        }
-        if (changes && !queued[dest]) {
-            queued[dest] = true
-            queue[top++] = dest
-        }
-    }
-
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FastStackAnalyzer.kt

@@ -0,0 +1,239 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jetbrains.kotlin.codegen.optimization.fixStack
+
+import org.jetbrains.kotlin.codegen.inline.insnText
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
+import org.jetbrains.org.objectweb.asm.tree.analysis.Value
+
+/**
+ * @see org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
+ */
+@Suppress("DuplicatedCode")
+internal open class FastStackAnalyzer<V : Value>(
+    private val owner: String,
+    val method: MethodNode,
+    protected val interpreter: Interpreter<V>
+) {
+    protected val insnsArray: Array<AbstractInsnNode> = method.instructions.toArray()
+    private val nInsns = insnsArray.size
+
+    private val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
+
+    private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
+    private val queued = BooleanArray(nInsns)
+    private val queue = IntArray(nInsns)
+    private var top = 0
+
+    protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
+
+    protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
+
+    protected open fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean = true
+
+    fun analyze(): Array<Frame<V>?> {
+        if (nInsns == 0) return frames
+
+        // This is a very specific version of method bytecode analyzer that doesn't perform any DFA,
+        // but infers stack types for reachable instructions instead.
+
+        checkAssertions()
+
+        computeExceptionEdges()
+
+        val current = newFrame(method.maxLocals, method.maxStack)
+        val handler = newFrame(method.maxLocals, method.maxStack)
+        initControlFlowAnalysis(current, method, owner)
+
+        while (top > 0) {
+            val insn = queue[--top]
+            val f = frames[insn]!!
+            queued[insn] = false
+
+            val insnNode = method.instructions[insn]
+            val insnOpcode = insnNode.opcode
+            val insnType = insnNode.type
+
+            try {
+                if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) {
+                    visitNopInsn(f, insn)
+                } else {
+                    current.init(f)
+                    if (insnOpcode != Opcodes.RETURN) {
+                        // Don't care about possibly incompatible return type
+                        current.execute(insnNode, interpreter)
+                    }
+
+                    when {
+                        insnNode is JumpInsnNode ->
+                            visitJumpInsnNode(insnNode, current, insn, insnOpcode)
+                        insnNode is LookupSwitchInsnNode ->
+                            visitLookupSwitchInsnNode(insnNode, current, insn)
+                        insnNode is TableSwitchInsnNode ->
+                            visitTableSwitchInsnNode(insnNode, current, insn)
+                        insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN) ->
+                            visitOpInsn(current, insn)
+                        else -> {
+                        }
+                    }
+                }
+
+                handlers[insn]?.forEach { tcb ->
+                    val exnType = Type.getObjectType(tcb.type ?: "java/lang/Throwable")
+                    val jump = tcb.handler.indexOf()
+                    if (visitControlFlowExceptionEdge(insn, tcb.handler.indexOf())) {
+                        handler.init(f)
+                        handler.clearStack()
+                        handler.push(interpreter.newValue(exnType))
+                        mergeControlFlowEdge(jump, handler)
+                    }
+                }
+
+            } catch (e: AnalyzerException) {
+                throw AnalyzerException(e.node, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
+            } catch (e: Exception) {
+                throw AnalyzerException(insnNode, "Error at instruction #$insn ${insnNode.insnText}: ${e.message}", e)
+            }
+
+        }
+
+        return frames
+    }
+
+    private fun AbstractInsnNode.indexOf() = method.instructions.indexOf(this)
+
+    fun getFrame(insn: AbstractInsnNode): Frame<V>? =
+        frames[insn.indexOf()]
+
+    private fun checkAssertions() {
+        if (insnsArray.any { it.opcode == Opcodes.JSR || it.opcode == Opcodes.RET })
+            throw AssertionError("Subroutines are deprecated since Java 6")
+    }
+
+    private fun visitOpInsn(current: Frame<V>, insn: Int) {
+        processControlFlowEdge(current, insn, insn + 1)
+    }
+
+    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = insnNode.dflt.indexOf()
+        processControlFlowEdge(current, insn, jump)
+        // In most cases order of visiting switch labels should not matter
+        // The only one is a tableswitch being added in the beginning of coroutine method, these switch' labels may lead
+        // in the middle of try/catch block, and FixStackAnalyzer is not ready for this (trying to restore stack before it was saved)
+        // So we just fix the order of labels being traversed: the first one should be one at the method beginning
+        // Using 'reversed' is because nodes are processed in LIFO order
+        for (label in insnNode.labels.reversed()) {
+            jump = label.indexOf()
+            processControlFlowEdge(current, insn, jump)
+        }
+    }
+
+    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = insnNode.dflt.indexOf()
+        processControlFlowEdge(current, insn, jump)
+        for (label in insnNode.labels) {
+            jump = label.indexOf()
+            processControlFlowEdge(current, insn, jump)
+        }
+    }
+
+    private fun visitJumpInsnNode(insnNode: JumpInsnNode, current: Frame<V>, insn: Int, insnOpcode: Int) {
+        if (insnOpcode != Opcodes.GOTO && insnOpcode != Opcodes.JSR) {
+            processControlFlowEdge(current, insn, insn + 1)
+        }
+        val jump = insnNode.label.indexOf()
+        processControlFlowEdge(current, insn, jump)
+    }
+
+    private fun visitNopInsn(f: Frame<V>, insn: Int) {
+        processControlFlowEdge(f, insn, insn + 1)
+    }
+
+    private fun processControlFlowEdge(current: Frame<V>, insn: Int, jump: Int) {
+        if (visitControlFlowEdge(insn, jump)) {
+            mergeControlFlowEdge(jump, current)
+        }
+    }
+
+    private fun initControlFlowAnalysis(current: Frame<V>, m: MethodNode, owner: String) {
+        current.setReturn(interpreter.newValue(Type.getReturnType(m.desc)))
+        val args = Type.getArgumentTypes(m.desc)
+        var local = 0
+        if ((m.access and Opcodes.ACC_STATIC) == 0) {
+            val ctype = Type.getObjectType(owner)
+            current.setLocal(local++, interpreter.newValue(ctype))
+        }
+        for (arg in args) {
+            current.setLocal(local++, interpreter.newValue(arg))
+            if (arg.size == 2) {
+                current.setLocal(local++, interpreter.newValue(null))
+            }
+        }
+        while (local < m.maxLocals) {
+            current.setLocal(local++, interpreter.newValue(null))
+        }
+        mergeControlFlowEdge(0, current)
+    }
+
+    private fun computeExceptionEdges() {
+        for (tcb in method.tryCatchBlocks) {
+            // Don't have to visit same exception handler multiple times - we care only about stack state at TCB start.
+            val start = tcb.start.indexOf()
+            var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[start]
+            if (insnHandlers == null) {
+                insnHandlers = ArrayList()
+                handlers[start] = insnHandlers
+            }
+            insnHandlers.add(tcb)
+        }
+    }
+
+    private fun mergeControlFlowEdge(dest: Int, frame: Frame<V>) {
+        val destFrame = frames[dest]
+        if (destFrame == null) {
+            // Don't have to visit same instruction multiple times - we care only about "initial" stack state.
+            frames[dest] = newFrame(frame.locals, frame.maxStackSize).apply { init(frame) }
+            if (!queued[dest]) {
+                queued[dest] = true
+                queue[top++] = dest
+            }
+        }
+    }
+
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt

@@ -19,9 +19,6 @@ package org.jetbrains.kotlin.codegen.optimization.fixStack
 import com.intellij.util.containers.Stack
 import org.jetbrains.kotlin.codegen.inline.isAfterInlineMarker
 import org.jetbrains.kotlin.codegen.inline.isBeforeInlineMarker
-import org.jetbrains.kotlin.codegen.inline.isMarkedReturn
-import org.jetbrains.kotlin.codegen.optimization.common.FlexibleMethodAnalyzer
-import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -29,8 +26,6 @@ import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.JumpInsnNode
 import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
 import kotlin.math.max
@@ -50,9 +45,14 @@ internal class FixStackAnalyzer(
 
     val maxExtraStackSize: Int get() = analyzer.maxExtraStackSize
 
-    fun getStackToSpill(location: AbstractInsnNode) = analyzer.spilledStacks[location]
-    fun getActualStack(location: AbstractInsnNode) = getFrame(location)?.getStackContent()
-    fun getActualStackSize(location: AbstractInsnNode) = getFrame(location)?.stackSizeWithExtra ?: DEAD_CODE_STACK_SIZE
+    fun getStackToSpill(location: AbstractInsnNode): List<FixStackValue>? =
+        analyzer.spilledStacks[location]
+
+    fun getActualStack(location: AbstractInsnNode): List<FixStackValue>? =
+        getFrame(location)?.getStackContent()
+
+    fun getActualStackSize(location: AbstractInsnNode): Int =
+        getFrame(location)?.stackSizeWithExtra ?: DEAD_CODE_STACK_SIZE
 
     fun getExpectedStackSize(location: AbstractInsnNode): Int {
         // We should look for expected stack size at loop entry point markers if available,
@@ -90,9 +90,9 @@ internal class FixStackAnalyzer(
     private val analyzer = InternalAnalyzer(owner)
 
     private inner class InternalAnalyzer(owner: String) :
-        FlexibleMethodAnalyzer<BasicValue>(owner, method, OptimizationBasicInterpreter()) {
+        FastStackAnalyzer<FixStackValue>(owner, method, FixStackInterpreter()) {
 
-        val spilledStacks = hashMapOf<AbstractInsnNode, List<BasicValue>>()
+        val spilledStacks = hashMapOf<AbstractInsnNode, List<FixStackValue>>()
         var maxExtraStackSize = 0; private set
 
         override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
@@ -101,15 +101,15 @@ internal class FixStackAnalyzer(
             return !(insnNode is JumpInsnNode && context.breakContinueGotoNodes.contains(insnNode))
         }
 
-        override fun newFrame(nLocals: Int, nStack: Int): Frame<BasicValue> =
+        override fun newFrame(nLocals: Int, nStack: Int): Frame<FixStackValue> =
             FixStackFrame(nLocals, nStack)
 
         private fun indexOf(node: AbstractInsnNode) = method.instructions.indexOf(node)
 
-        inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<BasicValue>(nLocals, nStack) {
-            val extraStack = Stack<BasicValue>()
+        inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<FixStackValue>(nLocals, nStack) {
+            val extraStack = Stack<FixStackValue>()
 
-            override fun init(src: Frame<out BasicValue>): Frame<BasicValue> {
+            override fun init(src: Frame<out FixStackValue>): Frame<FixStackValue> {
                 extraStack.clear()
                 extraStack.addAll((src as FixStackFrame).extraStack)
                 return super.init(src)
@@ -120,7 +120,7 @@ internal class FixStackAnalyzer(
                 super.clearStack()
             }
 
-            override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<BasicValue>) {
+            override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<FixStackValue>) {
                 when {
                     PseudoInsn.SAVE_STACK_BEFORE_TRY.isa(insn) ->
                         executeSaveStackBeforeTry(insn)
@@ -130,10 +130,8 @@ internal class FixStackAnalyzer(
                         executeBeforeInlineCallMarker(insn)
                     isAfterInlineMarker(insn) ->
                         executeAfterInlineCallMarker(insn)
-                    isMarkedReturn(insn) -> {
-                        // KT-9644: might throw "Incompatible return type" on non-local return, in fact we don't care.
-                        if (insn.opcode == Opcodes.RETURN) return
-                    }
+                    insn.opcode == Opcodes.RETURN ->
+                        return
                 }
 
                 super.execute(insn, interpreter)
@@ -141,14 +139,16 @@ internal class FixStackAnalyzer(
 
             val stackSizeWithExtra: Int get() = super.getStackSize() + extraStack.size
 
-            fun getStackContent(): List<BasicValue> {
-                val savedStack = arrayListOf<BasicValue>()
-                IntRange(0, super.getStackSize() - 1).mapTo(savedStack) { super.getStack(it) }
+            fun getStackContent(): List<FixStackValue> {
+                val savedStack = ArrayList<FixStackValue>()
+                for (i in 0 until super.getStackSize()) {
+                    savedStack.add(super.getStack(i))
+                }
                 savedStack.addAll(extraStack)
                 return savedStack
             }
 
-            override fun push(value: BasicValue) {
+            override fun push(value: FixStackValue) {
                 if (super.getStackSize() < maxStackSize) {
                     super.push(value)
                 } else {
@@ -157,19 +157,18 @@ internal class FixStackAnalyzer(
                 }
             }
 
-            fun pushAll(values: Collection<BasicValue>) {
+            fun pushAll(values: Collection<FixStackValue>) {
                 values.forEach { push(it) }
             }
 
-            override fun pop(): BasicValue {
-                return if (extraStack.isNotEmpty()) {
+            override fun pop(): FixStackValue =
+                if (extraStack.isNotEmpty()) {
                     extraStack.pop()
                 } else {
                     super.pop()
                 }
-            }
 
-            override fun setStack(i: Int, value: BasicValue) {
+            override fun setStack(i: Int, value: FixStackValue) {
                 if (i < super.getMaxStackSize()) {
                     super.setStack(i, value)
                 } else {
@@ -177,29 +176,8 @@ internal class FixStackAnalyzer(
                 }
             }
 
-            override fun merge(frame: Frame<out BasicValue>, interpreter: Interpreter<BasicValue>): Boolean {
-                val other = frame as FixStackFrame
-                if (stackSizeWithExtra != other.stackSizeWithExtra) {
-                    throw AnalyzerException(null, "Incompatible stack heights")
-                }
-                var changed = false
-                for (i in 0 until stackSize) {
-                    val v0 = super.getStack(i)
-                    val vm = interpreter.merge(v0, other.getStack(i))
-                    if (vm != v0) {
-                        super.setStack(i, vm)
-                        changed = true
-                    }
-                }
-                for (i in 0 until extraStack.size) {
-                    val v0 = extraStack[i]
-                    val vm = interpreter.merge(v0, other.extraStack[i])
-                    if (vm != v0) {
-                        extraStack[i] = vm
-                        changed = true
-                    }
-                }
-                return changed
+            override fun merge(frame: Frame<out FixStackValue>, interpreter: Interpreter<FixStackValue>): Boolean {
+                throw UnsupportedOperationException("Stack normalization should not merge frames")
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackInterpreter.kt

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen.optimization.fixStack
+
+import org.jetbrains.kotlin.codegen.inline.insnOpcodeText
+import org.jetbrains.org.objectweb.asm.Handle
+import org.jetbrains.org.objectweb.asm.Opcodes.*
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
+
+open class FixStackInterpreter : Interpreter<FixStackValue>(API_VERSION) {
+
+    override fun newValue(type: Type?): FixStackValue =
+        type?.toFixStackValue()
+            ?: FixStackValue.UNINITIALIZED
+
+    override fun newOperation(insn: AbstractInsnNode): FixStackValue? =
+        when (insn.opcode) {
+            ACONST_NULL ->
+                FixStackValue.OBJECT
+            ICONST_M1, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5 ->
+                FixStackValue.INT
+            LCONST_0, LCONST_1 ->
+                FixStackValue.LONG
+            FCONST_0, FCONST_1, FCONST_2 ->
+                FixStackValue.FLOAT
+            DCONST_0, DCONST_1 ->
+                FixStackValue.DOUBLE
+            BIPUSH, SIPUSH ->
+                FixStackValue.INT
+            LDC -> {
+                when (val cst = (insn as LdcInsnNode).cst) {
+                    is Int ->
+                        FixStackValue.INT
+                    is Float ->
+                        FixStackValue.FLOAT
+                    is Long ->
+                        FixStackValue.LONG
+                    is Double ->
+                        FixStackValue.DOUBLE
+                    is String, is Handle ->
+                        FixStackValue.OBJECT
+                    is Type -> {
+                        val sort = cst.sort
+                        if (sort == Type.OBJECT || sort == Type.ARRAY || sort == Type.METHOD)
+                            FixStackValue.OBJECT
+                        else
+                            throw IllegalArgumentException("Illegal LDC constant $cst")
+                    }
+                    else ->
+                        throw IllegalArgumentException("Illegal LDC constant $cst")
+                }
+            }
+            GETSTATIC ->
+                newValue(Type.getType((insn as FieldInsnNode).desc))
+            NEW ->
+                newValue(Type.getObjectType((insn as TypeInsnNode).desc))
+            else ->
+                throw IllegalArgumentException("Unexpected instruction: " + insn.insnOpcodeText)
+        }
+
+    override fun copyOperation(insn: AbstractInsnNode, value: FixStackValue?): FixStackValue =
+        when (insn.opcode) {
+            ILOAD -> FixStackValue.INT
+            LLOAD -> FixStackValue.LONG
+            FLOAD -> FixStackValue.FLOAT
+            DLOAD -> FixStackValue.DOUBLE
+            ALOAD -> FixStackValue.OBJECT
+            else -> value!!
+        }
+
+    override fun binaryOperation(insn: AbstractInsnNode, value1: FixStackValue?, value2: FixStackValue?): FixStackValue? =
+        when (insn.opcode) {
+            IALOAD, BALOAD, CALOAD, SALOAD, IADD, ISUB, IMUL, IDIV, IREM, ISHL, ISHR, IUSHR, IAND, IOR, IXOR ->
+                FixStackValue.INT
+            FALOAD, FADD, FSUB, FMUL, FDIV, FREM ->
+                FixStackValue.FLOAT
+            LALOAD, LADD, LSUB, LMUL, LDIV, LREM, LSHL, LSHR, LUSHR, LAND, LOR, LXOR ->
+                FixStackValue.LONG
+            DALOAD, DADD, DSUB, DMUL, DDIV, DREM ->
+                FixStackValue.DOUBLE
+            AALOAD ->
+                FixStackValue.OBJECT
+            LCMP, FCMPL, FCMPG, DCMPL, DCMPG ->
+                FixStackValue.INT
+            IF_ICMPEQ, IF_ICMPNE, IF_ICMPLT, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ACMPEQ, IF_ACMPNE, PUTFIELD ->
+                null
+            else ->
+                throw IllegalArgumentException("Unexpected instruction: " + insn.insnOpcodeText)
+        }
+
+    override fun ternaryOperation(
+        insn: AbstractInsnNode,
+        value1: FixStackValue?,
+        value2: FixStackValue?,
+        value3: FixStackValue?
+    ): FixStackValue? =
+        null
+
+    override fun naryOperation(insn: AbstractInsnNode, values: List<FixStackValue?>): FixStackValue? =
+        when (insn.opcode) {
+            MULTIANEWARRAY ->
+                newValue(Type.getType((insn as MultiANewArrayInsnNode).desc))
+            INVOKEDYNAMIC ->
+                newValue(Type.getReturnType((insn as InvokeDynamicInsnNode).desc))
+            else ->
+                newValue(Type.getReturnType((insn as MethodInsnNode).desc))
+        }
+
+    override fun returnOperation(insn: AbstractInsnNode?, value: FixStackValue?, expected: FixStackValue?) {
+    }
+
+    override fun unaryOperation(insn: AbstractInsnNode, value: FixStackValue?): FixStackValue? =
+        when (insn.opcode) {
+            INEG, IINC, L2I, F2I, D2I, I2B, I2C, I2S ->
+                FixStackValue.INT
+            FNEG, I2F, L2F, D2F ->
+                FixStackValue.FLOAT
+            LNEG, I2L, F2L, D2L ->
+                FixStackValue.LONG
+            DNEG, I2D, L2D, F2D ->
+                FixStackValue.DOUBLE
+            IFEQ, IFNE, IFLT, IFGE, IFGT, IFLE, TABLESWITCH, LOOKUPSWITCH, IRETURN, LRETURN, FRETURN, DRETURN, ARETURN, PUTSTATIC ->
+                null
+            GETFIELD ->
+                newValue(Type.getType((insn as FieldInsnNode).desc))
+            NEWARRAY ->
+                FixStackValue.OBJECT
+            ANEWARRAY -> {
+                FixStackValue.OBJECT
+            }
+            ARRAYLENGTH ->
+                FixStackValue.INT
+            ATHROW ->
+                null
+            CHECKCAST ->
+                FixStackValue.OBJECT
+            INSTANCEOF ->
+                FixStackValue.INT
+            MONITORENTER, MONITOREXIT, IFNULL, IFNONNULL ->
+                null
+            else ->
+                throw IllegalArgumentException("Unexpected instruction: " + insn.insnOpcodeText)
+        }
+
+    override fun merge(v: FixStackValue?, w: FixStackValue?): FixStackValue? =
+        when {
+            v == w -> v
+            v == null -> w
+            w == null -> v
+            else -> throw AssertionError("Mismatching value kinds: $v != $w")
+        }
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackValue.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.codegen.optimization.fixStack
+
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.analysis.Value
+
+enum class FixStackValue(
+    private val _size: Int,
+    val loadOpcode: Int,
+    val storeOpcode: Int,
+    val popOpcode: Int
+) : Value {
+    INT(1, Opcodes.ILOAD, Opcodes.ISTORE, Opcodes.POP),
+    LONG(2, Opcodes.LLOAD, Opcodes.LSTORE, Opcodes.POP2),
+    FLOAT(1, Opcodes.FLOAD, Opcodes.FSTORE, Opcodes.POP),
+    DOUBLE(2, Opcodes.DLOAD, Opcodes.DSTORE, Opcodes.POP2),
+    OBJECT(1, Opcodes.ALOAD, Opcodes.ASTORE, Opcodes.POP),
+    UNINITIALIZED(1, -1, -1, -1)
+    ;
+
+    override fun getSize(): Int = _size
+}
+
+fun Type.toFixStackValue(): FixStackValue? =
+    when (this.sort) {
+        Type.VOID -> null
+        Type.BOOLEAN, Type.BYTE, Type.CHAR, Type.SHORT, Type.INT -> FixStackValue.INT
+        Type.LONG -> FixStackValue.LONG
+        Type.FLOAT -> FixStackValue.FLOAT
+        Type.DOUBLE -> FixStackValue.DOUBLE
+        Type.OBJECT, Type.ARRAY, Type.METHOD -> FixStackValue.OBJECT
+        else -> throw AssertionError("Unexpected type: $this")
+    }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/LocalVariablesManager.kt

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.codegen.optimization.fixStack
 
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import kotlin.math.max
 
 internal class LocalVariablesManager(val context: FixStackContext, val methodNode: MethodNode) {
@@ -39,7 +38,10 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
         methodNode.maxLocals = max(methodNode.maxLocals, newValue)
     }
 
-    fun allocateVariablesForSaveStackMarker(saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
+    fun allocateVariablesForSaveStackMarker(
+        saveStackMarker: AbstractInsnNode,
+        savedStackValues: List<FixStackValue>
+    ): SavedStackDescriptor {
         val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size
         return allocateNewHandle(numRestoreStackMarkers, saveStackMarker, savedStackValues)
     }
@@ -47,10 +49,10 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
     private fun allocateNewHandle(
         numRestoreStackMarkers: Int,
         saveStackMarker: AbstractInsnNode,
-        savedStackValues: List<BasicValue>
+        savedStackValues: List<FixStackValue>
     ): SavedStackDescriptor {
-        if (savedStackValues.any { it.type == null }) {
-            throw AssertionError("Uninitialized value on stack at ${methodNode.instructions.indexOf(saveStackMarker)}")
+        if (savedStackValues.any { it == FixStackValue.UNINITIALIZED }) {
+            throw AssertionError("Uninitialized value on stack at ${methodNode.instructions.indexOf(saveStackMarker)}: $savedStackValues")
         }
 
         val firstUnusedLocalVarIndex = getFirstUnusedLocalVariableIndex()
@@ -78,7 +80,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
 
     fun allocateVariablesForBeforeInlineMarker(
         beforeInlineMarker: AbstractInsnNode,
-        savedStackValues: List<BasicValue>
+        savedStackValues: List<FixStackValue>
     ): SavedStackDescriptor {
         return allocateNewHandle(1, beforeInlineMarker, savedStackValues)
     }
@@ -101,7 +103,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
         }
     }
 
-    fun createReturnValueVariable(returnValue: BasicValue): Int {
+    fun createReturnValueVariable(returnValue: FixStackValue): Int {
         val returnValueIndex = getFirstUnusedLocalVariableIndex()
         updateMaxLocals(returnValueIndex + returnValue.size)
         return returnValueIndex

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/StackTransformationUtils.kt

@@ -54,10 +54,10 @@ fun <V : Value> Frame<V>.peekWords(size1: Int, size2: Int): List<V>? {
 }
 
 class SavedStackDescriptor(
-    val savedValues: List<BasicValue>,
+    val savedValues: List<FixStackValue>,
     val firstLocalVarIndex: Int
 ) {
-    private val savedValuesSize = savedValues.fold(0, { size, value -> size + value.size })
+    private val savedValuesSize = savedValues.fold(0) { size, value -> size + value.size }
     val firstUnusedLocalVarIndex = firstLocalVarIndex + savedValuesSize
 
     override fun toString(): String =
@@ -88,13 +88,13 @@ fun restoreStackWithReturnValue(
     methodNode: MethodNode,
     nodeToReplace: AbstractInsnNode,
     savedStackDescriptor: SavedStackDescriptor,
-    returnValue: BasicValue,
+    returnValue: FixStackValue,
     returnValueLocalVarIndex: Int
 ) {
     with(methodNode.instructions) {
-        insertBefore(nodeToReplace, VarInsnNode(returnValue.type.getOpcode(Opcodes.ISTORE), returnValueLocalVarIndex))
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.storeOpcode, returnValueLocalVarIndex))
         generateLoadInstructions(methodNode, nodeToReplace, savedStackDescriptor)
-        insertBefore(nodeToReplace, VarInsnNode(returnValue.type.getOpcode(Opcodes.ILOAD), returnValueLocalVarIndex))
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.loadOpcode, returnValueLocalVarIndex))
         remove(nodeToReplace)
     }
 }
@@ -102,10 +102,7 @@ fun restoreStackWithReturnValue(
 fun generateLoadInstructions(methodNode: MethodNode, location: AbstractInsnNode, savedStackDescriptor: SavedStackDescriptor) {
     var localVarIndex = savedStackDescriptor.firstLocalVarIndex
     for (value in savedStackDescriptor.savedValues) {
-        methodNode.instructions.insertBefore(
-            location,
-            VarInsnNode(value.type.getOpcode(Opcodes.ILOAD), localVarIndex)
-        )
+        methodNode.instructions.insertBefore(location, VarInsnNode(value.loadOpcode, localVarIndex))
         localVarIndex += value.size
     }
 }
@@ -114,10 +111,7 @@ fun generateStoreInstructions(methodNode: MethodNode, location: AbstractInsnNode
     var localVarIndex = savedStackDescriptor.firstUnusedLocalVarIndex
     for (value in savedStackDescriptor.savedValues.asReversed()) {
         localVarIndex -= value.size
-        methodNode.instructions.insertBefore(
-            location,
-            VarInsnNode(value.type.getOpcode(Opcodes.ISTORE), localVarIndex)
-        )
+        methodNode.instructions.insertBefore(location, VarInsnNode(value.storeOpcode, localVarIndex))
     }
 }
 
@@ -146,10 +140,10 @@ fun replaceAlwaysTrueIfeqWithGoto(methodNode: MethodNode, node: AbstractInsnNode
     }
 }
 
-fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, stackContent: List<BasicValue>) {
+fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, stackContent: List<FixStackValue>) {
     with(methodNode.instructions) {
         for (stackValue in stackContent.subList(expectedStackSize, stackContent.size)) {
-            insert(node, getPopInstruction(stackValue))
+            insert(node, InsnNode(stackValue.popOpcode))
         }
         remove(node)
     }

compiler/build.gradle.kts

@@ -85,7 +85,9 @@ if (kotlinBuildProperties.isInJpsBuildIdeaSync) {
     idea {
         this.module.generatedSourceDirs.add(generationRoot)
     }
-} else if (!kotlinBuildProperties.useFir && !kotlinBuildProperties.disableWerror) {
+}
+
+if (!kotlinBuildProperties.disableWerror) {
     allprojects {
         tasks.withType<KotlinCompile<*>> {
             if (path !in tasksWithWarnings) {

compiler/cli/cli-common/resources/META-INF/extensions/core.xml

@@ -1,12 +0,0 @@
-<idea-plugin>
-    <id>org.jetbrains.kotlin</id>
-    <version>1.2</version>
-
-    <!-- Don't add more extension points here! Logic in KotlinCoreEnvironment assumes that there is only one EP.  -->
-    <!-- And this file should be removed once 202 is no longer supported -->
-    <extensionPoints>
-        <extensionPoint qualifiedName="com.intellij.psi.classFileDecompiler"
-                        interface="com.intellij.psi.compiled.ClassFileDecompilers$Decompiler"
-                        dynamic="true"/>
-    </extensionPoints>
-</idea-plugin>

compiler/cli/cli-common/resources/META-INF/extensions/core.xml.as42

@@ -1,10 +0,0 @@
-<idea-plugin>
-    <id>org.jetbrains.kotlin</id>
-    <version>1.2</version>
-
-    <extensionPoints>
-        <extensionPoint qualifiedName="com.intellij.psi.classFileDecompiler"
-                        interface="com.intellij.psi.compiled.ClassFileDecompilers$Decompiler"
-                        dynamic="true"/>
-    </extensionPoints>
-</idea-plugin>

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt

@@ -214,6 +214,12 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var useOldClassFilesReading: Boolean by FreezableVar(false)
 
+    @Argument(
+        value = "-Xuse-fast-jar-file-system",
+        description = "Use fast implementation on Jar FS. This may speed up compilation time, but currently it's an experimental mode"
+    )
+    var useFastJarFileSystem: Boolean by FreezableVar(false)
+
     @Argument(
         value = "-Xdump-declarations-to",
         valueDescription = "<path>",

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -38,6 +38,8 @@ import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.backend.js.ic.buildCache
+import org.jetbrains.kotlin.ir.backend.js.ic.checkCaches
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.*
@@ -91,7 +93,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             configuration.put(CommonConfigurationKeys.MODULE_NAME, "repl.kts")
 
             val environment = KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration)
-            val projectEnv = KotlinCoreEnvironment.ProjectEnvironment(rootDisposable, environment)
+            val projectEnv = KotlinCoreEnvironment.ProjectEnvironment(rootDisposable, environment, configuration)
             projectEnv.registerExtensionsFromPlugins(configuration)
 
             val scriptingEvaluators = ScriptEvaluationExtension.getInstances(projectEnv.project)
@@ -179,6 +181,44 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         // TODO: Handle non-empty main call arguments
         val mainCallArguments = if (K2JsArgumentConstants.NO_CALL == arguments.main) null else emptyList<String>()
 
+        val icCaches = configureLibraries(arguments.cacheDirectories)
+
+        if (arguments.irBuildCache) {
+            messageCollector.report(INFO, "")
+            messageCollector.report(INFO, "Building cache:")
+            messageCollector.report(INFO, "to: ${outputFilePath}")
+            messageCollector.report(INFO, arguments.cacheDirectories ?: "")
+            messageCollector.report(INFO, libraries.toString())
+
+            val includes = arguments.includes!!
+
+            // TODO: deduplicate
+            val mainModule = run {
+                if (sourcesFiles.isNotEmpty()) {
+                    messageCollector.report(ERROR, "Source files are not supported when -Xinclude is present")
+                }
+                MainModule.Klib(includes)
+            }
+
+            val start = System.currentTimeMillis()
+            if (buildCache(
+                    cachePath = outputFilePath,
+                    project = projectJs,
+                    mainModule = mainModule,
+                    analyzer = AnalyzerWithCompilerReport(config.configuration),
+                    configuration = config.configuration,
+                    dependencies = libraries,
+                    friendDependencies = friendLibraries,
+                    icCache = checkCaches(libraries, icCaches, skipLib = mainModule.libPath)
+                )
+            ) {
+                messageCollector.report(INFO, "IC cache building duration: ${System.currentTimeMillis() - start}ms")
+            } else {
+                messageCollector.report(INFO, "IC cache up-to-date check duration: ${System.currentTimeMillis() - start}ms")
+            }
+            return OK
+        }
+
         if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
             if (arguments.irProduceKlibFile) {
                 require(outputFile.extension == KLIB_FILE_EXTENSION) { "Please set up .klib file as output" }
@@ -199,6 +239,9 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         }
 
         if (arguments.irProduceJs) {
+            messageCollector.report(INFO,"Produce executable: $outputFilePath")
+            messageCollector.report(INFO, arguments.cacheDirectories ?: "")
+
             val phaseConfig = createPhaseConfig(jsPhases, arguments, messageCollector)
 
             val includes = arguments.includes
@@ -243,6 +286,8 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 return OK
             }
 
+            val start = System.currentTimeMillis()
+
             val compiledModule = compile(
                 projectJs,
                 mainModule,
@@ -270,8 +315,13 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     arguments.irSafeExternalBooleanDiagnostic,
                     messageCollector
                 ),
+                lowerPerModule = icCaches.isNotEmpty(),
+                useStdlibCache = icCaches.isNotEmpty(),
+                icCache = if (icCaches.isNotEmpty()) checkCaches(libraries, icCaches, skipLib = includes).data else emptyMap(),
             )
 
+            messageCollector.report(INFO, "Executable production duration: ${System.currentTimeMillis() - start}ms")
+
             val outputs = if (arguments.irDce && !arguments.irDceDriven) compiledModule.outputsAfterDce!! else compiledModule.outputs!!
             outputFile.write(outputs)
             outputs.dependencies.forEach { (name, content) ->

compiler/cli/src/org/jetbrains/kotlin/cli/common/extensions/ScriptEvaluationExtension.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.cli.common.extensions
 
-import com.intellij.core.JavaCoreProjectEnvironment
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 
@@ -22,6 +22,6 @@ interface ScriptEvaluationExtension {
     fun eval(
         arguments: CommonCompilerArguments,
         configuration: CompilerConfiguration,
-        projectEnvironment: JavaCoreProjectEnvironment
+        projectEnvironment: KotlinCoreEnvironment.ProjectEnvironment
     ): ExitCode
 }

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

@@ -89,7 +89,8 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             val projectEnvironment =
                 KotlinCoreEnvironment.ProjectEnvironment(
                     rootDisposable,
-                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration)
+                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(rootDisposable, configuration),
+                    configuration
                 )
             projectEnvironment.registerExtensionsFromPlugins(configuration)
 

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

@@ -235,6 +235,7 @@ object FirKotlinToJvmBytecodeCompiler {
             if (commonSession != null) {
                 sourceDependsOnDependencies(listOf(commonSession.moduleData))
             }
+            friendDependencies(module.getFriendPaths())
         }
 
         val commonAnalyzerFacade = commonSession?.let { FirAnalyzerFacade(it, languageVersionSettings, commonKtFiles) }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreDumbUtil.kt.as42

@@ -1,19 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler
-
-import com.intellij.openapi.project.DumbUtil
-
-@Suppress("UnstableApiUsage")
-class KotlinCoreDumbUtil : DumbUtil {
-    override fun <T : Any?> filterByDumbAwarenessHonoringIgnoring(collection: Collection<T>): List<T> =
-        when (collection) {
-            is List<T> -> collection
-            else -> ArrayList(collection)
-        }
-
-    override fun mayUseIndices(): Boolean = false
-}

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

@@ -68,6 +68,7 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_W
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
+import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarFileSystem
 import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.cli.jvm.index.*
 import org.jetbrains.kotlin.cli.jvm.javac.JavacWrapperRegistrar
@@ -92,11 +93,11 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
-import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
@@ -107,17 +108,54 @@ import java.nio.file.FileSystems
 import java.util.zip.ZipFile
 
 class KotlinCoreEnvironment private constructor(
-    val projectEnvironment: JavaCoreProjectEnvironment,
+    val projectEnvironment: ProjectEnvironment,
     private val initialConfiguration: CompilerConfiguration,
     configFiles: EnvironmentConfigFiles
 ) {
 
     class ProjectEnvironment(
         disposable: Disposable,
-        applicationEnvironment: KotlinCoreApplicationEnvironment
+        applicationEnvironment: KotlinCoreApplicationEnvironment,
+        configuration: CompilerConfiguration
     ) :
         KotlinCoreProjectEnvironment(disposable, applicationEnvironment) {
 
+        internal val jarFileSystem: VirtualFileSystem
+
+        init {
+            val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+
+            if (configuration.getBoolean(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM)) {
+                messageCollector?.report(
+                    STRONG_WARNING,
+                    "Using new faster version of JAR FS: it should make your build faster, but the new implementation is experimental"
+                )
+            }
+
+            jarFileSystem = when {
+                configuration.getBoolean(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM) || configuration.getBoolean(CommonConfigurationKeys.USE_FIR) -> {
+                    val fastJarFs = FastJarFileSystem.createIfUnmappingPossible()
+
+                    if (fastJarFs == null) {
+                        messageCollector?.report(
+                            STRONG_WARNING,
+                            "Your JDK doesn't seem to support mapped buffer unmapping, so the slower (old) version of JAR FS will be used"
+                        )
+                        applicationEnvironment.jarFileSystem
+                    } else {
+
+                        Disposer.register(disposable) {
+                            fastJarFs.clearHandlersCache()
+                        }
+
+                        fastJarFs
+                    }
+                }
+
+                else -> applicationEnvironment.jarFileSystem
+            }
+        }
+
         private var extensionRegistered = false
 
         override fun preregisterServices() {
@@ -167,6 +205,13 @@ class KotlinCoreEnvironment private constructor(
 
         val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
 
+        if (configuration.getBoolean(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM)) {
+            messageCollector?.report(
+                STRONG_WARNING,
+                "Using new faster version of JAR FS: it should make your build faster, but the new implementation is experimental"
+            )
+        }
+
         (projectEnvironment as? ProjectEnvironment)?.registerExtensionsFromPlugins(configuration)
         // otherwise consider that project environment is properly configured before passing to the environment
         // TODO: consider some asserts to check important extension points
@@ -391,7 +436,7 @@ class KotlinCoreEnvironment private constructor(
     }
 
     private fun findJarRoot(file: File): VirtualFile? =
-        applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
+        projectEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
 
     private fun getSourceRootsCheckingForDuplicates(): List<KotlinSourceRoot> {
         val uniqueSourceRoots = hashSetOf<String>()
@@ -427,7 +472,7 @@ class KotlinCoreEnvironment private constructor(
         ): KotlinCoreEnvironment {
             setupIdeaStandaloneExecution()
             val appEnv = getOrCreateApplicationEnvironmentForProduction(parentDisposable, configuration)
-            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
+            val projectEnv = ProjectEnvironment(parentDisposable, appEnv, configuration)
             val environment = KotlinCoreEnvironment(projectEnv, configuration, configFiles)
 
             synchronized(APPLICATION_LOCK) {
@@ -438,7 +483,7 @@ class KotlinCoreEnvironment private constructor(
 
         @JvmStatic
         fun createForProduction(
-            projectEnvironment: JavaCoreProjectEnvironment, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
+            projectEnvironment: ProjectEnvironment, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
         ): KotlinCoreEnvironment {
             val environment = KotlinCoreEnvironment(projectEnvironment, configuration, configFiles)
 
@@ -459,7 +504,7 @@ class KotlinCoreEnvironment private constructor(
             val configuration = initialConfiguration.copy()
             // Tests are supposed to create a single project and dispose it right after use
             val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
+            val projectEnv = ProjectEnvironment(parentDisposable, appEnv, configuration)
             return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs)
         }
 
@@ -474,7 +519,7 @@ class KotlinCoreEnvironment private constructor(
         @TestOnly
         fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment {
             val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            return ProjectEnvironment(parentDisposable, appEnv)
+            return ProjectEnvironment(parentDisposable, appEnv, configuration)
         }
 
         // used in the daemon for jar cache cleanup
@@ -538,11 +583,6 @@ class KotlinCoreEnvironment private constructor(
             val applicationEnvironment = KotlinCoreApplicationEnvironment.create(parentDisposable, unitTestMode)
 
             registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
-            // FIX ME WHEN BUNCH 202 REMOVED: this code is required to support compiler bundled to both 202 and 203.
-            // Please, remove "com.intellij.psi.classFileDecompiler" EP registration once 202 is no longer supported by the compiler
-            if (!ApplicationManager.getApplication().extensionArea.hasExtensionPoint("com.intellij.psi.classFileDecompiler")) {
-                registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/core.xml")
-            }
 
             registerApplicationServicesForCLI(applicationEnvironment)
             registerApplicationServices(applicationEnvironment)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42

@@ -1,722 +0,0 @@
-/*
- * 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.cli.jvm.compiler
-
-import com.intellij.codeInsight.ExternalAnnotationsManager
-import com.intellij.codeInsight.InferredAnnotationsManager
-import com.intellij.core.CoreApplicationEnvironment
-import com.intellij.core.CoreJavaFileManager
-import com.intellij.core.JavaCoreProjectEnvironment
-import com.intellij.ide.highlighter.JavaFileType
-import com.intellij.lang.java.JavaParserDefinition
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.application.TransactionGuard
-import com.intellij.openapi.application.TransactionGuardImpl
-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.diagnostic.Logger
-import com.intellij.openapi.extensions.ExtensionsArea
-import com.intellij.openapi.fileTypes.PlainTextFileType
-import com.intellij.openapi.project.DumbUtil
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Disposer
-import com.intellij.openapi.util.io.FileUtilRt
-import com.intellij.openapi.util.text.StringUtil
-import com.intellij.openapi.vfs.*
-import com.intellij.openapi.vfs.impl.ZipHandler
-import com.intellij.psi.PsiElementFinder
-import com.intellij.psi.PsiManager
-import com.intellij.psi.impl.JavaClassSupersImpl
-import com.intellij.psi.impl.PsiElementFinderImpl
-import com.intellij.psi.impl.PsiTreeChangePreprocessor
-import com.intellij.psi.impl.file.impl.JavaFileManager
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.util.JavaClassSupers
-import com.intellij.util.io.URLUtil
-import com.intellij.util.lang.UrlClassLoader
-import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
-import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
-import org.jetbrains.kotlin.asJava.classes.FacadeCache
-import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
-import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.CliModuleVisibilityManagerImpl
-import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
-import org.jetbrains.kotlin.cli.common.extensions.ScriptEvaluationExtension
-import org.jetbrains.kotlin.cli.common.extensions.ShellExtension
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.common.toBooleanLenient
-import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
-import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.cli.jvm.index.*
-import org.jetbrains.kotlin.cli.jvm.javac.JavacWrapperRegistrar
-import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
-import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleResolver
-import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
-import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
-import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
-import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.extensions.*
-import org.jetbrains.kotlin.extensions.internal.CandidateInterceptor
-import org.jetbrains.kotlin.extensions.internal.TypeResolutionInterceptor
-import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.js.translate.extensions.JsSyntheticTranslateExtension
-import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
-import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
-import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
-import org.jetbrains.kotlin.parsing.KotlinParserDefinition
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
-import org.jetbrains.kotlin.resolve.ModuleAnnotationsResolver
-import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
-import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
-import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
-import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
-import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
-import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
-import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
-import org.jetbrains.kotlin.serialization.DescriptorSerializerPlugin
-import org.jetbrains.kotlin.utils.PathUtil
-import java.io.File
-import java.nio.file.FileSystems
-import java.util.zip.ZipFile
-
-class KotlinCoreEnvironment private constructor(
-    val projectEnvironment: JavaCoreProjectEnvironment,
-    initialConfiguration: CompilerConfiguration,
-    configFiles: EnvironmentConfigFiles
-) {
-
-    class ProjectEnvironment(
-        disposable: Disposable, applicationEnvironment: KotlinCoreApplicationEnvironment
-    ) :
-        KotlinCoreProjectEnvironment(disposable, applicationEnvironment) {
-
-        private var extensionRegistered = false
-
-        override fun preregisterServices() {
-            registerProjectExtensionPoints(project.extensionArea)
-        }
-
-        fun registerExtensionsFromPlugins(configuration: CompilerConfiguration) {
-            if (!extensionRegistered) {
-                registerPluginExtensionPoints(project)
-                registerExtensionsFromPlugins(project, configuration)
-                extensionRegistered = true
-            }
-        }
-
-        override fun registerJavaPsiFacade() {
-            with(project) {
-                registerService(
-                    CoreJavaFileManager::class.java,
-                    ServiceManager.getService(this, JavaFileManager::class.java) as CoreJavaFileManager
-                )
-
-                registerKotlinLightClassSupport(project)
-
-                registerService(ExternalAnnotationsManager::class.java, MockExternalAnnotationsManager())
-                registerService(InferredAnnotationsManager::class.java, MockInferredAnnotationsManager())
-            }
-
-            super.registerJavaPsiFacade()
-        }
-    }
-
-    private val sourceFiles = mutableListOf<KtFile>()
-    private val rootsIndex: JvmDependenciesDynamicCompoundIndex
-    private val packagePartProviders = mutableListOf<JvmPackagePartProvider>()
-
-    private val classpathRootsResolver: ClasspathRootsResolver
-    private val initialRoots = ArrayList<JavaRoot>()
-
-    val configuration: CompilerConfiguration = initialConfiguration.apply { setupJdkClasspathRoots(configFiles) }.copy()
-
-    init {
-        PersistentFSConstants::class.java.getDeclaredField("ourMaxIntellisenseFileSize")
-            .apply { isAccessible = true }
-            .setInt(null, FileUtilRt.LARGE_FOR_CONTENT_LOADING)
-
-        val project = projectEnvironment.project
-
-        val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-
-        (projectEnvironment as? ProjectEnvironment)?.registerExtensionsFromPlugins(configuration)
-        // otherwise consider that project environment is properly configured before passing to the environment
-        // TODO: consider some asserts to check important extension points
-
-        project.registerService(DeclarationProviderFactoryService::class.java, CliDeclarationProviderFactoryService(sourceFiles))
-
-        val isJvm = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES
-        project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(isJvm))
-
-        registerProjectServicesForCLI(projectEnvironment)
-
-        registerProjectServices(projectEnvironment.project)
-
-        for (extension in CompilerConfigurationExtension.getInstances(project)) {
-            extension.updateConfiguration(configuration)
-        }
-
-        sourceFiles += createKtFiles(project)
-
-        collectAdditionalSources(project)
-
-        sourceFiles.sortBy { it.virtualFile.path }
-
-        val javaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl
-
-        val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
-        val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
-        val javaModuleFinder = CliJavaModuleFinder(
-            jdkHome?.path?.let { path ->
-                jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
-            },
-            javaFileManager
-        )
-
-        val outputDirectory =
-            configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
-                ?: configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)?.absolutePath
-
-        classpathRootsResolver = ClasspathRootsResolver(
-            PsiManager.getInstance(project),
-            messageCollector,
-            configuration.getList(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES),
-            this::contentRootToVirtualFile,
-            javaModuleFinder,
-            !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
-            outputDirectory?.let(this::findLocalFile),
-            javaFileManager
-        )
-
-        val (initialRoots, javaModules) =
-            classpathRootsResolver.convertClasspathRoots(configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS))
-        this.initialRoots.addAll(initialRoots)
-
-        if (!configuration.getBoolean(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK) && messageCollector != null) {
-            JvmRuntimeVersionsConsistencyChecker.checkCompilerClasspathConsistency(
-                messageCollector,
-                configuration,
-                initialRoots.mapNotNull { (file, type) -> if (type == JavaRoot.RootType.BINARY) file else null }
-            )
-        }
-
-        val (roots, singleJavaFileRoots) =
-            initialRoots.partition { (file) -> file.isDirectory || file.extension != JavaFileType.DEFAULT_EXTENSION }
-
-        // REPL and kapt2 update classpath dynamically
-        rootsIndex = JvmDependenciesDynamicCompoundIndex().apply {
-            addIndex(JvmDependenciesIndexImpl(roots))
-            updateClasspathFromRootsIndex(this)
-        }
-
-        javaFileManager.initialize(
-            rootsIndex,
-            packagePartProviders,
-            SingleJavaFileRootsIndex(singleJavaFileRoots),
-            configuration.getBoolean(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING)
-        )
-
-        project.registerService(
-            JavaModuleResolver::class.java,
-            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList(), project)
-        )
-
-        val finderFactory = CliVirtualFileFinderFactory(rootsIndex)
-        project.registerService(MetadataFinderFactory::class.java, finderFactory)
-        project.registerService(VirtualFileFinderFactory::class.java, finderFactory)
-
-        project.putUserData(APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY, fun(roots: List<File>) {
-            updateClasspath(roots.map { JavaSourceRoot(it, null) })
-        })
-    }
-
-    private fun collectAdditionalSources(project: MockProject) {
-        var unprocessedSources: Collection<KtFile> = sourceFiles
-        val processedSources = HashSet<KtFile>()
-        val processedSourcesByExtension = HashMap<CollectAdditionalSourcesExtension, Collection<KtFile>>()
-        // repeat feeding extensions with sources while new sources a being added
-        var sourceCollectionIterations = 0
-        while (unprocessedSources.isNotEmpty()) {
-            if (sourceCollectionIterations++ > 10) { // TODO: consider using some appropriate global constant
-                throw IllegalStateException("Unable to collect additional sources in reasonable number of iterations")
-            }
-            processedSources.addAll(unprocessedSources)
-            val allNewSources = ArrayList<KtFile>()
-            for (extension in CollectAdditionalSourcesExtension.getInstances(project)) {
-                // do not feed the extension with the sources it returned on the previous iteration
-                val sourcesToProcess = unprocessedSources - (processedSourcesByExtension[extension] ?: emptyList())
-                val newSources = extension.collectAdditionalSourcesAndUpdateConfiguration(sourcesToProcess, configuration, project)
-                if (newSources.isNotEmpty()) {
-                    allNewSources.addAll(newSources)
-                    processedSourcesByExtension[extension] = newSources
-                }
-            }
-            unprocessedSources = allNewSources.filterNot { processedSources.contains(it) }.distinct()
-            sourceFiles += unprocessedSources
-        }
-    }
-
-    fun addKotlinSourceRoots(rootDirs: List<File>) {
-        val roots = rootDirs.map { KotlinSourceRoot(it.absolutePath, isCommon = false) }
-        sourceFiles += createSourceFilesFromSourceRoots(configuration, project, roots)
-    }
-
-    fun createPackagePartProvider(scope: GlobalSearchScope): JvmPackagePartProvider {
-        return JvmPackagePartProvider(configuration.languageVersionSettings, scope).apply {
-            addRoots(initialRoots, configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY))
-            packagePartProviders += this
-            (ModuleAnnotationsResolver.getInstance(project) as CliModuleAnnotationsResolver).addPackagePartProvider(this)
-        }
-    }
-
-    private val VirtualFile.javaFiles: List<VirtualFile>
-        get() = mutableListOf<VirtualFile>().apply {
-            VfsUtilCore.processFilesRecursively(this@javaFiles) { file ->
-                if (file.fileType == JavaFileType.INSTANCE) {
-                    add(file)
-                }
-                true
-            }
-        }
-
-    private val allJavaFiles: List<File>
-        get() = configuration.javaSourceRoots
-            .mapNotNull(this::findLocalFile)
-            .flatMap { it.javaFiles }
-            .map { File(it.canonicalPath) }
-
-    fun registerJavac(
-        javaFiles: List<File> = allJavaFiles,
-        kotlinFiles: List<KtFile> = sourceFiles,
-        arguments: Array<String>? = null,
-        bootClasspath: List<File>? = null,
-        sourcePath: List<File>? = null
-    ): Boolean {
-        return JavacWrapperRegistrar.registerJavac(
-            projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath,
-            LightClassGenerationSupport.getInstance(project), packagePartProviders
-        )
-    }
-
-    private val applicationEnvironment: CoreApplicationEnvironment
-        get() = projectEnvironment.environment
-
-    val project: Project
-        get() = projectEnvironment.project
-
-    internal fun countLinesOfCode(sourceFiles: List<KtFile>): Int =
-        sourceFiles.sumBy { sourceFile ->
-            val text = sourceFile.text
-            StringUtil.getLineBreakCount(text) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1)
-        }
-
-    private fun updateClasspathFromRootsIndex(index: JvmDependenciesIndex) {
-        index.indexedRoots.forEach {
-            projectEnvironment.addSourcesToClasspath(it.file)
-        }
-    }
-
-    fun updateClasspath(contentRoots: List<ContentRoot>): List<File>? {
-        // TODO: add new Java modules to CliJavaModuleResolver
-        val newRoots = classpathRootsResolver.convertClasspathRoots(contentRoots).roots
-
-        if (packagePartProviders.isEmpty()) {
-            initialRoots.addAll(newRoots)
-        } else {
-            for (packagePartProvider in packagePartProviders) {
-                packagePartProvider.addRoots(newRoots, configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY))
-            }
-        }
-
-        return rootsIndex.addNewIndexForRoots(newRoots)?.let { newIndex ->
-            updateClasspathFromRootsIndex(newIndex)
-            newIndex.indexedRoots.mapNotNull { (file) ->
-                VfsUtilCore.virtualToIoFile(VfsUtilCore.getVirtualFileForJar(file) ?: file)
-            }.toList()
-        }.orEmpty()
-    }
-
-    private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? =
-        when (root) {
-            is JvmClasspathRoot ->
-                if (root.file.isFile) findJarRoot(root.file) else findExistingRoot(root, "Classpath entry")
-            is JvmModulePathRoot ->
-                if (root.file.isFile) findJarRoot(root.file) else findExistingRoot(root, "Java module root")
-            is JavaSourceRoot ->
-                findExistingRoot(root, "Java source root")
-            else ->
-                throw IllegalStateException("Unexpected root: $root")
-        }
-
-    internal fun findLocalFile(path: String): VirtualFile? =
-        applicationEnvironment.localFileSystem.findFileByPath(path)
-
-    private fun findExistingRoot(root: JvmContentRoot, rootDescription: String): VirtualFile? {
-        return findLocalFile(root.file.absolutePath).also {
-            if (it == null) {
-                report(STRONG_WARNING, "$rootDescription points to a non-existent location: ${root.file}")
-            }
-        }
-    }
-
-    private fun findJarRoot(file: File): VirtualFile? =
-        applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}")
-
-    private fun getSourceRootsCheckingForDuplicates(): List<KotlinSourceRoot> {
-        val uniqueSourceRoots = hashSetOf<String>()
-        val result = mutableListOf<KotlinSourceRoot>()
-
-        for (root in configuration.kotlinSourceRoots) {
-            if (!uniqueSourceRoots.add(root.path)) {
-                report(STRONG_WARNING, "Duplicate source root: ${root.path}")
-            }
-            result.add(root)
-        }
-
-        return result
-    }
-
-    fun getSourceFiles(): List<KtFile> = sourceFiles
-
-    private fun createKtFiles(project: Project): List<KtFile> =
-        createSourceFilesFromSourceRoots(configuration, project, getSourceRootsCheckingForDuplicates())
-
-    internal fun report(severity: CompilerMessageSeverity, message: String) = configuration.report(severity, message)
-
-    companion object {
-        private val LOG = Logger.getInstance(KotlinCoreEnvironment::class.java)
-
-        private val APPLICATION_LOCK = Object()
-        private var ourApplicationEnvironment: KotlinCoreApplicationEnvironment? = null
-        private var ourProjectCount = 0
-
-        @JvmStatic
-        fun createForProduction(
-            parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
-        ): KotlinCoreEnvironment {
-            setupIdeaStandaloneExecution()
-            val appEnv = getOrCreateApplicationEnvironmentForProduction(parentDisposable, configuration)
-            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
-            val environment = KotlinCoreEnvironment(projectEnv, configuration, configFiles)
-
-            synchronized(APPLICATION_LOCK) {
-                ourProjectCount++
-            }
-            return environment
-        }
-
-        @JvmStatic
-        fun createForProduction(
-            projectEnvironment: JavaCoreProjectEnvironment, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles
-        ): KotlinCoreEnvironment {
-            val environment = KotlinCoreEnvironment(projectEnvironment, configuration, configFiles)
-
-            if (projectEnvironment.environment == applicationEnvironment) {
-                // accounting for core environment disposing
-                synchronized(APPLICATION_LOCK) {
-                    ourProjectCount++
-                }
-            }
-            return environment
-        }
-
-        @TestOnly
-        @JvmStatic
-        fun createForTests(
-            parentDisposable: Disposable, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
-        ): KotlinCoreEnvironment {
-            val configuration = initialConfiguration.copy()
-            // Tests are supposed to create a single project and dispose it right after use
-            val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            val projectEnv = ProjectEnvironment(parentDisposable, appEnv)
-            return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs)
-        }
-
-        @TestOnly
-        @JvmStatic
-        fun createForTests(
-            projectEnvironment: ProjectEnvironment, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
-        ): KotlinCoreEnvironment {
-            return KotlinCoreEnvironment(projectEnvironment, initialConfiguration, extensionConfigs)
-        }
-
-        @TestOnly
-        fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment {
-            val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            return ProjectEnvironment(parentDisposable, appEnv)
-        }
-
-        // used in the daemon for jar cache cleanup
-        val applicationEnvironment: KotlinCoreApplicationEnvironment? get() = ourApplicationEnvironment
-
-        fun getOrCreateApplicationEnvironmentForProduction(
-            parentDisposable: Disposable, configuration: CompilerConfiguration
-        ): KotlinCoreApplicationEnvironment = getOrCreateApplicationEnvironment(parentDisposable, configuration, unitTestMode = false)
-
-        fun getOrCreateApplicationEnvironmentForTests(
-            parentDisposable: Disposable, configuration: CompilerConfiguration
-        ): KotlinCoreApplicationEnvironment = getOrCreateApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-
-        private fun getOrCreateApplicationEnvironment(
-            parentDisposable: Disposable, configuration: CompilerConfiguration, unitTestMode: Boolean
-        ): KotlinCoreApplicationEnvironment {
-            synchronized(APPLICATION_LOCK) {
-                if (ourApplicationEnvironment == null) {
-                    val disposable = Disposer.newDisposable()
-                    ourApplicationEnvironment = createApplicationEnvironment(disposable, configuration, unitTestMode)
-                    ourProjectCount = 0
-                    Disposer.register(disposable, Disposable {
-                        synchronized(APPLICATION_LOCK) {
-                            ourApplicationEnvironment = null
-                        }
-                    })
-                }
-                // Disposing of the environment is unsafe in production then parallel builds are enabled, but turning it off universally
-                // breaks a lot of tests, therefore it is disabled for production and enabled for tests
-                if (System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY).toBooleanLenient() != true) {
-                    // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
-                    // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
-                    Disposer.register(parentDisposable, Disposable {
-                        synchronized(APPLICATION_LOCK) {
-                            if (--ourProjectCount <= 0) {
-                                disposeApplicationEnvironment()
-                            }
-                        }
-                    })
-                }
-
-                return ourApplicationEnvironment!!
-            }
-        }
-
-        private fun disposeApplicationEnvironment() {
-            synchronized(APPLICATION_LOCK) {
-                val environment = ourApplicationEnvironment ?: return
-                ourApplicationEnvironment = null
-                Disposer.dispose(environment.parentDisposable)
-                ZipHandler.clearFileAccessorCache()
-            }
-        }
-
-        private fun createApplicationEnvironment(
-            parentDisposable: Disposable, configuration: CompilerConfiguration, unitTestMode: Boolean
-        ): KotlinCoreApplicationEnvironment {
-            val applicationEnvironment = KotlinCoreApplicationEnvironment.create(parentDisposable, unitTestMode)
-
-            registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
-            registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/core.xml")
-
-            registerApplicationServicesForCLI(applicationEnvironment)
-            registerApplicationServices(applicationEnvironment)
-
-            return applicationEnvironment
-        }
-
-        private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) {
-            fun File.hasConfigFile(configFile: String): Boolean =
-                if (isDirectory) File(this, "META-INF" + File.separator + configFile).exists()
-                else try {
-                    ZipFile(this).use {
-                        it.getEntry("META-INF/$configFile") != null
-                    }
-                } catch (e: Throwable) {
-                    false
-                }
-
-            val pluginRoot: File =
-                configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File)
-                    ?: PathUtil.getResourcePathForClass(this::class.java).takeIf { it.hasConfigFile(configFilePath) }
-                    // hack for load extensions when compiler run directly from project directory (e.g. in tests)
-                    ?: File("compiler/cli/cli-common/resources").takeIf { it.hasConfigFile(configFilePath) }
-                    ?: throw IllegalStateException(
-                        "Unable to find extension point configuration $configFilePath " +
-                                "(cp:\n  ${(Thread.currentThread().contextClassLoader as? UrlClassLoader)?.urls?.joinToString("\n  ") { it.file }})"
-                    )
-
-            CoreApplicationEnvironment.registerExtensionPointAndExtensions(
-                FileSystems.getDefault().getPath(pluginRoot.path),
-                configFilePath,
-                ApplicationManager.getApplication().extensionArea
-            )
-        }
-
-        @JvmStatic
-        @Suppress("MemberVisibilityCanPrivate") // made public for CLI Android Lint
-        fun registerPluginExtensionPoints(project: MockProject) {
-            ExpressionCodegenExtension.registerExtensionPoint(project)
-            SyntheticResolveExtension.registerExtensionPoint(project)
-            SyntheticJavaResolveExtension.registerExtensionPoint(project)
-            ClassBuilderInterceptorExtension.registerExtensionPoint(project)
-            AnalysisHandlerExtension.registerExtensionPoint(project)
-            PackageFragmentProviderExtension.registerExtensionPoint(project)
-            StorageComponentContainerContributor.registerExtensionPoint(project)
-            DeclarationAttributeAltererExtension.registerExtensionPoint(project)
-            PreprocessedVirtualFileFactoryExtension.registerExtensionPoint(project)
-            JsSyntheticTranslateExtension.registerExtensionPoint(project)
-            CompilerConfigurationExtension.registerExtensionPoint(project)
-            CollectAdditionalSourcesExtension.registerExtensionPoint(project)
-            ExtraImportsProviderExtension.registerExtensionPoint(project)
-            IrGenerationExtension.registerExtensionPoint(project)
-            ScriptEvaluationExtension.registerExtensionPoint(project)
-            ShellExtension.registerExtensionPoint(project)
-            TypeResolutionInterceptor.registerExtensionPoint(project)
-            CandidateInterceptor.registerExtensionPoint(project)
-            DescriptorSerializerPlugin.registerExtensionPoint(project)
-        }
-
-        internal fun registerExtensionsFromPlugins(project: MockProject, configuration: CompilerConfiguration) {
-            val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-            for (registrar in configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
-                try {
-                    registrar.registerProjectComponents(project, configuration)
-                } catch (e: AbstractMethodError) {
-                    val message = "The provided plugin ${registrar.javaClass.name} is not compatible with this version of compiler"
-                    // Since the scripting plugin is often discovered in the compiler environment, it is often taken from the incompatible
-                    // location, and in many cases this is not a fatal error, therefore strong warning is generated instead of exception
-                    if (registrar.javaClass.simpleName == "ScriptingCompilerConfigurationComponentRegistrar") {
-                        messageCollector?.report(STRONG_WARNING, "Default scripting plugin is disabled: $message")
-                    } else {
-                        throw IllegalStateException(message, e)
-                    }
-                }
-            }
-        }
-
-
-        private fun registerApplicationServicesForCLI(applicationEnvironment: KotlinCoreApplicationEnvironment) {
-            // ability to get text from annotations xml files
-            applicationEnvironment.registerFileType(PlainTextFileType.INSTANCE, "xml")
-            applicationEnvironment.registerParserDefinition(JavaParserDefinition())
-        }
-
-        // made public for Upsource
-        @Suppress("MemberVisibilityCanBePrivate")
-        @JvmStatic
-        fun registerApplicationServices(applicationEnvironment: KotlinCoreApplicationEnvironment) {
-            with(applicationEnvironment) {
-                registerFileType(KotlinFileType.INSTANCE, "kt")
-                registerFileType(KotlinFileType.INSTANCE, KotlinParserDefinition.STD_SCRIPT_SUFFIX)
-                registerParserDefinition(KotlinParserDefinition())
-                application.registerService(KotlinBinaryClassCache::class.java, KotlinBinaryClassCache())
-                application.registerService(JavaClassSupers::class.java, JavaClassSupersImpl::class.java)
-                application.registerService(TransactionGuard::class.java, TransactionGuardImpl::class.java)
-            }
-        }
-
-        @JvmStatic
-        fun registerProjectExtensionPoints(area: ExtensionsArea) {
-            CoreApplicationEnvironment.registerExtensionPoint(
-                area, PsiTreeChangePreprocessor.EP.name, PsiTreeChangePreprocessor::class.java
-            )
-            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP.name, PsiElementFinder::class.java)
-
-            IdeaExtensionPoints.registerVersionSpecificProjectExtensionPoints(area)
-        }
-
-        // made public for Upsource
-        @JvmStatic
-        @Deprecated("Use registerProjectServices(project) instead.", ReplaceWith("registerProjectServices(projectEnvironment.project)"))
-        fun registerProjectServices(
-            projectEnvironment: JavaCoreProjectEnvironment,
-            @Suppress("UNUSED_PARAMETER") messageCollector: MessageCollector?
-        ) {
-            registerProjectServices(projectEnvironment.project)
-        }
-
-        // made public for Android Lint
-        @JvmStatic
-        fun registerProjectServices(project: MockProject) {
-            with(project) {
-                registerService(KotlinJavaPsiFacade::class.java, KotlinJavaPsiFacade(this))
-                registerService(FacadeCache::class.java, FacadeCache(this))
-                registerService(ModuleAnnotationsResolver::class.java, CliModuleAnnotationsResolver())
-            }
-        }
-
-        private fun registerProjectServicesForCLI(@Suppress("UNUSED_PARAMETER") projectEnvironment: JavaCoreProjectEnvironment) {
-            /**
-             * Note that Kapt may restart code analysis process, and CLI services should be aware of that.
-             * Use PsiManager.getModificationTracker() to ensure that all the data you cached is still valid.
-             */
-        }
-
-        // made public for Android Lint
-        @JvmStatic
-        fun registerKotlinLightClassSupport(project: MockProject) {
-            with(project) {
-                val traceHolder = CliTraceHolder()
-                val cliLightClassGenerationSupport = CliLightClassGenerationSupport(traceHolder, project)
-                val kotlinAsJavaSupport = CliKotlinAsJavaSupport(this, traceHolder)
-                registerService(LightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
-                registerService(CliLightClassGenerationSupport::class.java, cliLightClassGenerationSupport)
-                registerService(KotlinAsJavaSupport::class.java, kotlinAsJavaSupport)
-                registerService(CodeAnalyzerInitializer::class.java, traceHolder)
-                @Suppress("UnstableApiUsage")
-                registerService(DumbUtil::class.java, KotlinCoreDumbUtil())
-
-                // We don't pass Disposable because in some tests, we manually unregister these extensions, and that leads to LOG.error
-                // exception from `ExtensionPointImpl.doRegisterExtension`, because the registered extension can no longer be found
-                // when the project is being disposed.
-                // For example, see the `unregisterExtension` call in `GenerationUtils.compileFilesUsingFrontendIR`.
-                // TODO: refactor this to avoid registering unneeded extensions in the first place, and avoid using deprecated API.
-                @Suppress("DEPRECATION")
-                PsiElementFinder.EP.getPoint(project).registerExtension(JavaElementFinder(this))
-                @Suppress("DEPRECATION")
-                PsiElementFinder.EP.getPoint(project).registerExtension(PsiElementFinderImpl(this))
-            }
-        }
-
-        private fun CompilerConfiguration.setupJdkClasspathRoots(configFiles: EnvironmentConfigFiles) {
-            if (getBoolean(JVMConfigurationKeys.NO_JDK)) return
-
-            val jvmTarget = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES
-            if (!jvmTarget) return
-
-            val jdkHome = get(JVMConfigurationKeys.JDK_HOME)
-            val (javaRoot, classesRoots) = if (jdkHome == null) {
-                val javaHome = File(System.getProperty("java.home"))
-                put(JVMConfigurationKeys.JDK_HOME, javaHome)
-
-                javaHome to PathUtil.getJdkClassesRootsFromCurrentJre()
-            } else {
-                jdkHome to PathUtil.getJdkClassesRoots(jdkHome)
-            }
-
-            if (!CoreJrtFileSystem.isModularJdk(javaRoot)) {
-                if (classesRoots.isEmpty()) {
-                    report(ERROR, "No class roots are found in the JDK path: $javaRoot")
-                } else {
-                    addJvmSdkRoots(classesRoots)
-                }
-            }
-        }
-    }
-}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/FastJarFileSystem.kt

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
+
+import com.intellij.openapi.util.Couple
+import com.intellij.openapi.vfs.DeprecatedVirtualFileSystem
+import com.intellij.openapi.vfs.StandardFileSystems
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.util.containers.ConcurrentFactoryMap
+import com.intellij.util.io.FileAccessorCache
+import java.io.File
+import java.io.IOException
+import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.nio.MappedByteBuffer
+import java.nio.channels.FileChannel
+
+private typealias RandomAccessFileAndBuffer = Pair<RandomAccessFile, MappedByteBuffer>
+
+class FastJarFileSystem private constructor(internal val unmapBuffer: MappedByteBuffer.() -> Unit) : DeprecatedVirtualFileSystem() {
+    private val myHandlers: MutableMap<String, FastJarHandler> =
+        ConcurrentFactoryMap.createMap { key: String -> FastJarHandler(this@FastJarFileSystem, key) }
+
+    internal val cachedOpenFileHandles: FileAccessorCache<File, RandomAccessFileAndBuffer> =
+        object : FileAccessorCache<File, RandomAccessFileAndBuffer>(20, 10) {
+            @Throws(IOException::class)
+            override fun createAccessor(file: File): RandomAccessFileAndBuffer {
+                val randomAccessFile = RandomAccessFile(file, "r")
+                return Pair(randomAccessFile, randomAccessFile.channel.map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length()))
+            }
+
+            @Throws(IOException::class)
+            override fun disposeAccessor(fileAccessor: RandomAccessFileAndBuffer) {
+                fileAccessor.first.close()
+                fileAccessor.second.unmapBuffer()
+            }
+
+            override fun isEqual(val1: File, val2: File): Boolean {
+                return val1 == val2 // reference equality to handle different jars for different ZipHandlers on the same path
+            }
+        }
+
+    override fun getProtocol(): String {
+        return StandardFileSystems.JAR_PROTOCOL
+    }
+
+    override fun findFileByPath(path: String): VirtualFile? {
+        val pair = splitPath(path)
+        return myHandlers[pair.first]!!.findFileByPath(pair.second)
+    }
+
+    override fun refresh(asynchronous: Boolean) {}
+    override fun refreshAndFindFileByPath(path: String): VirtualFile? {
+        return findFileByPath(path)
+    }
+
+    fun clearHandlersCache() {
+        myHandlers.clear()
+        cachedOpenFileHandles.clear()
+    }
+
+    companion object {
+        fun splitPath(path: String): Couple<String> {
+            val separator = path.indexOf("!/")
+            require(separator >= 0) { "Path in JarFileSystem must contain a separator: $path" }
+            val localPath = path.substring(0, separator)
+            val pathInJar = path.substring(separator + 2)
+            return Couple.of(localPath, pathInJar)
+        }
+
+        fun createIfUnmappingPossible(): FastJarFileSystem? {
+            val cleanerCallBack = prepareCleanerCallback() ?: return null
+            return FastJarFileSystem(cleanerCallBack)
+        }
+    }
+}
+
+
+private val IS_PRIOR_9_JRE = System.getProperty("java.specification.version", "").startsWith("1.")
+
+private fun prepareCleanerCallback(): ((ByteBuffer) -> Unit)? {
+    return try {
+        if (IS_PRIOR_9_JRE) {
+            val cleaner = Class.forName("java.nio.DirectByteBuffer").getMethod("cleaner")
+            cleaner.isAccessible = true
+
+            val clean = Class.forName("sun.misc.Cleaner").getMethod("clean")
+            clean.isAccessible = true
+
+            { buffer: ByteBuffer -> clean.invoke(cleaner.invoke(buffer)) }
+        } else {
+            val unsafeClass = try {
+                Class.forName("sun.misc.Unsafe")
+            } catch (ex: Exception) {
+                // jdk.internal.misc.Unsafe doesn't yet have an invokeCleaner() method,
+                // but that method should be added if sun.misc.Unsafe is removed.
+                Class.forName("jdk.internal.misc.Unsafe")
+            }
+
+            val clean = unsafeClass.getMethod("invokeCleaner", ByteBuffer::class.java)
+            clean.isAccessible = true
+
+            val theUnsafeField = unsafeClass.getDeclaredField("theUnsafe")
+            theUnsafeField.isAccessible = true
+
+            val theUnsafe = theUnsafeField.get(null);
+
+            { buffer: ByteBuffer -> clean.invoke(theUnsafe, buffer) }
+        }
+    } catch (ex: Exception) {
+        null
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/FastJarHandler.kt

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
+
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.impl.ZipHandler
+import com.intellij.util.containers.FactoryMap
+import com.intellij.util.text.ByteArrayCharSequence
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.io.RandomAccessFile
+import java.nio.channels.FileChannel
+
+class FastJarHandler(val fileSystem: FastJarFileSystem, path: String) : ZipHandler(path) {
+    private val myRoot: VirtualFile?
+
+    private val ourEntryMap: Map<String, ZipEntryDescription>
+    private val cachedManifest: ByteArray?
+
+    init {
+        RandomAccessFile(file, "r").use { randomAccessFile ->
+            val mappedByteBuffer = randomAccessFile.channel.map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length())
+            try {
+                ourEntryMap = mappedByteBuffer.parseCentralDirectory().associateBy { it.relativePath }
+                cachedManifest = ourEntryMap[MANIFEST_PATH]?.let(mappedByteBuffer::contentsToByteArray)
+            } finally {
+                with(fileSystem) {
+                    mappedByteBuffer.unmapBuffer()
+                }
+            }
+        }
+
+        val entries: MutableMap<EntryInfo, FastJarVirtualFile> = HashMap()
+        val entriesMap = entriesMap
+        val childrenMap = FactoryMap.create<FastJarVirtualFile, MutableList<VirtualFile>> { ArrayList() }
+        for (info in entriesMap.values) {
+            val file = getOrCreateFile(info, entries)
+            val parent = file.parent
+            if (parent != null) {
+                childrenMap[parent]?.add(file)
+            }
+        }
+
+        val rootInfo = getEntryInfo("")
+        myRoot = rootInfo?.let { getOrCreateFile(it, entries) }
+
+        for ((key, childList) in childrenMap) {
+            key.children = childList.toTypedArray()
+        }
+    }
+
+    private fun getOrCreateFile(info: EntryInfo, entries: MutableMap<EntryInfo, FastJarVirtualFile>): FastJarVirtualFile {
+        var file = entries[info]
+        if (file == null) {
+            val parent = info.parent
+            file = FastJarVirtualFile(this, info.shortName,
+                                      if (info.isDirectory) -1 else info.length,
+                                      info.timestamp,
+                                      parent?.let { getOrCreateFile(it, entries) })
+            entries[info] = file
+        }
+        return file
+    }
+
+    fun findFileByPath(pathInJar: String): VirtualFile? {
+        return myRoot?.findFileByRelativePath(pathInJar)
+    }
+
+    @Throws(IOException::class)
+    override fun createEntriesMap(): Map<String, EntryInfo> {
+        val mapToEntryInfo = mutableMapOf<String, EntryInfo>()
+        mapToEntryInfo[""] = EntryInfo("", true, DEFAULT_LENGTH, DEFAULT_TIMESTAMP, null)
+        for (zipEntry in ourEntryMap.values) {
+            getOrCreate(zipEntry, mapToEntryInfo)
+        }
+
+        return mapToEntryInfo
+    }
+
+    private fun getOrCreate(entry: ZipEntryDescription, map: MutableMap<String, EntryInfo>): EntryInfo {
+        var isDirectory = entry.isDirectory
+        var entryName = entry.relativePath
+        if (StringUtil.endsWithChar(entryName, '/')) {
+            entryName = entryName.substring(0, entryName.length - 1)
+            isDirectory = true
+        }
+        if (StringUtil.startsWithChar(entryName, '/') || StringUtil.startsWithChar(entryName, '\\')) {
+            entryName = entryName.substring(1)
+        }
+
+        var info = map[entryName]
+        if (info != null) return info
+
+        val path = splitPathAndFix(entryName)
+
+        val parentInfo = getOrCreateDirectory(path.first, map)
+        if ("." == path.second) {
+            return parentInfo
+        }
+        info = store(map, parentInfo, path.second, isDirectory, entry.uncompressedSize.toLong(), 0, path.third)
+        return info
+    }
+
+    private fun getOrCreateDirectory(entryName: String, map: MutableMap<String, EntryInfo>): EntryInfo {
+        var info = map[entryName]
+
+        if (info == null) {
+            val entry = ourEntryMap["$entryName/"]
+            if (entry != null) {
+                return getOrCreate(entry, map)
+            }
+            val path = splitPathAndFix(entryName)
+            require(entryName != path.first) {
+                "invalid entry name: '" + entryName + "' in " + this.file.absolutePath + "; after split: " + path
+            }
+            val parentInfo = getOrCreateDirectory(path.first, map)
+            info = store(map, parentInfo, path.second, true, DEFAULT_LENGTH, DEFAULT_TIMESTAMP, path.third)
+        }
+
+        return info
+    }
+
+    private fun store(
+        map: MutableMap<String, EntryInfo>,
+        parentInfo: EntryInfo?,
+        shortName: CharSequence,
+        isDirectory: Boolean,
+        size: Long,
+        time: Long,
+        entryName: String
+    ): EntryInfo {
+        val sequence = ByteArrayCharSequence.convertToBytesIfPossible(shortName)
+        val info = EntryInfo(sequence, isDirectory, size, time, parentInfo)
+        map[entryName] = info
+        return info
+    }
+
+    override fun contentsToByteArray(relativePath: String): ByteArray {
+        if (relativePath == MANIFEST_PATH) return cachedManifest ?: throw FileNotFoundException("$file!/$relativePath")
+        val zipEntryDescription = ourEntryMap[relativePath] ?: throw FileNotFoundException("$file!/$relativePath")
+        return fileSystem.cachedOpenFileHandles[file].use {
+            synchronized(it) {
+                it.get().second.contentsToByteArray(zipEntryDescription)
+            }
+        }
+    }
+}
+
+private const val MANIFEST_PATH = "META-INF/MANIFEST.MF"
+
+

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/FastJarVirtualFile.kt

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
+
+import com.intellij.openapi.util.Couple
+import com.intellij.openapi.util.io.BufferExposingByteArrayInputStream
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileSystem
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+
+internal class FastJarVirtualFile(
+    private val myHandler: FastJarHandler,
+    private val myName: CharSequence,
+    private val myLength: Long,
+    private val myTimestamp: Long,
+    parent: FastJarVirtualFile?
+) : VirtualFile() {
+    private val myParent: VirtualFile? = parent
+    private var myChildren = EMPTY_ARRAY
+    fun setChildren(children: Array<VirtualFile>) {
+        myChildren = children
+    }
+
+    override fun getName(): String {
+        return myName.toString()
+    }
+
+    override fun getNameSequence(): CharSequence {
+        return myName
+    }
+
+    override fun getFileSystem(): VirtualFileSystem {
+        return myHandler.fileSystem
+    }
+
+    override fun getPath(): String {
+        if (myParent == null) {
+            return FileUtil.toSystemIndependentName(myHandler.file.path) + "!/"
+        }
+        val parentPath = myParent.path
+        val answer = StringBuilder(parentPath.length + 1 + myName.length)
+        answer.append(parentPath)
+        if (answer[answer.length - 1] != '/') {
+            answer.append('/')
+        }
+        answer.append(myName)
+        return answer.toString()
+    }
+
+    override fun isWritable(): Boolean {
+        return false
+    }
+
+    override fun isDirectory(): Boolean {
+        return myLength < 0
+    }
+
+    override fun isValid(): Boolean {
+        return true
+    }
+
+    override fun getParent(): VirtualFile? {
+        return myParent
+    }
+
+    override fun getChildren(): Array<VirtualFile> {
+        return myChildren
+    }
+
+    @Throws(IOException::class)
+    override fun getOutputStream(requestor: Any, newModificationStamp: Long, newTimeStamp: Long): OutputStream {
+        throw UnsupportedOperationException("JarFileSystem is read-only")
+    }
+
+    @Throws(IOException::class)
+    override fun contentsToByteArray(): ByteArray {
+        val pair: Couple<String> = FastJarFileSystem.splitPath(
+            path
+        )
+        return myHandler.contentsToByteArray(pair.second)
+    }
+
+    override fun getTimeStamp(): Long {
+        return myTimestamp
+    }
+
+    override fun getLength(): Long {
+        return myLength
+    }
+
+    override fun refresh(asynchronous: Boolean, recursive: Boolean, postRunnable: Runnable?) {}
+    @Throws(IOException::class)
+    override fun getInputStream(): InputStream {
+        return BufferExposingByteArrayInputStream(contentsToByteArray())
+    }
+
+    override fun getModificationStamp(): Long {
+        return 0
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/jarfs/ZipImplementation.kt

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.jarfs
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.MappedByteBuffer
+import java.util.zip.Inflater
+
+
+class ZipEntryDescription(
+    val relativePath: String,
+    val compressedSize: Int,
+    val uncompressedSize: Int,
+    val offsetInFile: Int,
+    val compressionKind: CompressionKind,
+    val fileNameSize: Int
+) {
+
+    enum class CompressionKind {
+        PLAIN, DEFLATE
+    }
+
+    val isDirectory get() = uncompressedSize == 0
+}
+
+private const val END_OF_CENTRAL_DIR_SIZE = 22
+private const val LOCAL_FILE_HEADER_EXTRA_OFFSET = 28
+private const val LOCAL_FILE_HEADER_SIZE = LOCAL_FILE_HEADER_EXTRA_OFFSET + 2
+
+fun MappedByteBuffer.contentsToByteArray(
+    zipEntryDescription: ZipEntryDescription
+): ByteArray {
+    order(ByteOrder.LITTLE_ENDIAN)
+    val extraSize =
+        getUnsignedShort(zipEntryDescription.offsetInFile + LOCAL_FILE_HEADER_EXTRA_OFFSET)
+
+    position(
+        zipEntryDescription.offsetInFile + LOCAL_FILE_HEADER_SIZE + zipEntryDescription.fileNameSize + extraSize
+    )
+    val compressed = ByteArray(zipEntryDescription.compressedSize + 1)
+    get(compressed, 0, zipEntryDescription.compressedSize)
+
+    return when (zipEntryDescription.compressionKind) {
+        ZipEntryDescription.CompressionKind.DEFLATE -> {
+            val inflater = Inflater(true)
+            inflater.setInput(compressed, 0, zipEntryDescription.compressedSize)
+
+            val result = ByteArray(zipEntryDescription.uncompressedSize)
+
+            inflater.inflate(result)
+
+            result
+        }
+        ZipEntryDescription.CompressionKind.PLAIN -> compressed.copyOf(zipEntryDescription.compressedSize)
+    }
+}
+
+fun MappedByteBuffer.parseCentralDirectory(): List<ZipEntryDescription> {
+    order(ByteOrder.LITTLE_ENDIAN)
+
+    val endOfCentralDirectoryOffset = (capacity() - END_OF_CENTRAL_DIR_SIZE downTo 0).first { offset ->
+        // header of "End of central directory"
+        getInt(offset) == 0x06054b50
+    }
+
+    val entriesNumber = getUnsignedShort(endOfCentralDirectoryOffset + 10)
+    val offsetOfCentralDirectory = getInt(endOfCentralDirectoryOffset + 16)
+
+    var currentOffset = offsetOfCentralDirectory
+
+    val result = mutableListOf<ZipEntryDescription>()
+    for (i in 0 until entriesNumber) {
+        val headerConst = getInt(currentOffset)
+        require(headerConst == 0x02014b50) {
+            "$i: $headerConst"
+        }
+
+        val versionNeededToExtract =
+            getShort(currentOffset + 6).toInt()
+
+        val compressionMethod = getShort(currentOffset + 10).toInt()
+
+        val compressedSize = getInt(currentOffset + 20)
+        val uncompressedSize = getInt(currentOffset + 24)
+        val fileNameLength = getUnsignedShort(currentOffset + 28).toInt()
+        val extraLength = getUnsignedShort(currentOffset + 30).toInt()
+        val fileCommentLength = getUnsignedShort(currentOffset + 32).toInt()
+
+        val offsetOfFileData = getInt(currentOffset + 42)
+
+        val bytesForName = ByteArray(fileNameLength)
+
+        position(currentOffset + 46)
+        get(bytesForName)
+
+        val name = String(bytesForName)
+
+        currentOffset += 46 + fileNameLength + extraLength + fileCommentLength
+
+        require(versionNeededToExtract == 10 || versionNeededToExtract == 20) {
+            "Unexpected versionNeededToExtract ($versionNeededToExtract) at $name"
+        }
+
+        val compressionKind = when (compressionMethod) {
+            0 -> ZipEntryDescription.CompressionKind.PLAIN
+            8 -> ZipEntryDescription.CompressionKind.DEFLATE
+            else -> error("Unexpected compression method ($compressionMethod) at $name")
+        }
+
+        result += ZipEntryDescription(
+            name, compressedSize, uncompressedSize, offsetOfFileData, compressionKind,
+            fileNameLength
+        )
+    }
+
+    return result
+}
+
+private fun ByteBuffer.getUnsignedShort(offset: Int): Int = java.lang.Short.toUnsignedInt(getShort(offset))

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

@@ -280,11 +280,16 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
     put(JVMConfigurationKeys.USE_TYPE_TABLE, arguments.useTypeTable)
     put(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK, arguments.skipRuntimeVersionCheck)
     put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, arguments.useOldClassFilesReading)
+    put(JVMConfigurationKeys.USE_FAST_JAR_FILE_SYSTEM, arguments.useFastJarFileSystem)
 
     if (arguments.useOldClassFilesReading) {
         messageCollector.report(INFO, "Using the old java class files reading implementation")
     }
 
+    if (arguments.useFastJarFileSystem) {
+        messageCollector.report(INFO, "Using fast Jar FS implementation")
+    }
+
     put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
     put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
     put(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS, arguments.useOldSpilledVarTypeAnalysis)

compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java

@@ -99,6 +99,9 @@ public class JVMConfigurationKeys {
     public static final CompilerConfigurationKey<Boolean> USE_PSI_CLASS_FILES_READING =
             CompilerConfigurationKey.create("use a slower (PSI-based) class files reading implementation");
 
+    public static final CompilerConfigurationKey<Boolean> USE_FAST_JAR_FILE_SYSTEM =
+            CompilerConfigurationKey.create("use a faster JAR filesystem implementation");
+
     public static final CompilerConfigurationKey<Boolean> USE_JAVAC =
             CompilerConfigurationKey.create("use javac [experimental]");
 

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -21,9 +21,7 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.impl.ZipHandler
 import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import org.jetbrains.kotlin.build.DEFAULT_KOTLIN_SOURCE_FILES_EXTENSIONS
-import org.jetbrains.kotlin.build.report.BuildReporter
 import org.jetbrains.kotlin.build.report.RemoteBuildReporter
-import org.jetbrains.kotlin.build.report.RemoteReporter
 import org.jetbrains.kotlin.cli.common.CLICompiler
 import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.ExitCode
@@ -37,10 +35,15 @@ import org.jetbrains.kotlin.cli.common.repl.ReplEvalResult
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarFileSystem
+import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarHandler
 import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.common.*
-import org.jetbrains.kotlin.daemon.report.*
+import org.jetbrains.kotlin.daemon.report.CompileServicesFacadeMessageCollector
+import org.jetbrains.kotlin.daemon.report.DaemonMessageReporter
+import org.jetbrains.kotlin.daemon.report.DaemonMessageReporterPrintStreamAdapter
+import org.jetbrains.kotlin.daemon.report.getBuildReporter
 import org.jetbrains.kotlin.incremental.*
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt

@@ -66,7 +66,8 @@ abstract class KotlinJvmReplServiceBase(
             val projectEnvironment =
                 KotlinCoreEnvironment.ProjectEnvironment(
                     disposable,
-                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(disposable, configuration)
+                    KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForProduction(disposable, configuration),
+                    configuration,
                 )
             ReplFactoryExtension.registerExtensionPoint(projectEnvironment.project)
             projectEnvironment.registerExtensionsFromPlugins(configuration)
@@ -223,4 +224,4 @@ fun CompilerConfiguration.configureScripting(compilerId: CompilerId) {
             error
         )
     }
-}
+}

compiler/daemon/src/org/jetbrains/kotlin/daemon/experimental/CompileServiceServerSideImpl.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.cli.common.repl.ReplCompileResult
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.jarfs.FastJarFileSystem
 import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.CompileServiceImplBase

compiler/fir/analysis-tests/build.gradle.kts

@@ -36,12 +36,7 @@ dependencies {
         includeJars("jna", rootProject = rootProject)
     }
 
-    Platform[202] {
-        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-1") }
-    }
-    Platform[203].orHigher {
-        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
-    }
+    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
     testRuntimeOnly(toolsJar())
 }
 

compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java

@@ -64,6 +64,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         runTest("compiler/fir/analysis-tests/testData/resolve/catchParameter.kt");
     }
 
+    @TestMetadata("classCallInLambda.kt")
+    public void testClassCallInLambda() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/classCallInLambda.kt");
+    }
+
     @TestMetadata("companion.kt")
     public void testCompanion() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/companion.kt");

compiler/fir/analysis-tests/testData/resolve/classCallInLambda.dot

@@ -0,0 +1,59 @@
+digraph classCallInLambda_kt {
+    graph [nodesep=3]
+    node [shape=box penwidth=2]
+    edge [penwidth=2]
+
+    subgraph cluster_0 {
+        color=red
+        0 [label="Enter function test" style="filled" fillcolor=red];
+        subgraph cluster_1 {
+            color=blue
+            1 [label="Enter block"];
+            2 [label="Access variable R|<local>/x|"];
+            3 [label="Postponed enter to lambda"];
+            subgraph cluster_2 {
+                color=blue
+                11 [label="Enter function anonymousFunction" style="filled" fillcolor=red];
+                subgraph cluster_3 {
+                    color=blue
+                    12 [label="Enter block"];
+                    13 [label="Access variable R|<local>/it|"];
+                    14 [label="::class call"];
+                    15 [label="Exit block"];
+                }
+                16 [label="Exit function anonymousFunction" style="filled" fillcolor=red];
+            }
+            4 [label="Call arguments union" style="filled" fillcolor=yellow];
+            5 [label="Postponed exit from lambda"];
+            6 [label="Function call: R|<local>/x|.R|kotlin/let|<R|kotlin/String|, R|kotlin/reflect/KClass<out kotlin/String>|>(...)"];
+            7 [label="Jump: ^test R|<local>/x|.R|kotlin/let|<R|kotlin/String|, R|kotlin/reflect/KClass<out kotlin/String>|>(<L> = let@fun <anonymous>(it: R|kotlin/String|): R|kotlin/reflect/KClass<out kotlin/String>| <inline=Inline, kind=EXACTLY_ONCE>  {
+    ^ <getClass>(R|<local>/it|)
+}
+)"];
+            8 [label="Stub" style="filled" fillcolor=gray];
+            9 [label="Exit block" style="filled" fillcolor=gray];
+        }
+        10 [label="Exit function test" style="filled" fillcolor=red];
+    }
+    0 -> {1};
+    1 -> {2};
+    2 -> {3};
+    3 -> {11};
+    3 -> {5} [color=red];
+    3 -> {11} [style=dashed];
+    4 -> {6} [color=red];
+    5 -> {6} [color=green];
+    6 -> {7};
+    7 -> {10};
+    7 -> {8} [style=dotted];
+    8 -> {9} [style=dotted];
+    9 -> {10} [style=dotted];
+    11 -> {12};
+    12 -> {13};
+    13 -> {14};
+    14 -> {15};
+    15 -> {16};
+    16 -> {4} [color=red];
+    16 -> {5} [color=green];
+
+}

compiler/fir/analysis-tests/testData/resolve/classCallInLambda.fir.txt

@@ -0,0 +1,7 @@
+FILE: classCallInLambda.kt
+    public final fun test(x: R|kotlin/String|): R|kotlin/reflect/KClass<*>| {
+        ^test R|<local>/x|.R|kotlin/let|<R|kotlin/String|, R|kotlin/reflect/KClass<out kotlin/String>|>(<L> = let@fun <anonymous>(it: R|kotlin/String|): R|kotlin/reflect/KClass<out kotlin/String>| <inline=Inline, kind=EXACTLY_ONCE>  {
+            ^ <getClass>(R|<local>/it|)
+        }
+        )
+    }

compiler/fir/analysis-tests/testData/resolve/classCallInLambda.kt

@@ -0,0 +1,7 @@
+// WITH_STDLIB
+// DUMP_CFG
+import kotlin.reflect.KClass
+
+fun test(x: String): KClass<*> {
+    return x.let { it::class }
+}

compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.kt

@@ -7,7 +7,7 @@ interface FirFunctionCall : FirBase
 fun foo(statements: List<FirBase>, arguments: List<FirBase>, explicitReceiver: FirBase): List<FirFunctionCall> {
 
     val firstCalls = with(statements.last() as FirFunctionCall) setCall@{
-        buildList {
+        <!EXPERIMENTAL_API_USAGE_ERROR!>buildList<!> {
             add(this@setCall)
             with(arguments.last() as FirFunctionCall) plusCall@{
                 add(this@plusCall)

compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt

@@ -1,4 +1,4 @@
-fun <T> foo(@BuilderInference block: MutableList<T>.() -> Unit): T = null!!
+fun <T> foo(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: MutableList<T>.() -> Unit): T = null!!
 
 fun takeString(s: String) {}
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceAndCoercionToUnit.kt

@@ -2,7 +2,7 @@ class DropDownComponent<T : Any>(val initialValues: List<T>)
 
 fun test(strings: List<String>) {
     val dropDown = DropDownComponent(
-        initialValues = buildList {
+        initialValues = <!EXPERIMENTAL_API_USAGE_ERROR!>buildList<!> {
             addAll(strings)
         }
     )

compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt

@@ -1,5 +1,5 @@
 fun test_1() {
-    val list = buildList {
+    val list = <!EXPERIMENTAL_API_USAGE_ERROR!>buildList<!> {
         add("")
     }
     takeList(list)
@@ -12,7 +12,7 @@ fun test_2() {
     takeList(list)
 }
 
-fun <E> myBuildList(@BuilderInference builderAction: MutableList<E>.() -> Unit): List<E> {
+fun <E> myBuildList(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> builderAction: MutableList<E>.() -> Unit): List<E> {
     return ArrayList<E>().apply(builderAction)
 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt

@@ -2,7 +2,7 @@ interface KtScope {
     fun getAllNames(): Set<String>
 }
 
-inline fun <E> buildSet(@BuilderInference builderAction: MutableSet<E>.() -> Unit): Set<E> {
+inline fun <E> buildSet(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> builderAction: MutableSet<E>.() -> Unit): Set<E> {
     return null!!
 }
 

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java

@@ -68,6 +68,12 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest {
             runTest("compiler/fir/analysis-tests/testData/resolve/catchParameter.kt");
         }
 
+        @Test
+        @TestMetadata("classCallInLambda.kt")
+        public void testClassCallInLambda() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/classCallInLambda.kt");
+        }
+
         @Test
         @TestMetadata("companion.kt")
         public void testCompanion() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -68,6 +68,12 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             runTest("compiler/fir/analysis-tests/testData/resolve/catchParameter.kt");
         }
 
+        @Test
+        @TestMetadata("classCallInLambda.kt")
+        public void testClassCallInLambda() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/classCallInLambda.kt");
+        }
+
         @Test
         @TestMetadata("companion.kt")
         public void testCompanion() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java

@@ -1103,6 +1103,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
                 runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCall.kt");
             }
 
+            @Test
+            @TestMetadata("ConstructorCallAllowed.kt")
+            public void testConstructorCallAllowed() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCallAllowed.kt");
+            }
+
             @Test
             @TestMetadata("DanglingMixed.kt")
             public void testDanglingMixed() throws Exception {
@@ -31681,6 +31687,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
                 runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningNull.kt");
             }
 
+            @Test
+            @TestMetadata("nonExhaustiveWhenStatement_1_5.kt")
+            public void testNonExhaustiveWhenStatement_1_5() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/when/nonExhaustiveWhenStatement_1_5.kt");
+            }
+
             @Test
             @TestMetadata("nonExhaustiveWhenStatement_1_6.kt")
             public void testNonExhaustiveWhenStatement_1_6() throws Exception {
@@ -34851,6 +34863,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
                 runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt");
             }
 
+            @Test
+            @TestMetadata("experimentalSetter.kt")
+            public void testExperimentalSetter() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt");
+            }
+
             @Test
             @TestMetadata("fullFqNameUsage.kt")
             public void testFullFqNameUsage() throws Exception {
@@ -34935,6 +34953,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
                 runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFileWithVeryExperimentalMarker.kt");
             }
 
+            @Test
+            @TestMetadata("useExperimentalOnStatement.kt")
+            public void testUseExperimentalOnStatement() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnStatement.kt");
+            }
+
             @Test
             @TestMetadata("useExperimentalOnWholeModule.kt")
             public void testUseExperimentalOnWholeModule() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java

@@ -1103,6 +1103,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac
                 runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCall.kt");
             }
 
+            @Test
+            @TestMetadata("ConstructorCallAllowed.kt")
+            public void testConstructorCallAllowed() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCallAllowed.kt");
+            }
+
             @Test
             @TestMetadata("DanglingMixed.kt")
             public void testDanglingMixed() throws Exception {
@@ -31681,6 +31687,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac
                 runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningNull.kt");
             }
 
+            @Test
+            @TestMetadata("nonExhaustiveWhenStatement_1_5.kt")
+            public void testNonExhaustiveWhenStatement_1_5() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/when/nonExhaustiveWhenStatement_1_5.kt");
+            }
+
             @Test
             @TestMetadata("nonExhaustiveWhenStatement_1_6.kt")
             public void testNonExhaustiveWhenStatement_1_6() throws Exception {
@@ -34851,6 +34863,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac
                 runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt");
             }
 
+            @Test
+            @TestMetadata("experimentalSetter.kt")
+            public void testExperimentalSetter() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt");
+            }
+
             @Test
             @TestMetadata("fullFqNameUsage.kt")
             public void testFullFqNameUsage() throws Exception {
@@ -34935,6 +34953,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac
                 runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFileWithVeryExperimentalMarker.kt");
             }
 
+            @Test
+            @TestMetadata("useExperimentalOnStatement.kt")
+            public void testUseExperimentalOnStatement() throws Exception {
+                runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnStatement.kt");
+            }
+
             @Test
             @TestMetadata("useExperimentalOnWholeModule.kt")
             public void testUseExperimentalOnWholeModule() throws Exception {

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -97,7 +97,6 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val UNRESOLVED_LABEL by error<PsiElement>()
         val DESERIALIZATION_ERROR by error<PsiElement>()
         val ERROR_FROM_JAVA_RESOLUTION by error<PsiElement>()
-        val UNKNOWN_CALLABLE_KIND by error<PsiElement>()
         val MISSING_STDLIB_CLASS by error<PsiElement>()
         val NO_THIS by error<PsiElement>()
 
@@ -131,8 +130,6 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
     }
 
     val SUPERTYPES by object : DiagnosticGroup("Supertypes") {
-        val ENUM_AS_SUPERTYPE by error<PsiElement>()
-        val RECURSION_IN_SUPERTYPES by error<PsiElement>()
         val NOT_A_SUPERTYPE by error<PsiElement>()
         val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error<PsiElement>()
         val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error<KtTypeReference> {
@@ -252,7 +249,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<FqName>("optInMarkerFqName")
             parameter<String>("message")
         }
-        val EXPERIMENTAL_API_USAGE_ERROR by error<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+        val EXPERIMENTAL_API_USAGE_ERROR by warning<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<FqName>("optInMarkerFqName")
             parameter<String>("message")
         }
@@ -969,6 +966,8 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val USELESS_IS_CHECK by warning<KtElement> {
             parameter<Boolean>("compileTimeCheckResult")
         }
+        val IS_ENUM_ENTRY by error<KtTypeReference>()
+        val ENUM_ENTRY_AS_TYPE by error<KtTypeReference>(PositioningStrategy.SELECTOR_BY_QUALIFIED)
     }
 
     val WHEN_EXPRESSIONS by object : DiagnosticGroup("When expressions") {

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -120,7 +120,6 @@ object FirErrors {
     val UNRESOLVED_LABEL by error0<PsiElement>()
     val DESERIALIZATION_ERROR by error0<PsiElement>()
     val ERROR_FROM_JAVA_RESOLUTION by error0<PsiElement>()
-    val UNKNOWN_CALLABLE_KIND by error0<PsiElement>()
     val MISSING_STDLIB_CLASS by error0<PsiElement>()
     val NO_THIS by error0<PsiElement>()
     val DEPRECATION_ERROR by error2<PsiElement, FirBasedSymbol<*>, String>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
@@ -138,8 +137,6 @@ object FirErrors {
     val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error1<PsiElement, String>()
 
     // Supertypes
-    val ENUM_AS_SUPERTYPE by error0<PsiElement>()
-    val RECURSION_IN_SUPERTYPES by error0<PsiElement>()
     val NOT_A_SUPERTYPE by error0<PsiElement>()
     val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error0<PsiElement>()
     val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1<KtTypeReference, FirBasedSymbol<*>>()
@@ -217,7 +214,7 @@ object FirErrors {
 
     // OptIn-related
     val EXPERIMENTAL_API_USAGE by warning2<PsiElement, FqName, String>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val EXPERIMENTAL_API_USAGE_ERROR by error2<PsiElement, FqName, String>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val EXPERIMENTAL_API_USAGE_ERROR by warning2<PsiElement, FqName, String>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val EXPERIMENTAL_OVERRIDE by warning2<PsiElement, FqName, String>()
     val EXPERIMENTAL_OVERRIDE_ERROR by error2<PsiElement, FqName, String>()
     val EXPERIMENTAL_IS_NOT_ENABLED by warning0<KtAnnotationEntry>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
@@ -512,6 +509,8 @@ object FirErrors {
     // Casts and is-checks
     val USELESS_CAST by warning0<KtBinaryExpressionWithTypeRHS>(SourceElementPositioningStrategies.AS_TYPE)
     val USELESS_IS_CHECK by warning1<KtElement, Boolean>()
+    val IS_ENUM_ENTRY by error0<KtTypeReference>()
+    val ENUM_ENTRY_AS_TYPE by error0<KtTypeReference>(SourceElementPositioningStrategies.SELECTOR_BY_QUALIFIED)
 
     // When expressions
     val EXPECTED_CONDITION by error0<KtWhenCondition>()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt

@@ -23,6 +23,11 @@ object CommonExpressionCheckers : ExpressionCheckers() {
             FirDeprecationChecker,
         )
 
+    override val qualifiedAccessCheckers: Set<FirQualifiedAccessChecker>
+        get() = setOf(
+            FirOptInUsageAccessChecker,
+        )
+
     override val qualifiedAccessExpressionCheckers: Set<FirQualifiedAccessExpressionChecker>
         get() = setOf(
             FirCallableReferenceChecker,
@@ -115,6 +120,7 @@ object CommonExpressionCheckers : ExpressionCheckers() {
     override val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker>
         get() = setOf(
             FirStandaloneQualifierChecker,
+            FirOptInUsageQualifierChecker,
         )
 
     override val equalityOperatorCallCheckers: Set<FirEqualityOperatorCallChecker>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonTypeCheckers.kt

@@ -12,5 +12,6 @@ object CommonTypeCheckers : TypeCheckers() {
         FirTypeAnnotationChecker,
         FirSuspendModifierChecker,
         FirDeprecatedTypeChecker,
+        FirOptInUsageTypeRefChecker,
     )
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers
 
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
@@ -23,6 +24,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
 import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 private val RETENTION_PARAMETER_NAME = Name.identifier("value")
@@ -79,6 +81,12 @@ fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotationCall? {
     return getAnnotationByFqName(StandardNames.FqNames.target)
 }
 
+fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotationCall? {
+    return annotations.find {
+        (it.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.classId == classId
+    }
+}
+
 fun FirExpression.extractClassesFromArgument(): List<FirRegularClassSymbol> {
     return unfoldArrayOrVararg().mapNotNull {
         if (it !is FirGetClassCall) return@mapNotNull null

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt

@@ -98,7 +98,7 @@ private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession
 }
 
 private fun FirAnnotatedDeclaration.loadWasExperimentalMarkerClasses(): List<FirRegularClassSymbol> {
-    val wasExperimental = getAnnotationByFqName(OptInNames.WAS_EXPERIMENTAL_FQ_NAME) ?: return emptyList()
+    val wasExperimental = getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) ?: return emptyList()
     val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList()
     return annotationClasses.extractClassesFromArgument()
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/AbstractCheckerContext.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.context
+
+import org.jetbrains.kotlin.fir.resolve.SessionHolder
+import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
+
+abstract class AbstractCheckerContext(
+    override val sessionHolder: SessionHolder,
+    override val returnTypeCalculator: ReturnTypeCalculator,
+    override val allInfosSuppressed: Boolean,
+    override val allWarningsSuppressed: Boolean,
+    override val allErrorsSuppressed: Boolean
+) : CheckerContext()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/CheckerContext.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.context
 
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -14,7 +15,9 @@ import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStack
 import org.jetbrains.kotlin.fir.resolve.SessionHolder
+import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
+import org.jetbrains.kotlin.name.Name
 
 abstract class CheckerContext {
     // Services
@@ -26,6 +29,7 @@ abstract class CheckerContext {
     abstract val containingDeclarations: List<FirDeclaration>
     abstract val qualifiedAccessOrAnnotationCalls: List<FirStatement>
     abstract val getClassCalls: List<FirGetClassCall>
+    abstract val annotationContainers: List<FirAnnotationContainer>
 
     // Suppress
     abstract val suppressedDiagnostics: Set<String>
@@ -41,7 +45,25 @@ abstract class CheckerContext {
         allInfosSuppressed: Boolean,
         allWarningsSuppressed: Boolean,
         allErrorsSuppressed: Boolean
-    ): PersistentCheckerContext
+    ): CheckerContext
+
+    abstract fun addImplicitReceiver(name: Name?, value: ImplicitReceiverValue<*>): CheckerContext
+
+    abstract fun addDeclaration(declaration: FirDeclaration): CheckerContext
+
+    abstract fun dropDeclaration()
+
+    abstract fun addQualifiedAccessOrAnnotationCall(qualifiedAccessOrAnnotationCall: FirStatement): CheckerContext
+
+    abstract fun dropQualifiedAccessOrAnnotationCall()
+
+    abstract fun addGetClassCall(getClassCall: FirGetClassCall): CheckerContext
+
+    abstract fun dropGetClassCall()
+
+    abstract fun addAnnotationContainer(annotationContainer: FirAnnotationContainer): CheckerContext
+
+    abstract fun dropAnnotationContainer()
 
     fun isDiagnosticSuppressed(diagnostic: FirDiagnostic): Boolean {
         val factory = diagnostic.factory

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/MutableCheckerContext.kt

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.context
+
+import kotlinx.collections.immutable.PersistentSet
+import kotlinx.collections.immutable.persistentSetOf
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
+import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.resolve.PersistentImplicitReceiverStack
+import org.jetbrains.kotlin.fir.resolve.SessionHolder
+import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
+import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
+import org.jetbrains.kotlin.name.Name
+
+class MutableCheckerContext private constructor(
+    override val implicitReceiverStack: PersistentImplicitReceiverStack,
+    override val containingDeclarations: MutableList<FirDeclaration>,
+    override val qualifiedAccessOrAnnotationCalls: MutableList<FirStatement>,
+    override val getClassCalls: MutableList<FirGetClassCall>,
+    override val annotationContainers: MutableList<FirAnnotationContainer>,
+    sessionHolder: SessionHolder,
+    returnTypeCalculator: ReturnTypeCalculator,
+    override val suppressedDiagnostics: PersistentSet<String>,
+    allInfosSuppressed: Boolean,
+    allWarningsSuppressed: Boolean,
+    allErrorsSuppressed: Boolean
+) : AbstractCheckerContext(sessionHolder, returnTypeCalculator, allInfosSuppressed, allWarningsSuppressed, allErrorsSuppressed) {
+    constructor(sessionHolder: SessionHolder, returnTypeCalculator: ReturnTypeCalculator) : this(
+        PersistentImplicitReceiverStack(),
+        mutableListOf(),
+        mutableListOf(),
+        mutableListOf(),
+        mutableListOf(),
+        sessionHolder,
+        returnTypeCalculator,
+        persistentSetOf(),
+        allInfosSuppressed = false,
+        allWarningsSuppressed = false,
+        allErrorsSuppressed = false
+    )
+
+    override fun addImplicitReceiver(name: Name?, value: ImplicitReceiverValue<*>): MutableCheckerContext {
+        return MutableCheckerContext(
+            implicitReceiverStack.add(name, value),
+            containingDeclarations,
+            qualifiedAccessOrAnnotationCalls,
+            getClassCalls,
+            annotationContainers,
+            sessionHolder,
+            returnTypeCalculator,
+            suppressedDiagnostics,
+            allInfosSuppressed,
+            allWarningsSuppressed,
+            allErrorsSuppressed
+        )
+    }
+
+    override fun addDeclaration(declaration: FirDeclaration): MutableCheckerContext {
+        containingDeclarations.add(declaration)
+        return this
+    }
+
+    override fun dropDeclaration() {
+        containingDeclarations.removeAt(containingDeclarations.size - 1)
+    }
+
+    override fun addQualifiedAccessOrAnnotationCall(qualifiedAccessOrAnnotationCall: FirStatement): MutableCheckerContext {
+        qualifiedAccessOrAnnotationCalls.add(qualifiedAccessOrAnnotationCall)
+        return this
+    }
+
+    override fun dropQualifiedAccessOrAnnotationCall() {
+        qualifiedAccessOrAnnotationCalls.removeAt(qualifiedAccessOrAnnotationCalls.size - 1)
+    }
+
+    override fun addGetClassCall(getClassCall: FirGetClassCall): MutableCheckerContext {
+        getClassCalls.add(getClassCall)
+        return this
+    }
+
+    override fun dropGetClassCall() {
+        getClassCalls.removeAt(getClassCalls.size - 1)
+    }
+
+    override fun addAnnotationContainer(annotationContainer: FirAnnotationContainer): CheckerContext {
+        annotationContainers.add(annotationContainer)
+        return this
+    }
+
+    override fun dropAnnotationContainer() {
+        annotationContainers.removeAt(annotationContainers.size - 1)
+    }
+
+    override fun addSuppressedDiagnostics(
+        diagnosticNames: Collection<String>,
+        allInfosSuppressed: Boolean,
+        allWarningsSuppressed: Boolean,
+        allErrorsSuppressed: Boolean
+    ): MutableCheckerContext {
+        if (diagnosticNames.isEmpty()) return this
+        return MutableCheckerContext(
+            implicitReceiverStack,
+            containingDeclarations,
+            qualifiedAccessOrAnnotationCalls,
+            getClassCalls,
+            annotationContainers,
+            sessionHolder,
+            returnTypeCalculator,
+            suppressedDiagnostics.addAll(diagnosticNames),
+            this.allInfosSuppressed || allInfosSuppressed,
+            this.allWarningsSuppressed || allWarningsSuppressed,
+            this.allErrorsSuppressed || allErrorsSuppressed
+        )
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/PersistentCheckerContext.kt

@@ -9,6 +9,7 @@ import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.PersistentSet
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.persistentSetOf
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -23,18 +24,20 @@ class PersistentCheckerContext private constructor(
     override val containingDeclarations: PersistentList<FirDeclaration>,
     override val qualifiedAccessOrAnnotationCalls: PersistentList<FirStatement>,
     override val getClassCalls: PersistentList<FirGetClassCall>,
-    override val sessionHolder: SessionHolder,
-    override val returnTypeCalculator: ReturnTypeCalculator,
+    override val annotationContainers: PersistentList<FirAnnotationContainer>,
+    sessionHolder: SessionHolder,
+    returnTypeCalculator: ReturnTypeCalculator,
     override val suppressedDiagnostics: PersistentSet<String>,
-    override val allInfosSuppressed: Boolean,
-    override val allWarningsSuppressed: Boolean,
-    override val allErrorsSuppressed: Boolean
-) : CheckerContext() {
+    allInfosSuppressed: Boolean,
+    allWarningsSuppressed: Boolean,
+    allErrorsSuppressed: Boolean
+) : AbstractCheckerContext(sessionHolder, returnTypeCalculator, allInfosSuppressed, allWarningsSuppressed, allErrorsSuppressed) {
     constructor(sessionHolder: SessionHolder, returnTypeCalculator: ReturnTypeCalculator) : this(
         PersistentImplicitReceiverStack(),
         persistentListOf(),
         persistentListOf(),
         persistentListOf(),
+        persistentListOf(),
         sessionHolder,
         returnTypeCalculator,
         persistentSetOf(),
@@ -43,12 +46,13 @@ class PersistentCheckerContext private constructor(
         allErrorsSuppressed = false
     )
 
-    fun addImplicitReceiver(name: Name?, value: ImplicitReceiverValue<*>): PersistentCheckerContext {
+    override fun addImplicitReceiver(name: Name?, value: ImplicitReceiverValue<*>): PersistentCheckerContext {
         return PersistentCheckerContext(
             implicitReceiverStack.add(name, value),
             containingDeclarations,
             qualifiedAccessOrAnnotationCalls,
             getClassCalls,
+            annotationContainers,
             sessionHolder,
             returnTypeCalculator,
             suppressedDiagnostics,
@@ -58,12 +62,13 @@ class PersistentCheckerContext private constructor(
         )
     }
 
-    fun addDeclaration(declaration: FirDeclaration): PersistentCheckerContext {
+    override fun addDeclaration(declaration: FirDeclaration): PersistentCheckerContext {
         return PersistentCheckerContext(
             implicitReceiverStack,
             containingDeclarations.add(declaration),
             qualifiedAccessOrAnnotationCalls,
             getClassCalls,
+            annotationContainers,
             sessionHolder,
             returnTypeCalculator,
             suppressedDiagnostics,
@@ -73,12 +78,16 @@ class PersistentCheckerContext private constructor(
         )
     }
 
-    fun addQualifiedAccessOrAnnotationCall(qualifiedAccessOrAnnotationCall: FirStatement): PersistentCheckerContext {
+    override fun dropDeclaration() {
+    }
+
+    override fun addQualifiedAccessOrAnnotationCall(qualifiedAccessOrAnnotationCall: FirStatement): PersistentCheckerContext {
         return PersistentCheckerContext(
             implicitReceiverStack,
             containingDeclarations,
             this.qualifiedAccessOrAnnotationCalls.add(qualifiedAccessOrAnnotationCall),
             getClassCalls,
+            annotationContainers,
             sessionHolder,
             returnTypeCalculator,
             suppressedDiagnostics,
@@ -88,12 +97,16 @@ class PersistentCheckerContext private constructor(
         )
     }
 
-    fun addGetClassCall(getClassCall: FirGetClassCall): PersistentCheckerContext {
+    override fun dropQualifiedAccessOrAnnotationCall() {
+    }
+
+    override fun addGetClassCall(getClassCall: FirGetClassCall): PersistentCheckerContext {
         return PersistentCheckerContext(
             implicitReceiverStack,
             containingDeclarations,
             qualifiedAccessOrAnnotationCalls,
             getClassCalls.add(getClassCall),
+            annotationContainers,
             sessionHolder,
             returnTypeCalculator,
             suppressedDiagnostics,
@@ -103,6 +116,28 @@ class PersistentCheckerContext private constructor(
         )
     }
 
+    override fun dropGetClassCall() {
+    }
+
+    override fun addAnnotationContainer(annotationContainer: FirAnnotationContainer): PersistentCheckerContext {
+        return PersistentCheckerContext(
+            implicitReceiverStack,
+            containingDeclarations,
+            qualifiedAccessOrAnnotationCalls,
+            getClassCalls,
+            annotationContainers.add(annotationContainer),
+            sessionHolder,
+            returnTypeCalculator,
+            suppressedDiagnostics,
+            allInfosSuppressed,
+            allWarningsSuppressed,
+            allErrorsSuppressed
+        )
+    }
+
+    override fun dropAnnotationContainer() {
+    }
+
     override fun addSuppressedDiagnostics(
         diagnosticNames: Collection<String>,
         allInfosSuppressed: Boolean,
@@ -115,6 +150,7 @@ class PersistentCheckerContext private constructor(
             containingDeclarations,
             qualifiedAccessOrAnnotationCalls,
             getClassCalls,
+            annotationContainers,
             sessionHolder,
             returnTypeCalculator,
             suppressedDiagnostics.addAll(diagnosticNames),

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInAnnotationClassChecker.kt

@@ -13,14 +13,13 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.getAnnotationByFqName
 import org.jetbrains.kotlin.resolve.checkers.Experimentality
 import org.jetbrains.kotlin.resolve.checkers.OptInNames
 
 object FirOptInAnnotationClassChecker : FirRegularClassChecker() {
     override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return
-        if (declaration.getAnnotationByFqName(OptInNames.REQUIRES_OPT_IN_FQ_NAME) == null) return
+        if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) == null) return
         if (declaration.getRetention() == AnnotationRetention.SOURCE) {
             val target = declaration.getRetentionAnnotation()
             reporter.reportOn(target?.source, FirErrors.EXPERIMENTAL_ANNOTATION_WITH_WRONG_RETENTION, context)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt

@@ -31,8 +31,8 @@ object FirClassLiteralChecker : FirGetClassCallChecker() {
         if (source.kind is FirFakeSourceElementKind) return
         val argument = expression.argument
         if (argument is FirResolvedQualifier) {
-            val fqName = argument.classId?.asSingleFqName()
-            if (fqName in OptInNames.EXPERIMENTAL_FQ_NAMES || fqName in OptInNames.USE_EXPERIMENTAL_FQ_NAMES) {
+            val classId = argument.classId
+            if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) {
                 reporter.reportOn(argument.source, FirErrors.EXPERIMENTAL_CAN_ONLY_BE_USED_AS_ANNOTATION, context)
             }
         }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt

@@ -23,9 +23,9 @@ import org.jetbrains.kotlin.resolve.checkers.OptInNames
 object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() {
     override fun check(expression: FirAnnotationCall, context: CheckerContext, reporter: DiagnosticReporter) {
         val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return
-        val fqName = lookupTag.classId.asSingleFqName()
-        val isMarker = fqName == OptInNames.REQUIRES_OPT_IN_FQ_NAME
-        val isOptIn = fqName == OptInNames.OPT_IN_FQ_NAME
+        val classId = lookupTag.classId
+        val isMarker = classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID
+        val isOptIn = classId == OptInNames.OPT_IN_CLASS_ID
         if (isMarker || isOptIn) {
             checkUsageOfKotlinExperimentalOrUseExperimental(expression.source, context, reporter)
             if (isOptIn) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.expression
+
+import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
+import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
+import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+
+object FirOptInUsageAccessChecker : FirQualifiedAccessChecker() {
+    override fun check(expression: FirQualifiedAccess, context: CheckerContext, reporter: DiagnosticReporter) {
+        val sourceKind = expression.source?.kind
+        if (sourceKind is FirFakeSourceElementKind.DataClassGeneratedMembers ||
+            sourceKind is FirFakeSourceElementKind.PropertyFromParameter
+        ) return
+        val reference = expression.calleeReference as? FirResolvedNamedReference ?: return
+        val resolvedSymbol = reference.resolvedSymbol
+        with(FirOptInUsageBaseChecker) {
+            if (expression is FirVariableAssignment && resolvedSymbol is FirPropertySymbol) {
+                val experimentalities = resolvedSymbol.loadExperimentalities(context, fromSetter = true) +
+                        loadExperimentalitiesFromTypeArguments(context, expression.typeArguments)
+                reportNotAcceptedExperimentalities(experimentalities, expression.lValue, context, reporter)
+                return
+            }
+            val experimentalities = resolvedSymbol.loadExperimentalities(context, fromSetter = false) +
+                    loadExperimentalitiesFromTypeArguments(context, expression.typeArguments)
+            reportNotAcceptedExperimentalities(experimentalities, expression, context, reporter)
+        }
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt

@@ -5,35 +5,237 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.expression
 
+import org.jetbrains.kotlin.config.AnalysisFlags
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.checkers.*
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.findArgumentByName
-import org.jetbrains.kotlin.fir.declarations.getAnnotationByFqName
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirConstExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.resolve.toFirRegularClass
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenFunctions
+import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenProperties
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.checkers.Experimentality
 import org.jetbrains.kotlin.resolve.checkers.OptInNames
+import org.jetbrains.kotlin.utils.SmartSet
+import org.jetbrains.kotlin.utils.addIfNotNull
+
+object FirOptInUsageBaseChecker {
+    data class Experimentality(val annotationClassId: ClassId, val severity: Severity, val message: String?) {
+        enum class Severity { WARNING, ERROR }
+        companion object {
+            val DEFAULT_SEVERITY = Severity.ERROR
+        }
+    }
 
-internal object FirOptInUsageBaseChecker {
     fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(): Experimentality? {
         ensureResolved(FirResolvePhase.BODY_RESOLVE)
         @OptIn(SymbolInternals::class)
         return fir.loadExperimentalityForMarkerAnnotation()
     }
 
+    fun loadExperimentalitiesFromTypeArguments(
+        context: CheckerContext,
+        typeArguments: List<FirTypeProjection>
+    ): Set<Experimentality> {
+        if (typeArguments.isEmpty()) return emptySet()
+        return loadExperimentalitiesFromConeArguments(context, typeArguments.map { it.toConeTypeProjection() })
+    }
+
+    fun loadExperimentalitiesFromConeArguments(
+        context: CheckerContext,
+        typeArguments: List<ConeTypeProjection>
+    ): Set<Experimentality> {
+        if (typeArguments.isEmpty()) return emptySet()
+        val result = SmartSet.create<Experimentality>()
+        typeArguments.forEach {
+            if (!it.isStarProjection) it.type?.addExperimentalities(context, result)
+        }
+        return result
+    }
+
+    fun FirBasedSymbol<*>.loadExperimentalities(
+        context: CheckerContext, fromSetter: Boolean
+    ): Set<Experimentality> = loadExperimentalities(
+        context, knownExperimentalities = null, visited = mutableSetOf(), fromSetter
+    )
+
+    @OptIn(SymbolInternals::class)
+    private fun FirBasedSymbol<*>.loadExperimentalities(
+        context: CheckerContext,
+        knownExperimentalities: SmartSet<Experimentality>?,
+        visited: MutableSet<FirAnnotatedDeclaration>,
+        fromSetter: Boolean,
+    ): Set<Experimentality> {
+        ensureResolved(FirResolvePhase.STATUS)
+        val fir = this.fir as? FirAnnotatedDeclaration ?: return emptySet()
+        if (!visited.add(fir)) return emptySet()
+        val result = knownExperimentalities ?: SmartSet.create()
+        val session = context.session
+        if (fir is FirCallableDeclaration) {
+            val parentClassSymbol = fir.containingClass()?.toSymbol(session) as? FirRegularClassSymbol
+            if (fir.isSubstitutionOrIntersectionOverride) {
+                parentClassSymbol?.ensureResolved(FirResolvePhase.STATUS)
+                val parentClassScope = parentClassSymbol?.unsubstitutedScope(context)
+                if (this is FirNamedFunctionSymbol) {
+                    parentClassScope?.processDirectlyOverriddenFunctions(this) {
+                        it.loadExperimentalities(context, result, visited, fromSetter = false)
+                        ProcessorAction.NEXT
+                    }
+                } else if (this is FirPropertySymbol) {
+                    parentClassScope?.processDirectlyOverriddenProperties(this) {
+                        it.loadExperimentalities(context, result, visited, fromSetter)
+                        ProcessorAction.NEXT
+                    }
+                }
+            }
+            if (fir !is FirConstructor) {
+                // Without coneTypeSafe v fails in MT test (FirRenderer.kt)
+                fir.returnTypeRef.coneTypeSafe<ConeKotlinType>().addExperimentalities(context, result, visited)
+                fir.receiverTypeRef?.coneType.addExperimentalities(context, result, visited)
+                if (fir is FirSimpleFunction) {
+                    fir.valueParameters.forEach {
+                        it.returnTypeRef.coneType.addExperimentalities(context, result, visited)
+                    }
+                }
+            }
+            parentClassSymbol?.loadExperimentalities(context, result, visited, fromSetter = false)
+            if (fromSetter && this is FirPropertySymbol) {
+                setterSymbol?.loadExperimentalities(context, result, visited, fromSetter = false)
+            }
+        } else if (this is FirRegularClassSymbol && fir is FirRegularClass && !fir.isLocal) {
+            val parentClassSymbol = outerClassSymbol(context)
+            parentClassSymbol?.loadExperimentalities(context, result, visited, fromSetter = false)
+        }
+
+        for (annotation in fir.annotations) {
+            val annotationType = annotation.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()
+            if (annotation.useSiteTarget != AnnotationUseSiteTarget.PROPERTY_SETTER || fromSetter) {
+                result.addIfNotNull(
+                    annotationType?.lookupTag?.toFirRegularClass(
+                        session
+                    )?.loadExperimentalityForMarkerAnnotation()
+                )
+            }
+        }
+
+        if (fir is FirTypeAlias) {
+            fir.expandedTypeRef.coneType.addExperimentalities(context, result, visited)
+        }
+
+        if (fir.getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) != null) {
+            val accessibility = fir.checkSinceKotlinVersionAccessibility(context)
+            if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) {
+                accessibility.markerClasses.forEach {
+                    it.ensureResolved(FirResolvePhase.STATUS)
+                    result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation())
+                }
+            }
+        }
+
+        // TODO: getAnnotationsOnContainingModule
+        return result
+    }
+
+    private fun ConeKotlinType?.addExperimentalities(
+        context: CheckerContext,
+        result: SmartSet<Experimentality>,
+        visited: MutableSet<FirAnnotatedDeclaration> = mutableSetOf()
+    ) {
+        if (this !is ConeClassLikeType) return
+        lookupTag.toSymbol(context.session)?.loadExperimentalities(
+            context, result, visited, fromSetter = false
+        )
+        fullyExpandedType(context.session).typeArguments.forEach {
+            if (!it.isStarProjection) it.type?.addExperimentalities(context, result, visited)
+        }
+    }
+
     private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(): Experimentality? {
-        val experimental = getAnnotationByFqName(OptInNames.REQUIRES_OPT_IN_FQ_NAME) ?: return null
+        val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID)
+            ?: return null
 
         val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression
         val levelName = (levelArgument?.calleeReference as? FirResolvedNamedReference)?.name?.asString()
         val level = OptInLevel.values().firstOrNull { it.name == levelName } ?: OptInLevel.DEFAULT
         val message = (experimental.findArgumentByName(MESSAGE) as? FirConstExpression<*>)?.value as? String
-        return Experimentality(symbol.classId.asSingleFqName(), level.severity, message)
+        return Experimentality(symbol.classId, level.severity, message)
+    }
+
+    fun reportNotAcceptedExperimentalities(
+        experimentalities: Collection<Experimentality>,
+        element: FirElement,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ) {
+        for ((annotationClassId, severity, message) in experimentalities) {
+            if (!isExperimentalityAcceptableInContext(annotationClassId, context)) {
+                val diagnostic = when (severity) {
+                    Experimentality.Severity.WARNING -> FirErrors.EXPERIMENTAL_API_USAGE
+                    Experimentality.Severity.ERROR -> FirErrors.EXPERIMENTAL_API_USAGE_ERROR
+                }
+                val reportedMessage = message ?: when (severity) {
+                    Experimentality.Severity.WARNING -> "This declaration is experimental and its usage should be marked"
+                    Experimentality.Severity.ERROR -> "This declaration is experimental and its usage must be marked"
+                }
+                reporter.reportOn(element.source, diagnostic, annotationClassId.asSingleFqName(), reportedMessage, context)
+            }
+        }
+    }
+
+    private fun isExperimentalityAcceptableInContext(
+        annotationClassId: ClassId,
+        context: CheckerContext
+    ): Boolean {
+        val languageVersionSettings = context.session.languageVersionSettings
+        val fqNameAsString = annotationClassId.asFqNameString()
+        if (fqNameAsString in languageVersionSettings.getFlag(AnalysisFlags.useExperimental)) {
+            return true
+        }
+        for (annotationContainer in context.annotationContainers) {
+            if (annotationContainer.isExperimentalityAcceptable(annotationClassId)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun FirAnnotationContainer.isExperimentalityAcceptable(annotationClassId: ClassId): Boolean {
+        return getAnnotationByClassId(annotationClassId) != null || isAnnotatedWithUseExperimentalOf(annotationClassId)
+    }
+
+    private fun FirAnnotationContainer.isAnnotatedWithUseExperimentalOf(annotationClassId: ClassId): Boolean {
+        for (annotation in annotations) {
+            val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType
+            if (coneType?.lookupTag?.classId != OptInNames.OPT_IN_CLASS_ID) {
+                continue
+            }
+            val annotationClasses = annotation.findArgumentByName(OptInNames.USE_EXPERIMENTAL_ANNOTATION_CLASS) ?: continue
+            if (annotationClasses.extractClassesFromArgument().any { it.classId == annotationClassId }) {
+                return true
+            }
+        }
+        return false
     }
 
     private val LEVEL = Name.identifier("level")

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageQualifierChecker.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.expression
+
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
+
+object FirOptInUsageQualifierChecker : FirResolvedQualifierChecker() {
+    override fun check(expression: FirResolvedQualifier, context: CheckerContext, reporter: DiagnosticReporter) {
+        val symbol = expression.symbol ?: return
+        with(FirOptInUsageBaseChecker) {
+            val experimentalities = symbol.loadExperimentalities(context, fromSetter = false)
+            reportNotAcceptedExperimentalities(experimentalities, expression, context, reporter)
+        }
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.type
+
+import org.jetbrains.kotlin.fir.FirRealSourceElementKind
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirOptInUsageBaseChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationByClassId
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPERIMENTAL_CAN_ONLY_BE_USED_AS_ANNOTATION
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPERIMENTAL_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_USE_EXPERIMENTAL
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.symbols.SymbolInternals
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.coneTypeSafe
+import org.jetbrains.kotlin.resolve.checkers.OptInNames
+
+object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
+    @OptIn(SymbolInternals::class)
+    override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) {
+        val source = typeRef.source
+        if (source?.kind !is FirRealSourceElementKind) return
+        val coneType = typeRef.coneTypeSafe<ConeClassLikeType>() ?: return
+        val symbol = coneType.lookupTag.toSymbol(context.session) ?: return
+        symbol.ensureResolved(FirResolvePhase.STATUS)
+        val classId = symbol.classId
+        val lastAnnotationCall = context.qualifiedAccessOrAnnotationCalls.lastOrNull() as? FirAnnotationCall
+        if (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) {
+            if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) {
+                reporter.reportOn(source, EXPERIMENTAL_CAN_ONLY_BE_USED_AS_ANNOTATION, context)
+            } else if (symbol is FirRegularClassSymbol && symbol.fir.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) != null) {
+                reporter.reportOn(source, EXPERIMENTAL_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_USE_EXPERIMENTAL, context)
+            }
+        }
+
+        with(FirOptInUsageBaseChecker) {
+            val experimentalities = symbol.loadExperimentalities(context, fromSetter = false) +
+                    loadExperimentalitiesFromConeArguments(context, coneType.typeArguments.toList())
+            reportNotAcceptedExperimentalities(experimentalities, typeRef, context, reporter)
+        }
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/util/firCheckersUtils.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers.util
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
@@ -15,7 +14,7 @@ fun FirElement.checkChildrenWithCustomVisitor(
     parentContext: CheckerContext,
     visitorVoid: FirVisitor<Unit, CheckerContext>
 ) {
-    val collectingVisitor = object : AbstractDiagnosticCollectorVisitor(parentContext as PersistentCheckerContext) {
+    val collectingVisitor = object : AbstractDiagnosticCollectorVisitor(parentContext) {
         override fun checkElement(element: FirElement) {
             element.accept(visitorVoid, context)
         }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.PrivateForInline
-import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.expressions.*
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.name.Name
 
 abstract class AbstractDiagnosticCollectorVisitor(
-    @set:PrivateForInline var context: PersistentCheckerContext,
+    @set:PrivateForInline var context: CheckerContext,
 ) : FirDefaultVisitor<Unit, Nothing?>() {
 
     protected open fun shouldVisitDeclaration(declaration: FirDeclaration) = true
@@ -43,14 +43,14 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: Nothing?) {
-        withSuppressedDiagnostics(annotationContainer) {
+        withAnnotationContainer(annotationContainer) {
             checkElement(annotationContainer)
             visitNestedElements(annotationContainer)
         }
     }
 
     private fun visitJump(loopJump: FirLoopJump) {
-        withSuppressedDiagnostics(loopJump) {
+        withAnnotationContainer(loopJump) {
             checkElement(loopJump)
             loopJump.target.labeledElement.takeIf { it is FirErrorLoop }?.accept(this, null)
         }
@@ -72,7 +72,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) {
-        withSuppressedDiagnostics(regularClass) {
+        withAnnotationContainer(regularClass) {
             visitClassAndChildren(regularClass, regularClass.defaultType())
         }
     }
@@ -82,19 +82,19 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?) {
-        withSuppressedDiagnostics(anonymousObject) {
+        withAnnotationContainer(anonymousObject) {
             visitClassAndChildren(anonymousObject, anonymousObject.defaultType())
         }
     }
 
     override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?) {
-        withSuppressedDiagnostics(simpleFunction) {
+        withAnnotationContainer(simpleFunction) {
             visitWithDeclarationAndReceiver(simpleFunction, simpleFunction.name, simpleFunction.receiverTypeRef)
         }
     }
 
     override fun visitConstructor(constructor: FirConstructor, data: Nothing?) {
-        withSuppressedDiagnostics(constructor) {
+        withAnnotationContainer(constructor) {
             visitWithDeclaration(constructor)
         }
     }
@@ -104,7 +104,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Nothing?) {
-        withSuppressedDiagnostics(anonymousFunction) {
+        withAnnotationContainer(anonymousFunction) {
             val labelName = anonymousFunction.label?.name?.let { Name.identifier(it) }
             visitWithDeclarationAndReceiver(
                 anonymousFunction,
@@ -115,13 +115,13 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     override fun visitProperty(property: FirProperty, data: Nothing?) {
-        withSuppressedDiagnostics(property) {
+        withAnnotationContainer(property) {
             visitWithDeclaration(property)
         }
     }
 
     override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) {
-        withSuppressedDiagnostics(typeAlias) {
+        withAnnotationContainer(typeAlias) {
             visitWithDeclaration(typeAlias)
         }
     }
@@ -129,26 +129,26 @@ abstract class AbstractDiagnosticCollectorVisitor(
     override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) {
         if (propertyAccessor !is FirDefaultPropertyAccessor) {
             val property = context.containingDeclarations.last() as FirProperty
-            withSuppressedDiagnostics(propertyAccessor) {
+            withAnnotationContainer(propertyAccessor) {
                 visitWithDeclarationAndReceiver(propertyAccessor, property.name, property.receiverTypeRef)
             }
         }
     }
 
     override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) {
-        withSuppressedDiagnostics(valueParameter) {
+        withAnnotationContainer(valueParameter) {
             visitWithDeclaration(valueParameter)
         }
     }
 
     override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) {
-        withSuppressedDiagnostics(enumEntry) {
+        withAnnotationContainer(enumEntry) {
             visitWithDeclaration(enumEntry)
         }
     }
 
     override fun visitFile(file: FirFile, data: Nothing?) {
-        withSuppressedDiagnostics(file) {
+        withAnnotationContainer(file) {
             visitWithDeclaration(file)
         }
     }
@@ -158,14 +158,14 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     override fun visitBlock(block: FirBlock, data: Nothing?) {
-        withSuppressedDiagnostics(block) {
+        withAnnotationContainer(block) {
             visitExpression(block, data)
         }
     }
 
     override fun visitTypeRef(typeRef: FirTypeRef, data: Nothing?) {
         if (typeRef.source != null && typeRef.source?.kind !is FirFakeSourceElementKind) {
-            withSuppressedDiagnostics(typeRef) {
+            withAnnotationContainer(typeRef) {
                 checkElement(typeRef)
                 visitNestedElements(typeRef)
             }
@@ -185,7 +185,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
         //if we don't visit resolved type we can't make any diagnostics on them
         //so here we check resolvedTypeRef
         if (resolvedTypeRef.type !is ConeClassErrorType) {
-            withSuppressedDiagnostics(resolvedTypeRef) {
+            withAnnotationContainer(resolvedTypeRef) {
                 checkElement(resolvedTypeRef)
             }
         }
@@ -256,6 +256,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
         try {
             return block()
         } finally {
+            existingContext.dropQualifiedAccessOrAnnotationCall()
             context = existingContext
         }
     }
@@ -268,6 +269,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
         try {
             return block()
         } finally {
+            existingContext.dropGetClassCall()
             context = existingContext
         }
     }
@@ -280,6 +282,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
         try {
             return block()
         } finally {
+            existingContext.dropDeclaration()
             context = existingContext
         }
     }
@@ -309,12 +312,18 @@ abstract class AbstractDiagnosticCollectorVisitor(
 
 
     @OptIn(PrivateForInline::class)
-    inline fun <R> withSuppressedDiagnostics(annotationContainer: FirAnnotationContainer, block: () -> R): R {
+    inline fun <R> withAnnotationContainer(annotationContainer: FirAnnotationContainer, block: () -> R): R {
         val existingContext = context
         addSuppressedDiagnosticsToContext(annotationContainer)
+        if (annotationContainer.annotations.isNotEmpty()) {
+            context = context.addAnnotationContainer(annotationContainer)
+        }
         return try {
             block()
         } finally {
+            if (annotationContainer.annotations.isNotEmpty()) {
+                existingContext.dropAnnotationContainer()
+            }
             context = existingContext
         }
     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/CheckerRunningDiagnosticCollectorVisitor.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.fir.analysis.collectors
 
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
 
 open class CheckerRunningDiagnosticCollectorVisitor(
-    context: PersistentCheckerContext,
+    context: CheckerContext,
     protected val components: List<AbstractDiagnosticCollectorComponent>
 ) : AbstractDiagnosticCollectorVisitor(context) {
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt

@@ -6,15 +6,10 @@
 package org.jetbrains.kotlin.fir.analysis.collectors
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.context.MutableCheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
-import org.jetbrains.kotlin.fir.analysis.diagnostics.impl.BaseDiagnosticReporter
-import org.jetbrains.kotlin.fir.analysis.diagnostics.impl.DiagnosticReporterWithSuppress
-import org.jetbrains.kotlin.fir.analysis.diagnostics.impl.SimpleDiagnosticReporter
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.SessionHolder
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve
 
 class SimpleDiagnosticsCollector(
@@ -24,7 +19,7 @@ class SimpleDiagnosticsCollector(
 ) : AbstractDiagnosticCollector(session, scopeSession, createComponents) {
     override fun createVisitor(components: List<AbstractDiagnosticCollectorComponent>): CheckerRunningDiagnosticCollectorVisitor {
         return CheckerRunningDiagnosticCollectorVisitor(
-            PersistentCheckerContext(
+            MutableCheckerContext(
                 this,
                 ReturnTypeCalculatorForFullBodyResolve()
             ),

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt

@@ -131,7 +131,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATION_ERROR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DESERIALIZATION_ERROR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DYNAMIC_UPPER_BOUND
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EMPTY_RANGE
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ENUM_AS_SUPERTYPE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ENUM_ENTRY_AS_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EQUALITY_NOT_APPLICABLE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EQUALITY_NOT_APPLICABLE_WARNING
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ERROR_FROM_JAVA_RESOLUTION
@@ -224,6 +224,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INTERFACE_WITH_SU
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_IF_AS_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_TYPE_OF_ANNOTATION_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVISIBLE_REFERENCE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.IS_ENUM_ENTRY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ITERATOR_AMBIGUITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.LEAKED_IN_PLACE_LAMBDA
@@ -305,7 +306,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROTECTED_CONSTRU
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_IMPLICIT_TYPES
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_INLINE
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_SUPERTYPES
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSIVE_TYPEALIAS_EXPANSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDECLARATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_ANNOTATION_TARGET
@@ -491,8 +491,6 @@ class FirDefaultErrorMessages {
             map.put(ILLEGAL_SELECTOR, "The expression cannot be a selector (occur after a dot)")
 
             // Supertypes
-            map.put(ENUM_AS_SUPERTYPE, "Enum as supertype")
-            map.put(RECURSION_IN_SUPERTYPES, "Recursion in supertypes")
             map.put(NOT_A_SUPERTYPE, "Not an immediate supertype")
             map.put(SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE, "Superclass is not accessible from interface")
             map.put(
@@ -1280,6 +1278,8 @@ class FirDefaultErrorMessages {
             // Casts and is-checks
             map.put(USELESS_CAST, "No cast needed")
             map.put(USELESS_IS_CHECK, "Check for instance is always ''{0}''", TO_STRING)
+            map.put(IS_ENUM_ENTRY, "'is' over enum entry is not allowed, use comparison instead")
+            map.put(ENUM_ENTRY_AS_TYPE, "Use of enum entry names as types is not allowed, use enum type instead")
 
             // When expressions
             map.put(EXPECTED_CONDITION, "Expected condition of type Boolean")

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt

@@ -20,8 +20,7 @@ import org.jetbrains.kotlin.lexer.KtTokens.VISIBILITY_MODIFIERS
 import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
 import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
 import org.jetbrains.kotlin.psi.stubs.elements.KtStringTemplateExpressionElementType
-import org.jetbrains.kotlin.psi.stubs.elements.KtValueArgumentElementType
-import org.jetbrains.kotlin.psi.stubs.elements.KtValueArgumentListElementType
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 
 object LightTreePositioningStrategies {
     val DEFAULT = object : LightTreePositioningStrategy() {
@@ -462,17 +461,36 @@ object LightTreePositioningStrategies {
                     return markElement(it, startOffset, endOffset, tree, node)
                 }
             }
-            if (node.tokenType !in KtTokens.QUALIFIED_ACCESS) {
+            if (node.tokenType in KtTokens.QUALIFIED_ACCESS) {
+                val selector = tree.selector(node)
+                if (selector != null) {
+                    return markElement(selector, startOffset, endOffset, tree, node)
+                }
                 return super.mark(node, startOffset, endOffset, tree)
             }
-            val selector = tree.selector(node)
-            if (selector != null) {
-                return markElement(selector, startOffset, endOffset, tree, node)
+            if (node.tokenType == KtNodeTypes.TYPE_REFERENCE) {
+                val typeElement = tree.findChildByType(node, KtStubElementTypes.TYPE_ELEMENT_TYPES)
+                if (typeElement != null) {
+                    val referencedTypeExpression = tree.referencedTypeExpression(typeElement)
+                    if (referencedTypeExpression != null) {
+                        return markElement(referencedTypeExpression, startOffset, endOffset, tree, node)
+                    }
+                }
             }
             return super.mark(node, startOffset, endOffset, tree)
         }
     }
 
+    private fun FlyweightCapableTreeStructure<LighterASTNode>.referencedTypeExpression(node: LighterASTNode): LighterASTNode? {
+        return when (node.tokenType) {
+            KtNodeTypes.USER_TYPE -> findChildByType(node, KtNodeTypes.REFERENCE_EXPRESSION)
+                ?: findChildByType(node, KtNodeTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION)
+            KtNodeTypes.NULLABLE_TYPE, KtNodeTypes.DEFINITELY_NOT_NULL_TYPE -> findChildByType(node, KtStubElementTypes.TYPE_ELEMENT_TYPES)
+                ?.let { referencedTypeExpression(it) }
+            else -> null
+        }
+    }
+
     val FUN_INTERFACE: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
         override fun mark(
             node: LighterASTNode,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt

@@ -333,8 +333,6 @@ private fun ConeSimpleDiagnostic.getFactory(source: FirSourceElement): FirDiagno
         DiagnosticKind.IllegalUnderscore -> FirErrors.ILLEGAL_UNDERSCORE
         DiagnosticKind.DeserializationError -> FirErrors.DESERIALIZATION_ERROR
         DiagnosticKind.InferenceError -> FirErrors.INFERENCE_ERROR
-        DiagnosticKind.EnumAsSupertype -> FirErrors.ENUM_AS_SUPERTYPE
-        DiagnosticKind.RecursionInSupertypes -> FirErrors.RECURSION_IN_SUPERTYPES
         DiagnosticKind.RecursionInImplicitTypes -> FirErrors.RECURSION_IN_IMPLICIT_TYPES
         DiagnosticKind.Java -> FirErrors.ERROR_FROM_JAVA_RESOLUTION
         DiagnosticKind.SuperNotAllowed -> FirErrors.SUPER_IS_NOT_AN_EXPRESSION
@@ -349,7 +347,6 @@ private fun ConeSimpleDiagnostic.getFactory(source: FirSourceElement): FirDiagno
         DiagnosticKind.VariableExpected -> FirErrors.VARIABLE_EXPECTED
         DiagnosticKind.ValueParameterWithNoTypeAnnotation -> FirErrors.VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION
         DiagnosticKind.CannotInferParameterType -> FirErrors.CANNOT_INFER_PARAMETER_TYPE
-        DiagnosticKind.UnknownCallableKind -> FirErrors.UNKNOWN_CALLABLE_KIND
         DiagnosticKind.IllegalProjectionUsage -> FirErrors.ILLEGAL_PROJECTION_USAGE
         DiagnosticKind.MissingStdlibClass -> FirErrors.MISSING_STDLIB_CLASS
         DiagnosticKind.IntLiteralOutOfRange -> FirErrors.INT_LITERAL_OUT_OF_RANGE
@@ -362,6 +359,8 @@ private fun ConeSimpleDiagnostic.getFactory(source: FirSourceElement): FirDiagno
         DiagnosticKind.RecursiveTypealiasExpansion -> FirErrors.RECURSIVE_TYPEALIAS_EXPANSION
         DiagnosticKind.LoopInSupertype -> FirErrors.CYCLIC_INHERITANCE_HIERARCHY
         DiagnosticKind.IllegalSelector -> FirErrors.ILLEGAL_SELECTOR
+        DiagnosticKind.IsEnumEntry -> FirErrors.IS_ENUM_ENTRY
+        DiagnosticKind.EnumEntryAsType -> FirErrors.ENUM_ENTRY_AS_TYPE
         DiagnosticKind.UnresolvedSupertype,
         DiagnosticKind.UnresolvedExpandedType,
         DiagnosticKind.Other -> FirErrors.OTHER_ERROR

compiler/fir/fir2ir/build.gradle.kts

@@ -43,12 +43,7 @@ dependencies {
         includeJars("jna", rootProject = rootProject)
     }
 
-    Platform[202] {
-        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-1") }
-    }
-    Platform[203].orHigher {
-        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
-    }
+    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
 }
 
 val generationRoot = projectDir.resolve("tests-gen")

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java

@@ -380,6 +380,76 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             }
         }
 
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/annotations/instances")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Instances {
+            @Test
+            public void testAllFilesPresentInInstances() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/instances"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+
+            @Test
+            @TestMetadata("annotationEnclosingName.kt")
+            public void testAnnotationEnclosingName() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/annotationEnclosingName.kt");
+            }
+
+            @Test
+            @TestMetadata("annotationEqHc.kt")
+            public void testAnnotationEqHc() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/annotationEqHc.kt");
+            }
+
+            @Test
+            @TestMetadata("annotationInstances.kt")
+            public void testAnnotationInstances() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/annotationInstances.kt");
+            }
+
+            @Test
+            @TestMetadata("annotationInstancesEmptyDefault.kt")
+            public void testAnnotationInstancesEmptyDefault() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/annotationInstancesEmptyDefault.kt");
+            }
+
+            @Test
+            @TestMetadata("annotationToString.kt")
+            public void testAnnotationToString() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/annotationToString.kt");
+            }
+
+            @Test
+            @TestMetadata("annotationType.kt")
+            public void testAnnotationType() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/annotationType.kt");
+            }
+
+            @Test
+            @TestMetadata("javaAnnotation.kt")
+            public void testJavaAnnotation() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/javaAnnotation.kt");
+            }
+
+            @Test
+            @TestMetadata("multifileEqHc.kt")
+            public void testMultifileEqHc() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/multifileEqHc.kt");
+            }
+
+            @Test
+            @TestMetadata("multimoduleInlining.kt")
+            public void testMultimoduleInlining() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/multimoduleInlining.kt");
+            }
+
+            @Test
+            @TestMetadata("multiplatformInstantiation.kt")
+            public void testMultiplatformInstantiation() throws Exception {
+                runTest("compiler/testData/codegen/box/annotations/instances/multiplatformInstantiation.kt");
+            }
+        }
+
         @Nested
         @TestMetadata("compiler/testData/codegen/box/annotations/kClassMapping")
         @TestDataPath("$PROJECT_ROOT")
@@ -5536,6 +5606,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/closures/kt47120a.kt");
         }
 
+        @Test
+        @TestMetadata("kt47840.kt")
+        public void testKt47840() throws Exception {
+            runTest("compiler/testData/codegen/box/closures/kt47840.kt");
+        }
+
         @Test
         @TestMetadata("kt5589.kt")
         public void testKt5589() throws Exception {
@@ -18910,6 +18986,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/inlineClasses/kt47609.kt");
         }
 
+        @Test
+        @TestMetadata("kt47762.kt")
+        public void testKt47762() throws Exception {
+            runTest("compiler/testData/codegen/box/inlineClasses/kt47762.kt");
+        }
+
         @Test
         @TestMetadata("mangledDefaultParameterFunction.kt")
         public void testMangledDefaultParameterFunction() throws Exception {
@@ -42454,6 +42536,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/unsignedTypes/kt43286a.kt");
         }
 
+        @Test
+        @TestMetadata("kt47716.kt")
+        public void testKt47716() throws Exception {
+            runTest("compiler/testData/codegen/box/unsignedTypes/kt47716.kt");
+        }
+
         @Test
         @TestMetadata("literalEqualsNullableUnsigned.kt")
         public void testLiteralEqualsNullableUnsigned() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxInlineCodegenTestGenerated.java

@@ -25,6 +25,28 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
     }
 
+    @Nested
+    @TestMetadata("compiler/testData/codegen/boxInline/annotations")
+    @TestDataPath("$PROJECT_ROOT")
+    public class Annotations {
+        @Test
+        public void testAllFilesPresentInAnnotations() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+        }
+
+        @Test
+        @TestMetadata("annotationInstanceInlining.kt")
+        public void testAnnotationInstanceInlining() throws Exception {
+            runTest("compiler/testData/codegen/boxInline/annotations/annotationInstanceInlining.kt");
+        }
+
+        @Test
+        @TestMetadata("instanceInAnonymousClass.kt")
+        public void testInstanceInAnonymousClass() throws Exception {
+            runTest("compiler/testData/codegen/boxInline/annotations/instanceInAnonymousClass.kt");
+        }
+    }
+
     @Nested
     @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject")
     @TestDataPath("$PROJECT_ROOT")

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt

@@ -57,6 +57,7 @@ class ValueParameter(
             initializer = buildQualifiedAccessExpression {
                 source = propertySource
                 calleeReference = buildPropertyFromParameterResolvedNamedReference {
+                    source = propertySource
                     this.name = name
                     resolvedSymbol = this@ValueParameter.firValueParameter.symbol
                     source = propertySource

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirTypeResolver.kt

@@ -11,5 +11,5 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 abstract class FirTypeResolver : FirSessionComponent {
-    abstract fun resolveType(typeRef: FirTypeRef, scopeClassDeclaration: ScopeClassDeclaration, areBareTypesAllowed: Boolean): ConeKotlinType
+    abstract fun resolveType(typeRef: FirTypeRef, scopeClassDeclaration: ScopeClassDeclaration, areBareTypesAllowed: Boolean, isOperandOfIsOperator: Boolean): ConeKotlinType
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirOuterClassTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.utils.expandedConeType
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
@@ -49,7 +48,7 @@ import org.jetbrains.kotlin.types.SmartcastStability
 fun List<FirQualifierPart>.toTypeProjections(): Array<ConeTypeProjection> =
     asReversed().flatMap { it.typeArgumentList.typeArguments.map { typeArgument -> typeArgument.toConeTypeProjection() } }.toTypedArray()
 
-fun FirFunction.constructFunctionalTypeRef(isSuspend: Boolean = false): FirResolvedTypeRef {
+fun FirFunction.constructFunctionalType(isSuspend: Boolean = false): ConeLookupTagBasedType {
     val receiverTypeRef = when (this) {
         is FirSimpleFunction -> receiverTypeRef
         is FirAnonymousFunction -> receiverTypeRef
@@ -65,11 +64,13 @@ fun FirFunction.constructFunctionalTypeRef(isSuspend: Boolean = false): FirResol
     }
     val rawReturnType = (this as FirTypedDeclaration).returnTypeRef.coneType
 
-    val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneType, rawReturnType, isSuspend = isSuspend)
+    return createFunctionalType(parameters, receiverTypeRef?.coneType, rawReturnType, isSuspend = isSuspend)
+}
 
+fun FirFunction.constructFunctionalTypeRef(isSuspend: Boolean = false): FirResolvedTypeRef {
     return buildResolvedTypeRef {
         source = this@constructFunctionalTypeRef.source?.fakeElement(FirFakeSourceElementKind.ImplicitTypeRef)
-        type = functionalType
+        type = constructFunctionalType(isSuspend)
     }
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -1342,6 +1342,10 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
         graphBuilder.exitCallableReference(callableReferenceAccess).mergeIncomingFlow()
     }
 
+    fun exitGetClassCall(getClassCall: FirGetClassCall) {
+        graphBuilder.exitGetClassCall(getClassCall).mergeIncomingFlow()
+    }
+
     // ------------------------------------------------------ Utils ------------------------------------------------------
 
     private fun getOrCreateLocalVariableAssignmentAnalyzer(firFunction: FirFunction): FirLocalVariableAssignmentAnalyzer? {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt

@@ -609,6 +609,12 @@ class CallableReferenceNode(
     }
 }
 
+class GetClassCallNode(owner: ControlFlowGraph, override val fir: FirGetClassCall, level: Int, id: Int) : CFGNode<FirGetClassCall>(owner, level, id) {
+    override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
+        return visitor.visitGetClassCallNode(this, data)
+    }
+}
+
 class DelegatedConstructorCallNode(
     owner: ControlFlowGraph,
     override val fir: FirDelegatedConstructorCall,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNodeRenderer.kt

@@ -123,6 +123,7 @@ fun CFGNode<*>.render(): String =
                 is ElvisExitNode -> "Exit ?:"
 
                 is CallableReferenceNode -> "Callable reference: ${fir.render(CfgRenderMode)}"
+                is GetClassCallNode -> "::class call"
 
                 is AbstractBinaryExitNode -> throw IllegalStateException()
             },

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt

@@ -1121,6 +1121,10 @@ class ControlFlowGraphBuilder {
         return createCallableReferenceNode(callableReferenceAccess).also { addNewSimpleNode(it) }
     }
 
+    fun exitGetClassCall(getClassCall: FirGetClassCall): GetClassCallNode {
+        return createGetClassCallNode(getClassCall).also { addNewSimpleNode(it) }
+    }
+
     // ----------------------------------- Block -----------------------------------
 
     fun enterInitBlock(initBlock: FirAnonymousInitializer): Pair<InitBlockEnterNode, CFGNode<*>?> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt

@@ -128,6 +128,9 @@ fun ControlFlowGraphBuilder.createFunctionCallNode(fir: FirFunctionCall): Functi
 fun ControlFlowGraphBuilder.createCallableReferenceNode(fir: FirCallableReferenceAccess): CallableReferenceNode =
     CallableReferenceNode(currentGraph, fir, levelCounter, createId())
 
+fun ControlFlowGraphBuilder.createGetClassCallNode(fir: FirGetClassCall): GetClassCallNode =
+    GetClassCallNode(currentGraph, fir, levelCounter, createId())
+
 fun ControlFlowGraphBuilder.createDelegatedConstructorCallNode(fir: FirDelegatedConstructorCall): DelegatedConstructorCallNode =
     DelegatedConstructorCallNode(currentGraph, fir, levelCounter, createId())