add kotlin benchmarks for abi snapshot

.idea/dictionaries/skuzmich.xml

@@ -2,7 +2,6 @@
   <dictionary name="skuzmich">
     <words>
       <w>anyref</w>
-      <w>dataref</w>
       <w>ushr</w>
       <w>wasm</w>
     </words>

.idea/runConfigurations/IDEA.xml

@@ -0,0 +1,20 @@
+<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

@@ -0,0 +1,20 @@
+<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

@@ -0,0 +1,20 @@
+<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

@@ -0,0 +1,20 @@
+<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

@@ -0,0 +1,19 @@
+<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>

.idea/runConfigurations/Test__Commonizer___Light.xml

@@ -1,23 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test: Commonizer / Light" type="GradleRunConfiguration" factoryName="Gradle" folderName="Tests">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value=":native:kotlin-klib-commonizer-api:test" />
-          <option value=":native:kotlin-klib-commonizer:test" />
-        </list>
-      </option>
-      <option name="vmOptions" />
-    </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <DebugAllEnabled>false</DebugAllEnabled>
-    <method v="2" />
-  </configuration>
-</component>

ChangeLog.md

@@ -1,307 +1,5 @@
 # CHANGELOG
 
-## 1.5.21
-
-### Compiler
-
-- [`KT-47320`](https://youtrack.jetbrains.com/issue/KT-47320) "StringConcatException: Mismatched number of concat arguments" String concatenation fails when template contains special character
-- [`KT-47445`](https://youtrack.jetbrains.com/issue/KT-47445) "definitely not null type parameters is only available since language version 1.6" error in cast expression
-- [`KT-47446`](https://youtrack.jetbrains.com/issue/KT-47446) Improve warning message INTEGER_OPERATOR_RESOLVE_WILL_CHANGE
-- [`KT-47447`](https://youtrack.jetbrains.com/issue/KT-47447) False positive INTEGER_OPERATOR_RESOLVE_WILL_CHANGE warning: "expression will be resolved to Int in future releases"
-- [`KT-47449`](https://youtrack.jetbrains.com/issue/KT-47449) JVM / IR: ClassCastException IrStarProjectionImpl  cannot be cast to IrTypeProjection
-- [`KT-47459`](https://youtrack.jetbrains.com/issue/KT-47459) "IndexOutOfBoundsException: Index 0 out of bounds for length 0" caused by MarkertManager dependency
-- [`KT-47480`](https://youtrack.jetbrains.com/issue/KT-47480) StackOverflowError: Recursion on erasion of raw type with interdependent type parameters
-
-### Tools. Compiler Plugins
-
-- [`KT-47161`](https://youtrack.jetbrains.com/issue/KT-47161) Serializable class can't be inherited from serializable class in other module with: e: org.jetbrains.kotlin.codegen.CompilationException: Back-end (JVM) Internal error: Couldn't transform method node: write$Self
-- [`KT-47455`](https://youtrack.jetbrains.com/issue/KT-47455) Kotlin lombok plugin NullPointerException
-- [`KT-47513`](https://youtrack.jetbrains.com/issue/KT-47513) Lombok compiler plugin failed with 'Recursion detected in a lazy value under LockBasedStorageManager@1c21db60 (TopDownAnalyzer for JVM)'
-
-### Tools. Gradle
-
-- [`KT-47444`](https://youtrack.jetbrains.com/issue/KT-47444) Gradle Plugin: Publishing project with "maven-publish" fails when dependency versions are omitted (NPE in MppDependencyRewritingUtilsKt.associateDependenciesWithActualModuleDependencies)
-
-### Tools. kapt
-
-- [`KT-47416`](https://youtrack.jetbrains.com/issue/KT-47416) Kapt Gradle DSL ignores javaCompilerOptions in 1.5.20
-
-## 1.5.20
-
-### Compiler
-
-#### New Features
-
-- [`KT-43262`](https://youtrack.jetbrains.com/issue/KT-43262) No error for Java generic class @NotNull type parameter used in Kotlin with nullable type argument
-- [`KT-44373`](https://youtrack.jetbrains.com/issue/KT-44373) FIR: support error / warning suppression
-- [`KT-45189`](https://youtrack.jetbrains.com/issue/KT-45189) Support nullability annotations at module level
-- [`KT-45284`](https://youtrack.jetbrains.com/issue/KT-45284) Emit warnings based on jspecify annotations
-- [`KT-45525`](https://youtrack.jetbrains.com/issue/KT-45525) Allow to omit JvmInline annotation for expect value classes
-- [`KT-46545`](https://youtrack.jetbrains.com/issue/KT-46545) Emit annotations on function type parameters into bytecode for -jvm-target 1.8 and above
-
-#### Performance Improvements
-
-- [`KT-36646`](https://youtrack.jetbrains.com/issue/KT-36646) Don't box primitive values in equality comparison with objects in JVM_IR
-
-#### Fixes
-
-- [`KT-8325`](https://youtrack.jetbrains.com/issue/KT-8325) Unresolved annotation should be an error
-- [`KT-19455`](https://youtrack.jetbrains.com/issue/KT-19455) Type annotation unresolved on a type parameter of a supertype in anonymous object expression
-- [`KT-24643`](https://youtrack.jetbrains.com/issue/KT-24643) Prohibit using a type parameter declared for an extension property inside delegate
-- [`KT-25876`](https://youtrack.jetbrains.com/issue/KT-25876) Annotations on return types and supertypes are not analyzed
-- [`KT-28449`](https://youtrack.jetbrains.com/issue/KT-28449) Annotation target is not analyzed in several cases for type annotations
-- [`KT-36770`](https://youtrack.jetbrains.com/issue/KT-36770) Prohibit unsafe calls with expected @NotNull T and given Kotlin generic parameter with nullable bound
-- [`KT-36880`](https://youtrack.jetbrains.com/issue/KT-36880) K/N IR: Reference to expect property in actual declaration is not remapped
-- [`KT-38325`](https://youtrack.jetbrains.com/issue/KT-38325) IllegalStateException: No parameter with index 0-0 when iterating Scala 2.12.11 List
-- [`KT-38342`](https://youtrack.jetbrains.com/issue/KT-38342) FIR: Consider renaming diagnostic from AMBIGUITY to OVERLOAD_RESOLUTION_AMBIGUITY
-- [`KT-38476`](https://youtrack.jetbrains.com/issue/KT-38476) [FIR] Forgotten type approximation
-- [`KT-38540`](https://youtrack.jetbrains.com/issue/KT-38540) Kotlin/Native Set<T>.contains fails with specific enum setup
-- [`KT-40425`](https://youtrack.jetbrains.com/issue/KT-40425) IrGenerationExtension. Support simple reporting to compiler output (for development/debug)
-- [`KT-41620`](https://youtrack.jetbrains.com/issue/KT-41620) ClassCastException: Class cannot be cast to java.lang.Void
-- [`KT-41679`](https://youtrack.jetbrains.com/issue/KT-41679) NI: TYPE_MISMATCH wrong type inference of collection with type Any and integer literal
-- [`KT-41818`](https://youtrack.jetbrains.com/issue/KT-41818) NI: False positive IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION leads to NothingValueException on delegated properties
-- [`KT-42239`](https://youtrack.jetbrains.com/issue/KT-42239) IR: Report compilation error instead of throwing an exception (effectively crash compiler) when some declaration wasn't found while deserialization
-- [`KT-42631`](https://youtrack.jetbrains.com/issue/KT-42631) ArrayIndexOutOfBoundsException was thrown during IR lowering
-- [`KT-43258`](https://youtrack.jetbrains.com/issue/KT-43258) NI: False positive "Suspend function 'invoke' should be called only from a coroutine or another suspend function" when calling suspend operator fun on object property from last expression of a crossinlined suspend lambda
-- [`KT-44036`](https://youtrack.jetbrains.com/issue/KT-44036) Enum initialization order
-- [`KT-44511`](https://youtrack.jetbrains.com/issue/KT-44511) FIR DFA: smartcast after `if (nullable ?: boolean)`
-- [`KT-44554`](https://youtrack.jetbrains.com/issue/KT-44554) RAW FIR: NPE in RawFirBuilder
-- [`KT-44682`](https://youtrack.jetbrains.com/issue/KT-44682) raw FIR: incorrect source for qualified access
-- [`KT-44695`](https://youtrack.jetbrains.com/issue/KT-44695) *_TYPE_MISMATCH_ON_OVERRIDE checkers do not work for anonymous objects
-- [`KT-44699`](https://youtrack.jetbrains.com/issue/KT-44699) FIR: incorrect lambda return type (led to a false alarm: PROPERTY_TYPE_MISMATCH_ON_OVERRIDE)
-- [`KT-44802`](https://youtrack.jetbrains.com/issue/KT-44802) FIR bootstrap: trying to access package private class
-- [`KT-44813`](https://youtrack.jetbrains.com/issue/KT-44813) FIR bootstrap: various errors in collection-like classes
-- [`KT-44814`](https://youtrack.jetbrains.com/issue/KT-44814) FIR bootstrap: incorrect cast in when branch
-- [`KT-44942`](https://youtrack.jetbrains.com/issue/KT-44942) [FIR] ClassCastException in boostrap tests
-- [`KT-44995`](https://youtrack.jetbrains.com/issue/KT-44995) FIR: false positive for ANNOTATION_ARGUMENT_MUST_BE_CONST
-- [`KT-45010`](https://youtrack.jetbrains.com/issue/KT-45010) FIR: lambda arguments of inapplicable call is not resolved
-- [`KT-45048`](https://youtrack.jetbrains.com/issue/KT-45048) FIR bootstrap: VerifyError on KtUltraLightClass
-- [`KT-45052`](https://youtrack.jetbrains.com/issue/KT-45052) FIR bootstrap: inapplicable candidate in GenerateSpecTests.kt
-- [`KT-45121`](https://youtrack.jetbrains.com/issue/KT-45121) FIR IDE: redundant vararg parameter type transformation
-- [`KT-45136`](https://youtrack.jetbrains.com/issue/KT-45136) Native: dividing Int.MIN_VALUE by -1 crashes or hangs
-- [`KT-45236`](https://youtrack.jetbrains.com/issue/KT-45236) JVM / IR: "IllegalStateException: Symbol with IrTypeParameterSymbolImpl is unbound" caused by contracts and sealed class
-- [`KT-45308`](https://youtrack.jetbrains.com/issue/KT-45308) Psi2ir: "AssertionError: TypeAliasDescriptor expected" caused by using typealias from one module as a type in another module without a transitive dependency
-- [`KT-45316`](https://youtrack.jetbrains.com/issue/KT-45316) [FIR] Ambiguity between two implicit invokes with receiver
-- [`KT-45344`](https://youtrack.jetbrains.com/issue/KT-45344) FIR: Wrong inferred type for nullable type parameter
-- [`KT-45385`](https://youtrack.jetbrains.com/issue/KT-45385) FIR: false positive MUST_BE_INITIALIZED_OR_BE_ABSTRACT after rethrow
-- [`KT-45475`](https://youtrack.jetbrains.com/issue/KT-45475) [FIR] No smartcast after throw in if inside try block
-- [`KT-45508`](https://youtrack.jetbrains.com/issue/KT-45508) False negative ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED on a fake override with an abstract super class member
-- [`KT-45578`](https://youtrack.jetbrains.com/issue/KT-45578) REPL: Unresolved imports are cached for the subsequent compilations
-- [`KT-45685`](https://youtrack.jetbrains.com/issue/KT-45685) JVM IR: capturing a variable into crossinline suspend lambda makes the function inside inline function no longer unbox Result
-- [`KT-45584`](https://youtrack.jetbrains.com/issue/KT-45584) [FIR] Fix overriding property and java function in java class
-- [`KT-45697`](https://youtrack.jetbrains.com/issue/KT-45697) JVM IR: ISE "Function has no body" on getter of private field in a class present both in sources and dependencies
-- [`KT-45842`](https://youtrack.jetbrains.com/issue/KT-45842) Compiler doesn't allow a shared class to inherit a platform-specific sealed class
-- [`KT-45848`](https://youtrack.jetbrains.com/issue/KT-45848) False negative [SEALED_INHERITOR_IN_DIFFERENT_MODULE] error in compiler for a platform-specific inheritor of a shared sealed class
-- [`KT-45931`](https://youtrack.jetbrains.com/issue/KT-45931) There is no warning based on nullability java annotation
-- [`KT-45998`](https://youtrack.jetbrains.com/issue/KT-45998) JVM IR: AE when an accessor to a protected companion object member is being generated in child class
-- [`KT-46048`](https://youtrack.jetbrains.com/issue/KT-46048) Enum entries init order in companion object
-- [`KT-46074`](https://youtrack.jetbrains.com/issue/KT-46074) FIR: private-in-file fun interface is considered invisible in this file
-- [`KT-46173`](https://youtrack.jetbrains.com/issue/KT-46173) No error reporting on annotations on target type of `as` expression in return
-- [`KT-46235`](https://youtrack.jetbrains.com/issue/KT-46235) JVM IR: Stack overflow error on large expressions
-- [`KT-46270`](https://youtrack.jetbrains.com/issue/KT-46270) [FIR] Support `@PublishedAPI` in inline checker
-- [`KT-46539`](https://youtrack.jetbrains.com/issue/KT-46539) Generate annotations on type parameters bounds in bytecode
-- [`KT-46578`](https://youtrack.jetbrains.com/issue/KT-46578) JVM IR: IllegalAccessError accessing property delegated to java super class protected field reference
-- [`KT-46597`](https://youtrack.jetbrains.com/issue/KT-46597) JVM IR: AssertionError: SyntheticAccessorLowering should not attempt to modify other files - crossinline accessor
-- [`KT-46601`](https://youtrack.jetbrains.com/issue/KT-46601) JVM / IR: IllegalStateException: "Can't find method 'invokeinvoke`" when default lambda takes inline class parameters
-- [`KT-46670`](https://youtrack.jetbrains.com/issue/KT-46670) StackOverflowError on inheritance from raw type where class has protobuf-like recursive generics
-- [`KT-46715`](https://youtrack.jetbrains.com/issue/KT-46715) JVM / IR: "AssertionError: Unbound symbols not allowed IrConstructorSymbolImpl" with enum classes with the same name in test and src folders
-- [`KT-46759`](https://youtrack.jetbrains.com/issue/KT-46759) JVM IR: CCE in LateinitUsageLowering on @JvmStatic lateinit property in object
-- [`KT-46777`](https://youtrack.jetbrains.com/issue/KT-46777) [Native] [IR] Support suspend function as super type
-- [`KT-46802`](https://youtrack.jetbrains.com/issue/KT-46802) JVM / IR: "UnsupportedOperationException: Unknown structure of ADAPTER_FOR_CALLABLE_REFERENCE" caused by function reference on @JvmStatic function with unused default parameters
-- [`KT-46813`](https://youtrack.jetbrains.com/issue/KT-46813) JVM / IR: "ClassCastException: Integer cannot be cast to class Result" with Flow and `fold` method
-- [`KT-46822`](https://youtrack.jetbrains.com/issue/KT-46822) JVM IR: StackOverflowError on compiling a large data class
-- [`KT-46837`](https://youtrack.jetbrains.com/issue/KT-46837) Backend Internal error: Exception during IR lowering: assert at IrOverridingUtilKt.buildFakeOverrideMember
-- [`KT-46921`](https://youtrack.jetbrains.com/issue/KT-46921) JVM / IR: "IndexOutOfBoundsException: Cannot pop operand off an empty stack" caused by crossinline parameter and label return
-- [`KT-46984`](https://youtrack.jetbrains.com/issue/KT-46984) Type parameter bounds aren't used to report corresponding mismatch warnings
-- [`KT-46985`](https://youtrack.jetbrains.com/issue/KT-46985) There aren't warnings by java nullability annotations
-- [`KT-46986`](https://youtrack.jetbrains.com/issue/KT-46986) There aren't warnings by java nullability annotations
-- [`KT-46989`](https://youtrack.jetbrains.com/issue/KT-46989) There aren't warnings by java nullability annotations
-- [`KT-46990`](https://youtrack.jetbrains.com/issue/KT-46990) There aren't warnings by java nullability annotations on method's violated type arguments
-- [`KT-47019`](https://youtrack.jetbrains.com/issue/KT-47019) K/N: IrProperty.overriddenSymbols can't be used in common IR backend modules yet because it doesn't fully work in Native
-
-### Docs & Examples
-
-- [`KT-33783`](https://youtrack.jetbrains.com/issue/KT-33783) Document when a range created with rangeTo is empty
-
-### IDE
-
-- [`KT-44638`](https://youtrack.jetbrains.com/issue/KT-44638) `clone()` call is unresolved in JVM module of a multiplatform project
-- [`KT-45629`](https://youtrack.jetbrains.com/issue/KT-45629) [ULC] KtUltraLightFieldForSourceDeclaration.nameIdentifier returns null
-- [`KT-44825`](https://youtrack.jetbrains.com/issue/KT-44825) Can't open Kotlin compiler settings in newly created project
-- [`KT-45908`](https://youtrack.jetbrains.com/issue/KT-45908) Reproduciable 'org.jetbrains.kotlin.idea.caches.resolve.KotlinIdeaResolutionException: Kotlin resolution encountered a problem while analyzing KtNameReferenceExpression'
-
-### IDE. FIR
-
-- [`KT-45175`](https://youtrack.jetbrains.com/issue/KT-45175) FIR IDE: Exception with local property in `init` block
-- [`KT-45199`](https://youtrack.jetbrains.com/issue/KT-45199) FIR IDE: Error while collecting diagnostic on stale element after replacing element in quickfix
-- [`KT-45312`](https://youtrack.jetbrains.com/issue/KT-45312) FIR IDE: FIR plugin throws exception on synthetic function
-
-### IDE. Gradle Integration
-
-- [`KT-34401`](https://youtrack.jetbrains.com/issue/KT-34401) KotlinGradleModelBuilder builds models for non-kotlin modules and always trigger full task configuration.
-- [`KT-45277`](https://youtrack.jetbrains.com/issue/KT-45277) Wrong jvm target in gradle module in IDEA
-- [`KT-46488`](https://youtrack.jetbrains.com/issue/KT-46488) Import of a multiplatform project with MPP module depending on Kotlin/JVM one fails
-
-### IDE. Inspections and Intentions
-
-- [`KT-45075`](https://youtrack.jetbrains.com/issue/KT-45075) Inspection: Redundant creation of Json format
-- [`KT-45347`](https://youtrack.jetbrains.com/issue/KT-45347) Sealed interfaces: quickfix to move to package/module of sealed class/interface should not be shown in case of read-only declaration
-- [`KT-45348`](https://youtrack.jetbrains.com/issue/KT-45348) Sealed interfaces: show error for usage of sealed class/interface from a library in Java source code
-- [`KT-46063`](https://youtrack.jetbrains.com/issue/KT-46063) In multiplatform code, suggest to generate remaining `when` branches at least for shared sealed classes
-
-### IDE. Refactorings
-
-- [`KT-44431`](https://youtrack.jetbrains.com/issue/KT-44431) Quickfix to move class/interface to proper location: it is allowed to choose test source in JPS project while compiler does not allow it
-
-### IDE. Native
-
-- [`KT-39320`](https://youtrack.jetbrains.com/issue/KT-39320) [Commonizer] Reduce memory consumption
-
-### JavaScript
-
-- [`KT-40235`](https://youtrack.jetbrains.com/issue/KT-40235) KJS: IR. Broken support for external interface companion
-- [`KT-40689`](https://youtrack.jetbrains.com/issue/KT-40689) KJS / IR: strange and slow code for kotlin.math.max and kotlin.math.min for Double
-- [`KT-44138`](https://youtrack.jetbrains.com/issue/KT-44138) KJS / IR: Constant folding works incorrectly with unsigned arithmetic
-- [`KT-44394`](https://youtrack.jetbrains.com/issue/KT-44394) KJS / IR: `null` companion object for existed stdlib interfaces `NodeFilter` and `SVGUnitTypes`
-- [`KT-44950`](https://youtrack.jetbrains.com/issue/KT-44950) KJS / IR: "IllegalStateException: Can't find name for declaration" in case of extending export declared class without @JsExport annotation
-- [`KT-45057`](https://youtrack.jetbrains.com/issue/KT-45057) KJS / IR: "ClassCastException" when using `js` function in init block
-- [`KT-45361`](https://youtrack.jetbrains.com/issue/KT-45361) KJS / IR: `IrConstructorCall` representing annotation always returns `Unit`
-- [`KT-46608`](https://youtrack.jetbrains.com/issue/KT-46608) KJS: "Could not load content..." for source maps
-- [`KT-45655`](https://youtrack.jetbrains.com/issue/KT-45655) KJS: "REINTERPRET_CAST" is not copyable
-- [`KT-45866`](https://youtrack.jetbrains.com/issue/KT-45866) Default parameter with generic in expect-actual declarations
-- [`KT-46859`](https://youtrack.jetbrains.com/issue/KT-46859) Exception during IR lowering: NullPointerException was thrown at: optimizations.FoldConstantLowering.tryFoldingUnaryOps
-
-### KMM Plugin
-
-- [`KT-43899`](https://youtrack.jetbrains.com/issue/KT-43899) KMM: Fix "stale framework" usage by XCode & AppCode in default build script
-
-### Libraries
-
-- [`KT-43701`](https://youtrack.jetbrains.com/issue/KT-43701) Stdlib: Expand KDoc of inc() and dec() for operators
-- [`KT-46002`](https://youtrack.jetbrains.com/issue/KT-46002) Support all Unicode digit chars in digitToInt (JS and Native)
-- [`KT-46183`](https://youtrack.jetbrains.com/issue/KT-46183) Add default value for ignoreCase in K/N String.replace/replaceFirst
-- [`KT-46184`](https://youtrack.jetbrains.com/issue/KT-46184) Equivalize isLowerCase and isUpperCase behavior in all platforms
-
-### Native
-
-- [`KT-33175`](https://youtrack.jetbrains.com/issue/KT-33175) IR: String constants with incorrect surrogate pairs aren't preserved during serialization/deserialization
-- [`KT-44799`](https://youtrack.jetbrains.com/issue/KT-44799) Different behavior with functional interfaces in Kotlin/Native on iOS
-
-### Native. C Export
-
-- [`KT-42796`](https://youtrack.jetbrains.com/issue/KT-42796) [Reverse C Interop] Package with no public methods generate empty struct in the header, leading to an error
-
-### Native. ObjC Export
-
-- [`KT-38600`](https://youtrack.jetbrains.com/issue/KT-38600) Kotlin MP iOS Target doesn't contain kdoc comments
-- [`KT-45127`](https://youtrack.jetbrains.com/issue/KT-45127) KMM: hard to pass an error to Kotlin code from implementation of Kotlin method in Swift code
-
-### Native. Runtime. Memory
-
-- [`KT-45063`](https://youtrack.jetbrains.com/issue/KT-45063) Profiling indicates that a lot of time is spent on updateHeapRef on Apple platforms when running KMP code
-
-### Reflection
-
-- [`KT-10838`](https://youtrack.jetbrains.com/issue/KT-10838) Provide sensible toString() for property accessors in reflection
-- [`KT-13490`](https://youtrack.jetbrains.com/issue/KT-13490) Equality doesn't work for KProperty.Accessor implementations
-
-### Tools. CLI
-
-- [`KT-14772`](https://youtrack.jetbrains.com/issue/KT-14772) ISE (FNFE "Not a directory") on compilation with destination argument clashing with an existing file which is not a directory
-- [`KT-18184`](https://youtrack.jetbrains.com/issue/KT-18184) CompileEnvironmentException: Invalid jar path on "-d" with .jar in non-existing directory
-- [`KT-40977`](https://youtrack.jetbrains.com/issue/KT-40977) Report a readable diagnostic on empty -J argument in CLI
-
-### Tools. Commonizer
-
-- [`KT-45497`](https://youtrack.jetbrains.com/issue/KT-45497) [Commonizer] c-interop commonization: Dependency commonization
-- [`KT-46077`](https://youtrack.jetbrains.com/issue/KT-46077) [Commonizer] Add `commonizer_target` to commonized klib's manifest
-- [`KT-46107`](https://youtrack.jetbrains.com/issue/KT-46107) [Commonizer] CInteropCommonizerTask receives faulty dependencies in multi module projects containing multiple c-interops
-- [`KT-46248`](https://youtrack.jetbrains.com/issue/KT-46248) MPP: Compile KotlinMetadata fails with Unresolved reference if only one native platform from shared source set is available
-- [`KT-46856`](https://youtrack.jetbrains.com/issue/KT-46856) [Commonizer] Many targets can fail with 'filename too long'
-
-### Tools. Compiler Plugins
-
-- [`KT-7112`](https://youtrack.jetbrains.com/issue/KT-7112) Support calling Lombok-generated methods within same module
-- [`KT-45538`](https://youtrack.jetbrains.com/issue/KT-45538) Serialization, JVM IR: "AssertionError: No such type argument slot in IrConstructorCallImpl" with inner classes
-- [`KT-45541`](https://youtrack.jetbrains.com/issue/KT-45541) JVM / IR / Serialization: NullPointerException caused by "Serializable" annotation and local data class
-- [`KT-46469`](https://youtrack.jetbrains.com/issue/KT-46469) Kotlin Lombok: accessors with `AccessLevel.MODULE` fail to resolve
-- [`KT-46529`](https://youtrack.jetbrains.com/issue/KT-46529) Kotlin Lombok: with `@Accessors` without explicit `prefix` the prefix from lombok.config is not taken into account
-- [`KT-46531`](https://youtrack.jetbrains.com/issue/KT-46531) Kotlin Lombok: `lombok.getter.noIsPrefix` is processed depending on character case
-- [`KT-46920`](https://youtrack.jetbrains.com/issue/KT-46920) NullPointerException in CodeGeneratorVisitor when packing for xcode
-
-### Tools. Gradle
-
-- [`KT-24533`](https://youtrack.jetbrains.com/issue/KT-24533) Kapt should not run when annotation processors are not configured
-- [`KT-43988`](https://youtrack.jetbrains.com/issue/KT-43988) Enable plugin validation during build
-- [`KT-45301`](https://youtrack.jetbrains.com/issue/KT-45301) Gradle: Empty `build/kotlin` dir with custom build directory
-- [`KT-45519`](https://youtrack.jetbrains.com/issue/KT-45519) loadAndroidPluginVersion() impacts performance negatively and noticeably in multimodule Android build
-- [`KT-45744`](https://youtrack.jetbrains.com/issue/KT-45744) Create Kotlin Gradle Plugin JUnit5 basic test setup
-- [`KT-45834`](https://youtrack.jetbrains.com/issue/KT-45834) Gradle Plugin read system property related to kotlinCompilerClasspath breaks use of configuration cache
-- [`KT-46401`](https://youtrack.jetbrains.com/issue/KT-46401) Deprecate 'kotlin.parallel.tasks.in.project' build property
-- [`KT-46820`](https://youtrack.jetbrains.com/issue/KT-46820) Gradle: kotlinc (1.5.0) race condition causes a NullPointerException
-- [`KT-47317`](https://youtrack.jetbrains.com/issue/KT-47317) Restore 'kotlinPluginVersion' property in 'KotlinBasePluginWrapper'
-
-### Tools. Gradle. JS
-
-- [`KT-42911`](https://youtrack.jetbrains.com/issue/KT-42911) Support Gradle configuration cache for K/JS tasks
-- [`KT-45294`](https://youtrack.jetbrains.com/issue/KT-45294) KJS / Gradle: Number of modules in project affects JS tasks configuration cache state size
-- [`KT-45754`](https://youtrack.jetbrains.com/issue/KT-45754) KJS / IR: Remove adding option of source maps in Gradle plugin
-- [`KT-46178`](https://youtrack.jetbrains.com/issue/KT-46178) KJS / Dukat: Added as a dependency always without condition
-- [`KT-46976`](https://youtrack.jetbrains.com/issue/KT-46976) KJS: Broken support for dynamically created `webpack.config.d`
-- [`KT-47045`](https://youtrack.jetbrains.com/issue/KT-47045) [Gradle, JS] Task requirements are added to all compilations with same name
-
-### Tools. Gradle. Multiplatform
-
-- [`KT-36679`](https://youtrack.jetbrains.com/issue/KT-36679) MPP Gradle plugin: Improve messaging for the commonizer
-- [`KT-45832`](https://youtrack.jetbrains.com/issue/KT-45832) CInteropCommonization: Filter out illegal dependencies
-- [`KT-46394`](https://youtrack.jetbrains.com/issue/KT-46394) Multiplatform: Gradle 7 support
-- [`KT-46517`](https://youtrack.jetbrains.com/issue/KT-46517) Add kotlin-project-model as api dependency to kotlin-gradle-plugin-api
-
-### Tools. Gradle. Native
-
-- [`KT-27240`](https://youtrack.jetbrains.com/issue/KT-27240) MPP Gradle plugin: Provide a framework packing task for Kotlin/Native
-- [`KT-39016`](https://youtrack.jetbrains.com/issue/KT-39016) Missing stdlib when the downloading process was aborted
-- [`KT-40907`](https://youtrack.jetbrains.com/issue/KT-40907) Xcode error after switching between device and simulator: Building for iOS, but the linked and embedded framework was built for iOS Simulator.
-- [`KT-44059`](https://youtrack.jetbrains.com/issue/KT-44059) iosSimTest tasks are never up-to-date
-- [`KT-45801`](https://youtrack.jetbrains.com/issue/KT-45801) compileIosMainKotlinMetadata compilation property of gradle task is not initialized and fails with  `Execution failed for task ':shared:generateProjectStructureMetadata'`
-- [`KT-46680`](https://youtrack.jetbrains.com/issue/KT-46680) Register concrete "embedAndSign" tasks instead umbrella
-- [`KT-46892`](https://youtrack.jetbrains.com/issue/KT-46892) Kotlin Multiplatform Gradle Plugin: EmbedAndSign task always contains a default framework name
-
-### Tools. Incremental Compile
-
-- [`KT-44741`](https://youtrack.jetbrains.com/issue/KT-44741) Incremental compilation: inspectClassesForKotlinIC doesn't determine changes with imported constant
-
-### Tools. JPS
-
-- [`KT-34351`](https://youtrack.jetbrains.com/issue/KT-34351) KotlinTargetsIndex creation takes too long even if project doesn't have any kotlin
-- [`KT-45191`](https://youtrack.jetbrains.com/issue/KT-45191) [JPS] Marking method as "default" in Java SAM interface doesn't affect dependencies
-- [`KT-46242`](https://youtrack.jetbrains.com/issue/KT-46242) Support Lombok kotlin plugin in JPS and maven
-
-### Tools. kapt
-
-#### Performance Improvements
-
-- [`KT-28901`](https://youtrack.jetbrains.com/issue/KT-28901) Consider caching annotation processors classloaders
-
-#### Fixes
-
-- [`KT-27123`](https://youtrack.jetbrains.com/issue/KT-27123) kapt: missing space in error log makes location non-clickable
-- [`KT-29929`](https://youtrack.jetbrains.com/issue/KT-29929) [Kapt] Stub generator uses constant value in method annotation instead of constant name 2.
-- [`KT-31146`](https://youtrack.jetbrains.com/issue/KT-31146) kapt: executableElement.getAnnotation(JvmOverloads::class.java) returns null
-- [`KT-32202`](https://youtrack.jetbrains.com/issue/KT-32202) Gradle task kaptKotlin fails: "module not found" in Java 11 modular application
-- [`KT-34838`](https://youtrack.jetbrains.com/issue/KT-34838) Kapt: 'cannot find symbol' for a top-level property with anonymous delegate
-- [`KT-35104`](https://youtrack.jetbrains.com/issue/KT-35104) Support @JvmStatic in KAPT stubs
-- [`KT-35167`](https://youtrack.jetbrains.com/issue/KT-35167) Kapt Gradle plugin doesn't handle --module-path javac argument
-- [`KT-37586`](https://youtrack.jetbrains.com/issue/KT-37586) KAPT: When delegated property use an unknown type (to-be-generated class), `correctTypeError` will mess up the `$delegate` field type
-- [`KT-39060`](https://youtrack.jetbrains.com/issue/KT-39060) Kapt: correctErrorTypes don't retain return type of getter in Java stub
-- [`KT-39715`](https://youtrack.jetbrains.com/issue/KT-39715) KaptGenerateStubsTask resolves annotation processor options too early (before execution time)
-- [`KT-41581`](https://youtrack.jetbrains.com/issue/KT-41581) Kapt doesn't have line breaks between warnings
-- [`KT-43804`](https://youtrack.jetbrains.com/issue/KT-43804) Kapt fails to preserve parameter names in open suspend functions
-- [`KT-43686`](https://youtrack.jetbrains.com/issue/KT-43686) KaptWithoutKotlincTask should use `@CompileClasspath` for `kotlinStdlibClasspath` for cache relocateability.
-- [`KT-45032`](https://youtrack.jetbrains.com/issue/KT-45032) Kapt: NullPointerException: insnList.first must not be null
-- [`KT-46176`](https://youtrack.jetbrains.com/issue/KT-46176) Kapt: "java.lang.IndexOutOfBoundsException: Index -1 out of bounds for length 3" with delegation and property reference
-
-
 ## 1.5.10
 
 ### Compiler

ReadMe.md

@@ -35,7 +35,7 @@ Support for multiplatform programming is one of Kotlin’s key benefits. It redu
 
 ## Editing Kotlin
 
- * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html) ([source code](https://github.com/JetBrains/intellij-community/tree/master/plugins/kotlin))
+ * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html)
  * [Kotlin Eclipse Plugin](https://kotlinlang.org/docs/tutorials/getting-started-eclipse.html)
  * [Kotlin Sublime Text Package](https://github.com/vkostyukov/kotlin-sublime-package)
 
@@ -97,10 +97,13 @@ command line parameters on the first run:
 
 - `clean` - clean build results
 - `dist` - assembles the compiler distribution into `dist/kotlinc/` folder
+- `ideaPlugin` - assembles the Kotlin IDEA plugin distribution into `dist/artifacts/ideaPlugin/Kotlin/` folder
 - `install` - build and install all public artifacts into local maven repository
+- `runIde` - build IDEA plugin and run IDEA with it
 - `coreLibsTest` - build and run stdlib, reflect and kotlin-test tests
 - `gradlePluginTest` - build and run gradle plugin tests
 - `compilerTest` - build and run all compiler tests
+- `ideaPluginTest` - build and run all IDEA plugin tests
 
 To reproduce TeamCity build use `-Pteamcity=true` flag. Local builds don't run proguard and have jar compression disabled by default.
 
@@ -140,6 +143,14 @@ To be able to run tests from IntelliJ easily, check `Delegate IDE build/run acti
 
 At this time, you can use the latest released `1.3.x` version of the Kotlin plugin for working with the code. To make sure you have the latest version installed, use `Tools` -> `Kotlin` -> `Configure Kotlin Plugin Updates`.
 
+### Compiling and running
+
+From this root project there are Run/Debug Configurations for running `IDEA` or the `Generate Compiler Tests` for example; so if you want to try out the latest and greatest IDEA plugin
+
+* `VCS` -> `Git` -> `Pull`
+* Run the `IDEA` run configuration in the project
+* A child IntelliJ IDEA with the Kotlin plugin will then startup
+
 ### Dependency verification
 
 We have a [dependencies verification](https://docs.gradle.org/current/userguide/dependency_verification.html) feature enabled in the

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.createSessionForTests
 import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
@@ -155,7 +154,7 @@ abstract class AbstractSimpleFileBenchmark {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(env.project))
         val session = createSessionForTests(env, scope)
         val firProvider = session.firProvider as FirProviderImpl
-        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, PsiHandlingMode.COMPILER)
+        val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
 
         val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)

build-benchmarks/build.gradle.kts

@@ -0,0 +1,60 @@
+group = "org.jetbrains"
+version = "1.0-SNAPSHOT"
+
+plugins {
+    java
+    application
+}
+
+buildscript {
+    val kotlinVersion = System.getenv("KOTLIN_VERSION") ?: "1.5.255-SNAPSHOT"
+    val kotlinRepo = "https://buildserver.labs.intellij.net/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinDev_CompilerDistAndMavenArtifacts),number:$kotlinVersion,branch:default:any/artifacts/content/maven"
+    extra["kotlinRepo"] = kotlinRepo
+
+    repositories {
+        mavenLocal()
+        maven {
+            url = uri(kotlinRepo)
+        }
+    }
+
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
+    }
+}
+
+apply {
+    plugin("kotlin")
+}
+
+val kotlinRepo: String by extra
+
+repositories {
+    maven { url = uri("https://repo.gradle.org/gradle/libs-releases") }
+    mavenLocal()
+    maven {
+        url = uri(kotlinRepo)
+    }
+}
+
+dependencies {
+    implementation("org.jetbrains:kotlin-build-benchmarks:1.0-SNAPSHOT")
+    implementation(kotlin("stdlib"))
+}
+
+application {
+    mainClassName = "RunBenchmarksKt"
+}
+
+tasks.register("runGavra0", JavaExec::class) {
+    classpath = sourceSets.main.get().runtimeClasspath
+    main = "RunGavra0BenchmarksKt"
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().all {
+    kotlinOptions {
+        freeCompilerArgs += listOf(
+            "-Xuse-experimental=kotlin.ExperimentalUnsignedTypes"
+        )
+    }
+}

build-benchmarks/src/main/kotlin/kotlinScenarios.kt

@@ -0,0 +1,371 @@
+import org.jetbrains.kotlin.build.benchmarks.dsl.*
+
+fun abiSnapshotBenchmarks() =
+    suite {
+        val coreUtilStrings = changeableFile("coreUtil/StringsKt")
+        val coreUtilCoreLib = changeableFile("coreUtil/CoreLibKt")
+        val compilerCommonBackendContext = changeableFile("compiler/CommonBackendContext")
+        val kotlinGradlePluginConfigurationPhaseAware = changeableFile("kotlinGradlePlugin/ConfigurationPhaseAware")
+        val buildSrc = changeableFile("buildSrc/BuildPropertiesExtKt")
+
+        defaultTasks(Tasks.DIST, Tasks.COMPILER_TEST_CLASSES, Tasks.IDEA_TEST_CLASSES, Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+        defaultJdk = System.getenv("JDK_8")
+
+        val noArgs = arrayOf<String>()
+
+        val defaultArguments = arrayOf(
+            "--info",
+            "--no-build-cache",
+            "--watch-fs",
+            "-Dkotlin.incremental.classpath.snapshot.enabled=true",
+        )
+
+        val parallelBuild = arrayOf(
+            *defaultArguments,
+            "--parallel",
+        )
+
+        val nonParallelBuild = arrayOf(
+            *defaultArguments,
+            "--no-parallel",
+        )
+
+        defaultArguments(*defaultArguments)
+
+        scenario("clean build") {
+            arguments(*nonParallelBuild)
+            expectSlowBuild("clean build")
+            step {
+                doNotMeasure()
+                runTasks(Tasks.CLEAN)
+            }
+            step {}
+        }
+
+        scenario("(buildSrc, Kotlin) add public fun with abi snapshot") {
+            step {
+                changeFile(buildSrc, TypeOfChange.ADD_PUBLIC_FUNCTION)
+                runTasks(*noArgs)
+            }
+        }
+
+        scenario("(buildSrc, Kotlin) add private fun with abi snapshot") {
+            step {
+                changeFile(buildSrc, TypeOfChange.ADD_PRIVATE_FUNCTION)
+                runTasks(*noArgs)
+            }
+        }
+
+        scenario("clean build parallel") {
+            arguments(*parallelBuild)
+            expectSlowBuild("clean build")
+            step {
+                doNotMeasure()
+                runTasks(Tasks.CLEAN)
+            }
+            step {}
+        }
+
+        scenario("Run gradle plugin tests with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST)
+            }
+            step {
+                doNotMeasure()
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST_CLEAN)
+            }
+            repeat = 5U
+        }
+
+        scenario("Run gradle plugin tests after changes with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(kotlinGradlePluginConfigurationPhaseAware, TypeOfChange.ADD_PRIVATE_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST)
+            }
+            step {
+                doNotMeasure()
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST_CLEAN)
+            }
+            repeat = 5U
+        }
+
+        scenario("(non-leaf, core) add private function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PRIVATE_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, core) add public function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PUBLIC_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, core) add private class with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PRIVATE_CLASS)
+            }
+        }
+
+        scenario("(non-leaf, core) add public class with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PUBLIC_CLASS)
+            }
+        }
+
+        scenario("(non-leaf, core) build after error with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                doNotMeasure()
+                expectBuildToFail()
+                changeFile(coreUtilStrings, TypeOfChange.INTRODUCE_COMPILE_ERROR)
+            }
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.FIX_COMPILE_ERROR)
+            }
+        }
+
+        scenario("(non-leaf, core) change popular inline function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilCoreLib, TypeOfChange.CHANGE_INLINE_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, compiler) add public function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(compilerCommonBackendContext, TypeOfChange.ADD_PUBLIC_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, compiler) add private function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(compilerCommonBackendContext, TypeOfChange.ADD_PRIVATE_FUNCTION)
+            }
+        }
+
+        scenario("(leaf, kotlin gradle plugin) add private function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(kotlinGradlePluginConfigurationPhaseAware, TypeOfChange.ADD_PRIVATE_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+            }
+        }
+
+        scenario("(leaf, kotlin gradle plugin) add public function with abi snapshot") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(kotlinGradlePluginConfigurationPhaseAware, TypeOfChange.ADD_PUBLIC_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+            }
+        }
+    }
+}
+
+fun kotlinBenchmarks() =
+    suite {
+        val coreUtilStrings = changeableFile("coreUtil/StringsKt")
+        val coreUtilCoreLib = changeableFile("coreUtil/CoreLibKt")
+        val compilerCommonBackendContext = changeableFile("compiler/CommonBackendContext")
+        val kotlinGradlePluginConfigurationPhaseAware = changeableFile("kotlinGradlePlugin/ConfigurationPhaseAware")
+        val buildSrc = changeableFile("buildSrc/BuildPropertiesExtKt")
+
+        defaultTasks(Tasks.DIST, Tasks.COMPILER_TEST_CLASSES, Tasks.IDEA_TEST_CLASSES, Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+        defaultJdk = System.getenv("JDK_8")
+
+        val noArgs = arrayOf<String>()
+
+        val defaultArguments = arrayOf(
+            "--info",
+            "--no-build-cache",
+            "--watch-fs",
+        )
+
+        val parallelBuild = arrayOf(
+            *defaultArguments,
+            "--parallel",
+        )
+
+        val nonParallelBuild = arrayOf(
+            *defaultArguments,
+            "--no-parallel",
+        )
+
+        defaultArguments(*defaultArguments)
+
+        scenario("clean build") {
+            arguments(*nonParallelBuild)
+            expectSlowBuild("clean build")
+            step {
+                doNotMeasure()
+                runTasks(Tasks.CLEAN)
+            }
+            step {}
+        }
+
+        scenario("(buildSrc, Kotlin) add public fun") {
+            step {
+                changeFile(buildSrc, TypeOfChange.ADD_PUBLIC_FUNCTION)
+                runTasks(*noArgs)
+            }
+        }
+
+        scenario("(buildSrc, Kotlin) add private fun") {
+            step {
+                changeFile(buildSrc, TypeOfChange.ADD_PRIVATE_FUNCTION)
+                runTasks(*noArgs)
+            }
+        }
+
+        scenario("clean build parallel") {
+            arguments(*parallelBuild)
+            expectSlowBuild("clean build")
+            step {
+                doNotMeasure()
+                runTasks(Tasks.CLEAN)
+            }
+            step {}
+        }
+
+        scenario("Run gradle plugin tests") {
+            arguments(*nonParallelBuild)
+            step {
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST)
+            }
+            step {
+                doNotMeasure()
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST_CLEAN)
+            }
+            repeat = 5U
+        }
+
+        scenario("Run gradle plugin tests after changes") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(kotlinGradlePluginConfigurationPhaseAware, TypeOfChange.ADD_PRIVATE_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST)
+            }
+            step {
+                doNotMeasure()
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_TEST_CLEAN)
+            }
+            repeat = 5U
+        }
+
+        scenario("(non-leaf, core) add private function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PRIVATE_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, core) add public function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PUBLIC_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, core) add private class") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PRIVATE_CLASS)
+            }
+        }
+
+        scenario("(non-leaf, core) add public class") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.ADD_PUBLIC_CLASS)
+            }
+        }
+
+        scenario("(non-leaf, core) build after error") {
+            arguments(*nonParallelBuild)
+            step {
+                doNotMeasure()
+                expectBuildToFail()
+                changeFile(coreUtilStrings, TypeOfChange.INTRODUCE_COMPILE_ERROR)
+            }
+            step {
+                changeFile(coreUtilStrings, TypeOfChange.FIX_COMPILE_ERROR)
+            }
+        }
+
+        scenario("(non-leaf, core) change popular inline function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(coreUtilCoreLib, TypeOfChange.CHANGE_INLINE_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, compiler) add public function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(compilerCommonBackendContext, TypeOfChange.ADD_PUBLIC_FUNCTION)
+            }
+        }
+
+        scenario("(non-leaf, compiler) add private function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(compilerCommonBackendContext, TypeOfChange.ADD_PRIVATE_FUNCTION)
+            }
+        }
+
+        scenario("(leaf, kotlin gradle plugin) add private function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(kotlinGradlePluginConfigurationPhaseAware, TypeOfChange.ADD_PRIVATE_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+            }
+        }
+
+        scenario("(leaf, kotlin gradle plugin) add public function") {
+            arguments(*nonParallelBuild)
+            step {
+                changeFile(kotlinGradlePluginConfigurationPhaseAware, TypeOfChange.ADD_PUBLIC_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+            }
+        }
+    }
+
+fun gavra0Benchmarks() =
+    suite {
+        defaultArguments("-Dorg.gradle.workers.max=8", "--parallel", "--watch-fs")
+        defaultJdk = System.getenv("JDK_8")
+
+        val stdlibFileTreeWalk = changeableFile("gavra0/stdlib/FileTreeWalkKt")
+        val coreDescriptorsClassDescriptorsBase = changeableFile("gavra0/coreDescriptors/ClassDescriptorBaseJava")
+
+        scenario("build") {
+            step {
+                doNotMeasure()
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+            }
+        }
+
+        scenario("abi change to stdlib") {
+            step {
+                changeFile(stdlibFileTreeWalk, TypeOfChange.ADD_PUBLIC_FUNCTION)
+                runTasks(Tasks.KOTLIN_GRADLE_PLUGIN_COMPILE_JAVA)
+            }
+            repeat = 10U
+        }
+
+        scenario("abi change to core.descriptors") {
+            step {
+                changeFile(coreDescriptorsClassDescriptorsBase, TypeOfChange.ADD_PUBLIC_FUNCTION)
+                runTasks(Tasks.DIST, Tasks.IDEA_PLUGIN)
+            }
+            repeat = 10U
+        }
+    }

build-benchmarks/src/main/kotlin/runBenchmarks.kt

@@ -0,0 +1,5 @@
+import org.jetbrains.kotlin.build.benchmarks.*
+
+fun main() {
+    mainImpl(kotlinBenchmarks(), "../.") // expected working dir is %KOTLIN_PROJECT_PATH%/build-benchmarks/
+}

build-benchmarks/src/main/kotlin/runGavra0Benchmarks.kt

@@ -0,0 +1,5 @@
+import org.jetbrains.kotlin.build.benchmarks.*
+
+fun main() {
+    mainImpl(gavra0Benchmarks(), "../.") // expected working dir is %KOTLIN_PROJECT_PATH%/build-benchmarks/
+}

build-benchmarks/src/main/resources/change-files/buildSrc/BuildPropertiesExtKt/_initial.benchmark

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+
+val KotlinBuildProperties.includeJava9: Boolean
+    get() = !isInJpsBuildIdeaSync && getBoolean("kotlin.build.java9", true)
+
+val KotlinBuildProperties.useBootstrapStdlib: Boolean
+    get() = isInJpsBuildIdeaSync || getBoolean("kotlin.build.useBootstrapStdlib", false)
+
+val KotlinBuildProperties.postProcessing: Boolean get() = isTeamcityBuild || getBoolean("kotlin.build.postprocessing", true)
+
+val KotlinBuildProperties.relocation: Boolean get() = postProcessing
+
+val KotlinBuildProperties.proguard: Boolean get() = postProcessing && getBoolean("kotlin.build.proguard", isTeamcityBuild)
+
+val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.build.jar.compression", isTeamcityBuild)
+
+val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)
+
+val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
+
+val KotlinBuildProperties.suppressJdkHomeWarning: Boolean get() = getBoolean("kotlin.suppress.jdkHome.warning", false)

build-benchmarks/src/main/resources/change-files/buildSrc/BuildPropertiesExtKt/_target-file.txt

@@ -0,0 +1 @@
+buildSrc/src/main/kotlin/BuildPropertiesExt.kt

build-benchmarks/src/main/resources/change-files/buildSrc/BuildPropertiesExtKt/addPrivateFunction.benchmark

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+val KotlinBuildProperties.includeJava9: Boolean
+    get() = !isInJpsBuildIdeaSync && getBoolean("kotlin.build.java9", true)
+
+val KotlinBuildProperties.useBootstrapStdlib: Boolean
+    get() = isInJpsBuildIdeaSync || getBoolean("kotlin.build.useBootstrapStdlib", false)
+
+val KotlinBuildProperties.postProcessing: Boolean get() = isTeamcityBuild || getBoolean("kotlin.build.postprocessing", true)
+
+val KotlinBuildProperties.relocation: Boolean get() = postProcessing
+
+val KotlinBuildProperties.proguard: Boolean get() = postProcessing && getBoolean("kotlin.build.proguard", isTeamcityBuild)
+
+val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.build.jar.compression", isTeamcityBuild)
+
+val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)
+
+val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
+
+val KotlinBuildProperties.suppressJdkHomeWarning: Boolean get() = getBoolean("kotlin.suppress.jdkHome.warning", false)
+
+private fun foo() {}

build-benchmarks/src/main/resources/change-files/buildSrc/BuildPropertiesExtKt/addPublicFunction.benchmark

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+val KotlinBuildProperties.includeJava9: Boolean
+    get() = !isInJpsBuildIdeaSync && getBoolean("kotlin.build.java9", true)
+
+val KotlinBuildProperties.useBootstrapStdlib: Boolean
+    get() = isInJpsBuildIdeaSync || getBoolean("kotlin.build.useBootstrapStdlib", false)
+
+val KotlinBuildProperties.postProcessing: Boolean get() = isTeamcityBuild || getBoolean("kotlin.build.postprocessing", true)
+
+val KotlinBuildProperties.relocation: Boolean get() = postProcessing
+
+val KotlinBuildProperties.proguard: Boolean get() = postProcessing && getBoolean("kotlin.build.proguard", isTeamcityBuild)
+
+val KotlinBuildProperties.jarCompression: Boolean get() = getBoolean("kotlin.build.jar.compression", isTeamcityBuild)
+
+val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignoreTestFailures", isTeamcityBuild)
+
+val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
+
+val KotlinBuildProperties.suppressJdkHomeWarning: Boolean get() = getBoolean("kotlin.suppress.jdkHome.warning", false)
+
+fun foo() {}

build-benchmarks/src/main/resources/change-files/compiler/CommonBackendContext/_initial.benchmark

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common
+
+import org.jetbrains.kotlin.backend.common.ir.Ir
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
+import org.jetbrains.kotlin.ir.builders.irCall
+import org.jetbrains.kotlin.ir.builders.irString
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+
+interface LoggingContext {
+    var inVerbosePhase: Boolean
+    fun log(message: () -> String)
+}
+
+interface CommonBackendContext : BackendContext, LoggingContext {
+    override val ir: Ir<CommonBackendContext>
+
+    fun report(element: IrElement?, irFile: IrFile?, message: String, isError: Boolean)
+
+    val configuration: CompilerConfiguration
+    val scriptMode: Boolean
+
+    fun throwUninitializedPropertyAccessException(builder: IrBuilderWithScope, name: String): IrExpression {
+        val throwErrorFunction = ir.symbols.throwUninitializedPropertyAccessException.owner
+        return builder.irCall(throwErrorFunction).apply {
+            putValueArgument(0, builder.irString(name))
+        }
+    }
+
+    val mapping: Mapping
+
+    // Adjust internal structures after a deep copy of some declarations.
+    fun handleDeepCopy(
+        fileSymbolMap: MutableMap<IrFileSymbol, IrFileSymbol>,
+        classSymbolMap: MutableMap<IrClassSymbol, IrClassSymbol>,
+        functionSymbolMap: MutableMap<IrSimpleFunctionSymbol, IrSimpleFunctionSymbol>
+    ) {}
+
+    fun isSideEffectFree(call: IrCall): Boolean {
+        return false
+    }
+}

build-benchmarks/src/main/resources/change-files/compiler/CommonBackendContext/_target-file.txt

@@ -0,0 +1 @@
+compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CommonBackendContext.kt

build-benchmarks/src/main/resources/change-files/compiler/CommonBackendContext/addPrivateFunction.benchmark

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common
+
+import org.jetbrains.kotlin.backend.common.ir.Ir
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
+import org.jetbrains.kotlin.ir.builders.irCall
+import org.jetbrains.kotlin.ir.builders.irString
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+
+interface LoggingContext {
+    var inVerbosePhase: Boolean
+    fun log(message: () -> String)
+}
+
+interface CommonBackendContext : BackendContext, LoggingContext {
+    override val ir: Ir<CommonBackendContext>
+
+    fun report(element: IrElement?, irFile: IrFile?, message: String, isError: Boolean)
+
+    val configuration: CompilerConfiguration
+    val scriptMode: Boolean
+
+    fun throwUninitializedPropertyAccessException(builder: IrBuilderWithScope, name: String): IrExpression {
+        val throwErrorFunction = ir.symbols.throwUninitializedPropertyAccessException.owner
+        return builder.irCall(throwErrorFunction).apply {
+            putValueArgument(0, builder.irString(name))
+        }
+    }
+
+    val mapping: Mapping
+
+    // Adjust internal structures after a deep copy of some declarations.
+    fun handleDeepCopy(
+        fileSymbolMap: MutableMap<IrFileSymbol, IrFileSymbol>,
+        classSymbolMap: MutableMap<IrClassSymbol, IrClassSymbol>,
+        functionSymbolMap: MutableMap<IrSimpleFunctionSymbol, IrSimpleFunctionSymbol>
+    ) {}
+
+    fun isSideEffectFree(call: IrCall): Boolean {
+        return false
+    }
+}
+
+private fun foo() {}

build-benchmarks/src/main/resources/change-files/compiler/CommonBackendContext/addPublicFunction.benchmark

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common
+
+import org.jetbrains.kotlin.backend.common.ir.Ir
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
+import org.jetbrains.kotlin.ir.builders.irCall
+import org.jetbrains.kotlin.ir.builders.irString
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+
+interface LoggingContext {
+    var inVerbosePhase: Boolean
+    fun log(message: () -> String)
+}
+
+interface CommonBackendContext : BackendContext, LoggingContext {
+    override val ir: Ir<CommonBackendContext>
+
+    fun report(element: IrElement?, irFile: IrFile?, message: String, isError: Boolean)
+
+    val configuration: CompilerConfiguration
+    val scriptMode: Boolean
+
+    fun throwUninitializedPropertyAccessException(builder: IrBuilderWithScope, name: String): IrExpression {
+        val throwErrorFunction = ir.symbols.throwUninitializedPropertyAccessException.owner
+        return builder.irCall(throwErrorFunction).apply {
+            putValueArgument(0, builder.irString(name))
+        }
+    }
+
+    val mapping: Mapping
+
+    // Adjust internal structures after a deep copy of some declarations.
+    fun handleDeepCopy(
+        fileSymbolMap: MutableMap<IrFileSymbol, IrFileSymbol>,
+        classSymbolMap: MutableMap<IrClassSymbol, IrClassSymbol>,
+        functionSymbolMap: MutableMap<IrSimpleFunctionSymbol, IrSimpleFunctionSymbol>
+    ) {}
+
+    fun isSideEffectFree(call: IrCall): Boolean {
+        return false
+    }
+}
+
+fun foo() {}

build-benchmarks/src/main/resources/change-files/coreUtil/CoreLibKt/_initial.benchmark

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+inline fun <T : Any> T?.sure(message: () -> String): T = this ?: throw AssertionError(message())

build-benchmarks/src/main/resources/change-files/coreUtil/CoreLibKt/_target-file.txt

@@ -0,0 +1 @@
+core/util.runtime/src/org/jetbrains/kotlin/utils/coreLib.kt

build-benchmarks/src/main/resources/change-files/coreUtil/CoreLibKt/changeInlineFunction.benchmark

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+fun <T : Any> T?.sure(message: () -> String): T = this ?: throw AssertionError(message())

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/_initial.benchmark

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) = collection.joinToString(separator)

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/_target-file.txt

@@ -0,0 +1 @@
+core/util.runtime/src/org/jetbrains/kotlin/utils/strings.kt

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/addPrivateClass.benchmark

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) = collection.joinToString(separator)
+
+private class Foo()

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/addPrivateFunction.benchmark

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) = collection.joinToString(separator)
+
+private fun foo() {}

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/addPublicClass.benchmark

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) = collection.joinToString(separator)
+
+class Foo()

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/addPublicFunction.benchmark

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) = collection.joinToString(separator)
+
+fun foo() {}

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/fixCompileError.benchmark

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) = collection.joinToString(separator)

build-benchmarks/src/main/resources/change-files/coreUtil/StringsKt/introduceCompileError.benchmark

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.utils
+
+// Needed for Java interop: otherwise you need to specify all the optional parameters to join, i.e. prefix, postfix, limit, truncated
+fun join(collection: Iterable<Any>, separator: String) =

build-benchmarks/src/main/resources/change-files/gavra0/coreDescriptors/ClassDescriptorBaseJava/_initial.benchmark

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.descriptors.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
+import org.jetbrains.kotlin.descriptors.SourceElement;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.storage.StorageManager;
+
+public abstract class ClassDescriptorBase extends AbstractClassDescriptor {
+
+    private final DeclarationDescriptor containingDeclaration;
+    private final SourceElement source;
+    private final boolean isExternal;
+
+    protected ClassDescriptorBase(
+            @NotNull StorageManager storageManager,
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull Name name,
+            @NotNull SourceElement source,
+            boolean isExternal
+    ) {
+        super(storageManager, name);
+        this.containingDeclaration = containingDeclaration;
+        this.source = source;
+        this.isExternal = isExternal;
+    }
+
+    @Override
+    public boolean isExternal() {
+        return isExternal;
+    }
+
+    @NotNull
+    @Override
+    public DeclarationDescriptor getContainingDeclaration() {
+        return containingDeclaration;
+    }
+
+    @NotNull
+    @Override
+    public SourceElement getSource() {
+        return source;
+    }
+}

build-benchmarks/src/main/resources/change-files/gavra0/coreDescriptors/ClassDescriptorBaseJava/_target-file.txt

@@ -0,0 +1 @@
+core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorBase.java

build-benchmarks/src/main/resources/change-files/gavra0/coreDescriptors/ClassDescriptorBaseJava/addPublicFunction.benchmark

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.descriptors.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
+import org.jetbrains.kotlin.descriptors.SourceElement;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.storage.StorageManager;
+
+public abstract class ClassDescriptorBase extends AbstractClassDescriptor {
+
+    private final DeclarationDescriptor containingDeclaration;
+    private final SourceElement source;
+    private final boolean isExternal;
+
+    protected ClassDescriptorBase(
+            @NotNull StorageManager storageManager,
+            @NotNull DeclarationDescriptor containingDeclaration,
+            @NotNull Name name,
+            @NotNull SourceElement source,
+            boolean isExternal
+    ) {
+        super(storageManager, name);
+        this.containingDeclaration = containingDeclaration;
+        this.source = source;
+        this.isExternal = isExternal;
+    }
+
+    @Override
+    public boolean isExternal() {
+        return isExternal;
+    }
+
+    @NotNull
+    @Override
+    public DeclarationDescriptor getContainingDeclaration() {
+        return containingDeclaration;
+    }
+
+    @NotNull
+    @Override
+    public SourceElement getSource() {
+        return source;
+    }
+
+    public static String foo() {
+        return "bar";
+    }
+}

build-benchmarks/src/main/resources/change-files/gavra0/stdlib/FileTreeWalkKt/_initial.benchmark

@@ -0,0 +1,272 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:JvmMultifileClass
+@file:JvmName("FilesKt")
+
+package kotlin.io
+
+import java.io.File
+import java.io.IOException
+import java.util.ArrayDeque
+
+/**
+ * An enumeration to describe possible walk directions.
+ * There are two of them: beginning from parents, ending with children,
+ * and beginning from children, ending with parents. Both use depth-first search.
+ */
+public enum class FileWalkDirection {
+    /** Depth-first search, directory is visited BEFORE its files */
+    TOP_DOWN,
+    /** Depth-first search, directory is visited AFTER its files */
+    BOTTOM_UP
+    // Do we want also breadth-first search?
+}
+
+/**
+ * This class is intended to implement different file traversal methods.
+ * It allows to iterate through all files inside a given directory.
+ *
+ * Use [File.walk], [File.walkTopDown] or [File.walkBottomUp] extension functions to instantiate a `FileTreeWalk` instance.
+
+ * If the file path given is just a file, walker iterates only it.
+ * If the file path given does not exist, walker iterates nothing, i.e. it's equivalent to an empty sequence.
+ */
+public class FileTreeWalk private constructor(
+    private val start: File,
+    private val direction: FileWalkDirection = FileWalkDirection.TOP_DOWN,
+    private val onEnter: ((File) -> Boolean)?,
+    private val onLeave: ((File) -> Unit)?,
+    private val onFail: ((f: File, e: IOException) -> Unit)?,
+    private val maxDepth: Int = Int.MAX_VALUE
+) : Sequence<File> {
+
+    internal constructor(start: File, direction: FileWalkDirection = FileWalkDirection.TOP_DOWN) : this(start, direction, null, null, null)
+
+
+    /** Returns an iterator walking through files. */
+    override fun iterator(): Iterator<File> = FileTreeWalkIterator()
+
+    /** Abstract class that encapsulates file visiting in some order, beginning from a given [root] */
+    private abstract class WalkState(val root: File) {
+        /** Call of this function proceeds to a next file for visiting and returns it */
+        public abstract fun step(): File?
+    }
+
+    /** Abstract class that encapsulates directory visiting in some order, beginning from a given [rootDir] */
+    private abstract class DirectoryState(rootDir: File) : WalkState(rootDir) {
+        init {
+            if (_Assertions.ENABLED)
+                assert(rootDir.isDirectory) { "rootDir must be verified to be directory beforehand." }
+        }
+    }
+
+    private inner class FileTreeWalkIterator : AbstractIterator<File>() {
+
+        // Stack of directory states, beginning from the start directory
+        private val state = ArrayDeque<WalkState>()
+
+        init {
+            when {
+                start.isDirectory -> state.push(directoryState(start))
+                start.isFile -> state.push(SingleFileState(start))
+                else -> done()
+            }
+        }
+
+        override fun computeNext() {
+            val nextFile = gotoNext()
+            if (nextFile != null)
+                setNext(nextFile)
+            else
+                done()
+        }
+
+
+        private fun directoryState(root: File): DirectoryState {
+            return when (direction) {
+                FileWalkDirection.TOP_DOWN -> TopDownDirectoryState(root)
+                FileWalkDirection.BOTTOM_UP -> BottomUpDirectoryState(root)
+            }
+        }
+
+        private tailrec fun gotoNext(): File? {
+            // Take next file from the top of the stack or return if there's nothing left
+            val topState = state.peek() ?: return null
+            val file = topState.step()
+            if (file == null) {
+                // There is nothing more on the top of the stack, go back
+                state.pop()
+                return gotoNext()
+            } else {
+                // Check that file/directory matches the filter
+                if (file == topState.root || !file.isDirectory || state.size >= maxDepth) {
+                    // Proceed to a root directory or a simple file
+                    return file
+                } else {
+                    // Proceed to a sub-directory
+                    state.push(directoryState(file))
+                    return gotoNext()
+                }
+            }
+        }
+
+        /** Visiting in bottom-up order */
+        private inner class BottomUpDirectoryState(rootDir: File) : DirectoryState(rootDir) {
+
+            private var rootVisited = false
+
+            private var fileList: Array<File>? = null
+
+            private var fileIndex = 0
+
+            private var failed = false
+
+            /** First all children, then root directory */
+            override fun step(): File? {
+                if (!failed && fileList == null) {
+                    if (onEnter?.invoke(root) == false) {
+                        return null
+                    }
+
+                    fileList = root.listFiles()
+                    if (fileList == null) {
+                        onFail?.invoke(root, AccessDeniedException(file = root, reason = "Cannot list files in a directory"))
+                        failed = true
+                    }
+                }
+                if (fileList != null && fileIndex < fileList!!.size) {
+                    // First visit all files
+                    return fileList!![fileIndex++]
+                } else if (!rootVisited) {
+                    // Then visit root
+                    rootVisited = true
+                    return root
+                } else {
+                    // That's all
+                    onLeave?.invoke(root)
+                    return null
+                }
+            }
+        }
+
+        /** Visiting in top-down order */
+        private inner class TopDownDirectoryState(rootDir: File) : DirectoryState(rootDir) {
+
+            private var rootVisited = false
+
+            private var fileList: Array<File>? = null
+
+            private var fileIndex = 0
+
+            /** First root directory, then all children */
+            override fun step(): File? {
+                if (!rootVisited) {
+                    // First visit root
+                    if (onEnter?.invoke(root) == false) {
+                        return null
+                    }
+
+                    rootVisited = true
+                    return root
+                } else if (fileList == null || fileIndex < fileList!!.size) {
+                    if (fileList == null) {
+                        // Then read an array of files, if any
+                        fileList = root.listFiles()
+                        if (fileList == null) {
+                            onFail?.invoke(root, AccessDeniedException(file = root, reason = "Cannot list files in a directory"))
+                        }
+                        if (fileList == null || fileList!!.size == 0) {
+                            onLeave?.invoke(root)
+                            return null
+                        }
+                    }
+                    // Then visit all files
+                    return fileList!![fileIndex++]
+                } else {
+                    // That's all
+                    onLeave?.invoke(root)
+                    return null
+                }
+            }
+        }
+
+        private inner class SingleFileState(rootFile: File) : WalkState(rootFile) {
+            private var visited: Boolean = false
+
+            init {
+                if (_Assertions.ENABLED)
+                    assert(rootFile.isFile) { "rootFile must be verified to be file beforehand." }
+            }
+
+            override fun step(): File? {
+                if (visited) return null
+                visited = true
+                return root
+            }
+        }
+
+    }
+
+    /**
+     * Sets a predicate [function], that is called on any entered directory before its files are visited
+     * and before it is visited itself.
+     *
+     * If the [function] returns `false` the directory is not entered and neither it nor its files are visited.
+     */
+    public fun onEnter(function: (File) -> Boolean): FileTreeWalk {
+        return FileTreeWalk(start, direction, onEnter = function, onLeave = onLeave, onFail = onFail, maxDepth = maxDepth)
+    }
+
+    /**
+     * Sets a callback [function], that is called on any left directory after its files are visited and after it is visited itself.
+     */
+    public fun onLeave(function: (File) -> Unit): FileTreeWalk {
+        return FileTreeWalk(start, direction, onEnter = onEnter, onLeave = function, onFail = onFail, maxDepth = maxDepth)
+    }
+
+    /**
+     * Set a callback [function], that is called on a directory when it's impossible to get its file list.
+     *
+     * [onEnter] and [onLeave] callback functions are called even in this case.
+     */
+    public fun onFail(function: (File, IOException) -> Unit): FileTreeWalk {
+        return FileTreeWalk(start, direction, onEnter = onEnter, onLeave = onLeave, onFail = function, maxDepth = maxDepth)
+    }
+
+    /**
+     * Sets the maximum [depth] of a directory tree to traverse. By default there is no limit.
+     *
+     * The value must be positive and [Int.MAX_VALUE] is used to specify an unlimited depth.
+     *
+     * With a value of 1, walker visits only the origin directory and all its immediate children,
+     * with a value of 2 also grandchildren, etc.
+     */
+    public fun maxDepth(depth: Int): FileTreeWalk {
+        if (depth <= 0)
+            throw IllegalArgumentException("depth must be positive, but was $depth.")
+        return FileTreeWalk(start, direction, onEnter, onLeave, onFail, depth)
+    }
+}
+
+/**
+ * Gets a sequence for visiting this directory and all its content.
+ *
+ * @param direction walk direction, top-down (by default) or bottom-up.
+ */
+public fun File.walk(direction: FileWalkDirection = FileWalkDirection.TOP_DOWN): FileTreeWalk =
+    FileTreeWalk(this, direction)
+
+/**
+ * Gets a sequence for visiting this directory and all its content in top-down order.
+ * Depth-first search is used and directories are visited before all their files.
+ */
+public fun File.walkTopDown(): FileTreeWalk = walk(FileWalkDirection.TOP_DOWN)
+
+/**
+ * Gets a sequence for visiting this directory and all its content in bottom-up order.
+ * Depth-first search is used and directories are visited after all their files.
+ */
+public fun File.walkBottomUp(): FileTreeWalk = walk(FileWalkDirection.BOTTOM_UP)

build-benchmarks/src/main/resources/change-files/gavra0/stdlib/FileTreeWalkKt/_target-file.txt

@@ -0,0 +1 @@
+libraries/stdlib/jvm/src/kotlin/io/files/FileTreeWalk.kt

build-benchmarks/src/main/resources/change-files/gavra0/stdlib/FileTreeWalkKt/addPublicFunction.benchmark

@@ -0,0 +1,276 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+@file:JvmMultifileClass
+@file:JvmName("FilesKt")
+
+package kotlin.io
+
+import java.io.File
+import java.io.IOException
+import java.util.ArrayDeque
+
+/**
+ * An enumeration to describe possible walk directions.
+ * There are two of them: beginning from parents, ending with children,
+ * and beginning from children, ending with parents. Both use depth-first search.
+ */
+public enum class FileWalkDirection {
+    /** Depth-first search, directory is visited BEFORE its files */
+    TOP_DOWN,
+    /** Depth-first search, directory is visited AFTER its files */
+    BOTTOM_UP
+    // Do we want also breadth-first search?
+}
+
+/**
+ * This class is intended to implement different file traversal methods.
+ * It allows to iterate through all files inside a given directory.
+ *
+ * Use [File.walk], [File.walkTopDown] or [File.walkBottomUp] extension functions to instantiate a `FileTreeWalk` instance.
+
+ * If the file path given is just a file, walker iterates only it.
+ * If the file path given does not exist, walker iterates nothing, i.e. it's equivalent to an empty sequence.
+ */
+public class FileTreeWalk private constructor(
+    private val start: File,
+    private val direction: FileWalkDirection = FileWalkDirection.TOP_DOWN,
+    private val onEnter: ((File) -> Boolean)?,
+    private val onLeave: ((File) -> Unit)?,
+    private val onFail: ((f: File, e: IOException) -> Unit)?,
+    private val maxDepth: Int = Int.MAX_VALUE
+) : Sequence<File> {
+
+    internal constructor(start: File, direction: FileWalkDirection = FileWalkDirection.TOP_DOWN) : this(start, direction, null, null, null)
+
+
+    /** Returns an iterator walking through files. */
+    override fun iterator(): Iterator<File> = FileTreeWalkIterator()
+
+    /** Abstract class that encapsulates file visiting in some order, beginning from a given [root] */
+    private abstract class WalkState(val root: File) {
+        /** Call of this function proceeds to a next file for visiting and returns it */
+        public abstract fun step(): File?
+    }
+
+    /** Abstract class that encapsulates directory visiting in some order, beginning from a given [rootDir] */
+    private abstract class DirectoryState(rootDir: File) : WalkState(rootDir) {
+        init {
+            if (_Assertions.ENABLED)
+                assert(rootDir.isDirectory) { "rootDir must be verified to be directory beforehand." }
+        }
+    }
+
+    private inner class FileTreeWalkIterator : AbstractIterator<File>() {
+
+        // Stack of directory states, beginning from the start directory
+        private val state = ArrayDeque<WalkState>()
+
+        init {
+            when {
+                start.isDirectory -> state.push(directoryState(start))
+                start.isFile -> state.push(SingleFileState(start))
+                else -> done()
+            }
+        }
+
+        override fun computeNext() {
+            val nextFile = gotoNext()
+            if (nextFile != null)
+                setNext(nextFile)
+            else
+                done()
+        }
+
+
+        private fun directoryState(root: File): DirectoryState {
+            return when (direction) {
+                FileWalkDirection.TOP_DOWN -> TopDownDirectoryState(root)
+                FileWalkDirection.BOTTOM_UP -> BottomUpDirectoryState(root)
+            }
+        }
+
+        private tailrec fun gotoNext(): File? {
+            // Take next file from the top of the stack or return if there's nothing left
+            val topState = state.peek() ?: return null
+            val file = topState.step()
+            if (file == null) {
+                // There is nothing more on the top of the stack, go back
+                state.pop()
+                return gotoNext()
+            } else {
+                // Check that file/directory matches the filter
+                if (file == topState.root || !file.isDirectory || state.size >= maxDepth) {
+                    // Proceed to a root directory or a simple file
+                    return file
+                } else {
+                    // Proceed to a sub-directory
+                    state.push(directoryState(file))
+                    return gotoNext()
+                }
+            }
+        }
+
+        /** Visiting in bottom-up order */
+        private inner class BottomUpDirectoryState(rootDir: File) : DirectoryState(rootDir) {
+
+            private var rootVisited = false
+
+            private var fileList: Array<File>? = null
+
+            private var fileIndex = 0
+
+            private var failed = false
+
+            /** First all children, then root directory */
+            override fun step(): File? {
+                if (!failed && fileList == null) {
+                    if (onEnter?.invoke(root) == false) {
+                        return null
+                    }
+
+                    fileList = root.listFiles()
+                    if (fileList == null) {
+                        onFail?.invoke(root, AccessDeniedException(file = root, reason = "Cannot list files in a directory"))
+                        failed = true
+                    }
+                }
+                if (fileList != null && fileIndex < fileList!!.size) {
+                    // First visit all files
+                    return fileList!![fileIndex++]
+                } else if (!rootVisited) {
+                    // Then visit root
+                    rootVisited = true
+                    return root
+                } else {
+                    // That's all
+                    onLeave?.invoke(root)
+                    return null
+                }
+            }
+        }
+
+        /** Visiting in top-down order */
+        private inner class TopDownDirectoryState(rootDir: File) : DirectoryState(rootDir) {
+
+            private var rootVisited = false
+
+            private var fileList: Array<File>? = null
+
+            private var fileIndex = 0
+
+            /** First root directory, then all children */
+            override fun step(): File? {
+                if (!rootVisited) {
+                    // First visit root
+                    if (onEnter?.invoke(root) == false) {
+                        return null
+                    }
+
+                    rootVisited = true
+                    return root
+                } else if (fileList == null || fileIndex < fileList!!.size) {
+                    if (fileList == null) {
+                        // Then read an array of files, if any
+                        fileList = root.listFiles()
+                        if (fileList == null) {
+                            onFail?.invoke(root, AccessDeniedException(file = root, reason = "Cannot list files in a directory"))
+                        }
+                        if (fileList == null || fileList!!.size == 0) {
+                            onLeave?.invoke(root)
+                            return null
+                        }
+                    }
+                    // Then visit all files
+                    return fileList!![fileIndex++]
+                } else {
+                    // That's all
+                    onLeave?.invoke(root)
+                    return null
+                }
+            }
+        }
+
+        private inner class SingleFileState(rootFile: File) : WalkState(rootFile) {
+            private var visited: Boolean = false
+
+            init {
+                if (_Assertions.ENABLED)
+                    assert(rootFile.isFile) { "rootFile must be verified to be file beforehand." }
+            }
+
+            override fun step(): File? {
+                if (visited) return null
+                visited = true
+                return root
+            }
+        }
+
+    }
+
+    /**
+     * Sets a predicate [function], that is called on any entered directory before its files are visited
+     * and before it is visited itself.
+     *
+     * If the [function] returns `false` the directory is not entered and neither it nor its files are visited.
+     */
+    public fun onEnter(function: (File) -> Boolean): FileTreeWalk {
+        return FileTreeWalk(start, direction, onEnter = function, onLeave = onLeave, onFail = onFail, maxDepth = maxDepth)
+    }
+
+    /**
+     * Sets a callback [function], that is called on any left directory after its files are visited and after it is visited itself.
+     */
+    public fun onLeave(function: (File) -> Unit): FileTreeWalk {
+        return FileTreeWalk(start, direction, onEnter = onEnter, onLeave = function, onFail = onFail, maxDepth = maxDepth)
+    }
+
+    /**
+     * Set a callback [function], that is called on a directory when it's impossible to get its file list.
+     *
+     * [onEnter] and [onLeave] callback functions are called even in this case.
+     */
+    public fun onFail(function: (File, IOException) -> Unit): FileTreeWalk {
+        return FileTreeWalk(start, direction, onEnter = onEnter, onLeave = onLeave, onFail = function, maxDepth = maxDepth)
+    }
+
+    /**
+     * Sets the maximum [depth] of a directory tree to traverse. By default there is no limit.
+     *
+     * The value must be positive and [Int.MAX_VALUE] is used to specify an unlimited depth.
+     *
+     * With a value of 1, walker visits only the origin directory and all its immediate children,
+     * with a value of 2 also grandchildren, etc.
+     */
+    public fun maxDepth(depth: Int): FileTreeWalk {
+        if (depth <= 0)
+            throw IllegalArgumentException("depth must be positive, but was $depth.")
+        return FileTreeWalk(start, direction, onEnter, onLeave, onFail, depth)
+    }
+
+    public fun foo(): Int {
+        return 0;
+    }
+}
+
+/**
+ * Gets a sequence for visiting this directory and all its content.
+ *
+ * @param direction walk direction, top-down (by default) or bottom-up.
+ */
+public fun File.walk(direction: FileWalkDirection = FileWalkDirection.TOP_DOWN): FileTreeWalk =
+    FileTreeWalk(this, direction)
+
+/**
+ * Gets a sequence for visiting this directory and all its content in top-down order.
+ * Depth-first search is used and directories are visited before all their files.
+ */
+public fun File.walkTopDown(): FileTreeWalk = walk(FileWalkDirection.TOP_DOWN)
+
+/**
+ * Gets a sequence for visiting this directory and all its content in bottom-up order.
+ * Depth-first search is used and directories are visited after all their files.
+ */
+public fun File.walkBottomUp(): FileTreeWalk = walk(FileWalkDirection.BOTTOM_UP)

build-benchmarks/src/main/resources/change-files/kotlinGradlePlugin/ConfigurationPhaseAware/_initial.benchmark

@@ -0,0 +1,37 @@
+/*
+ * 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.gradle.internal
+
+import kotlin.reflect.KProperty
+
+abstract class ConfigurationPhaseAware<C : Any> {
+
+    private var configured: C? = null
+
+    @Synchronized
+    fun requireConfigured(): C {
+        if (configured == null) {
+            configured = finalizeConfiguration()
+        }
+
+        return configured!!
+    }
+
+    protected fun requireNotConfigured() {
+        check(configured == null) { "Configuration already finalized for previous property values" }
+    }
+
+    inner class Property<T>(var value: T) {
+        operator fun getValue(receiver: Any, property: KProperty<*>): T = value
+
+        operator fun setValue(receiver: Any, property: KProperty<*>, value: T) {
+            requireNotConfigured()
+            this.value = value
+        }
+    }
+
+    protected abstract fun finalizeConfiguration(): C
+}

build-benchmarks/src/main/resources/change-files/kotlinGradlePlugin/ConfigurationPhaseAware/_target-file.txt

@@ -0,0 +1 @@
+libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/ConfigurationPhaseAware.kt

build-benchmarks/src/main/resources/change-files/kotlinGradlePlugin/ConfigurationPhaseAware/addPrivateFunction.benchmark

@@ -0,0 +1,39 @@
+/*
+ * 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.gradle.internal
+
+import kotlin.reflect.KProperty
+
+abstract class ConfigurationPhaseAware<C : Any> {
+
+    private var configured: C? = null
+
+    @Synchronized
+    fun requireConfigured(): C {
+        if (configured == null) {
+            configured = finalizeConfiguration()
+        }
+
+        return configured!!
+    }
+
+    protected fun requireNotConfigured() {
+        check(configured == null) { "Configuration already finalized for previous property values" }
+    }
+
+    inner class Property<T>(var value: T) {
+        operator fun getValue(receiver: Any, property: KProperty<*>): T = value
+
+        operator fun setValue(receiver: Any, property: KProperty<*>, value: T) {
+            requireNotConfigured()
+            this.value = value
+        }
+    }
+
+    protected abstract fun finalizeConfiguration(): C
+}
+
+private fun foo() {}

build-benchmarks/src/main/resources/change-files/kotlinGradlePlugin/ConfigurationPhaseAware/addPublicFunction.benchmark

@@ -0,0 +1,39 @@
+/*
+ * 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.gradle.internal
+
+import kotlin.reflect.KProperty
+
+abstract class ConfigurationPhaseAware<C : Any> {
+
+    private var configured: C? = null
+
+    @Synchronized
+    fun requireConfigured(): C {
+        if (configured == null) {
+            configured = finalizeConfiguration()
+        }
+
+        return configured!!
+    }
+
+    protected fun requireNotConfigured() {
+        check(configured == null) { "Configuration already finalized for previous property values" }
+    }
+
+    inner class Property<T>(var value: T) {
+        operator fun getValue(receiver: Any, property: KProperty<*>): T = value
+
+        operator fun setValue(receiver: Any, property: KProperty<*>, value: T) {
+            requireNotConfigured()
+            this.value = value
+        }
+    }
+
+    protected abstract fun finalizeConfiguration(): C
+}
+
+fun foo() {}

build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt

@@ -118,7 +118,7 @@ class ChangesCollector {
                     storage[packageProtoKey?.let { FqName(it) } ?: fqName] = newData
                 }
             }
-        } else if (oldData != null) {
+        } else {
             when (oldData) {
                 is ClassProtoData -> {
                     removed.add(oldData.nameResolver.getClassId(oldData.proto.fqName).asSingleFqName())

build-common/src/org/jetbrains/kotlin/incremental/ClasspathChanges.kt

@@ -1,76 +0,0 @@
-/*
- * 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.incremental
-
-import org.jetbrains.kotlin.name.FqName
-import java.io.ObjectInputStream
-import java.io.ObjectOutputStream
-import java.io.Serializable
-
-/**
- * Changes to the classpath of the `KotlinCompile` task, used to compute the source files that need to be recompiled during an incremental
- * run.
- */
-sealed class ClasspathChanges : Serializable {
-
-    class Available() : ClasspathChanges() {
-
-        lateinit var lookupSymbols: List<LookupSymbol>
-            private set
-
-        lateinit var fqNames: List<FqName>
-            private set
-
-        constructor(lookupSymbols: List<LookupSymbol>, fqNames: List<FqName>) : this() {
-            this.lookupSymbols = lookupSymbols
-            this.fqNames = fqNames
-        }
-
-        private fun writeObject(out: ObjectOutputStream) {
-            out.writeInt(lookupSymbols.size)
-            lookupSymbols.forEach {
-                out.writeUTF(it.name)
-                out.writeUTF(it.scope)
-            }
-
-            out.writeInt(fqNames.size)
-            fqNames.forEach {
-                out.writeUTF(it.asString())
-            }
-        }
-
-        private fun readObject(ois: ObjectInputStream) {
-            val lookupSymbolsSize = ois.readInt()
-            val lookupSymbols = ArrayList<LookupSymbol>(lookupSymbolsSize)
-            repeat(lookupSymbolsSize) {
-                val name = ois.readUTF()
-                val scope = ois.readUTF()
-                lookupSymbols.add(LookupSymbol(name, scope))
-            }
-            this.lookupSymbols = lookupSymbols
-
-            val fqNamesSize = ois.readInt()
-            val fqNames = ArrayList<FqName>(fqNamesSize)
-            repeat(fqNamesSize) {
-                val fqNameString = ois.readUTF()
-                fqNames.add(FqName(fqNameString))
-            }
-            this.fqNames = fqNames
-        }
-
-        companion object {
-            private const val serialVersionUID = 0L
-        }
-    }
-
-    sealed class NotAvailable : ClasspathChanges() {
-        object UnableToCompute : NotAvailable()
-        object ForNonIncrementalRun : NotAvailable()
-        object ClasspathSnapshotIsDisabled : NotAvailable()
-        object ReservedForTestsOnly : NotAvailable()
-        object ForJSCompiler : NotAvailable()
-    }
-}

build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.incremental
 
-import com.intellij.openapi.diagnostic.Logger
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -34,8 +33,6 @@ open class LookupStorage(
     targetDataDir: File,
     pathConverter: FileToPathConverter
 ) : BasicMapsOwner(targetDataDir) {
-    val LOG = Logger.getInstance("#org.jetbrains.kotlin.jps.build.KotlinBuilder")
-
     companion object {
         private val DELETED_TO_SIZE_TRESHOLD = 0.5
         private val MINIMUM_GARBAGE_COLLECTIBLE_SIZE = 10000
@@ -49,39 +46,31 @@ open class LookupStorage(
     @Volatile
     private var size: Int = 0
 
+    @Volatile
+    private var deletedCount: Int = 0
+
     init {
         try {
             if (countersFile.exists()) {
                 val lines = countersFile.readLines()
                 size = lines[0].toInt()
+                deletedCount = lines[1].toInt()
             }
         } catch (e: Exception) {
             throw IOException("Could not read $countersFile", e)
         }
+
     }
 
     @Synchronized
     fun get(lookupSymbol: LookupSymbol): Collection<String> {
         val key = LookupSymbolKey(lookupSymbol.name, lookupSymbol.scope)
         val fileIds = lookupMap[key] ?: return emptySet()
-        val paths = mutableSetOf<String>()
-        val filtered = mutableSetOf<Int>()
-
-        for (fileId in fileIds) {
-            val path = idToFile[fileId]?.path
-
-            if (path != null) {
-                paths.add(path)
-                filtered.add(fileId)
-            }
 
+        return fileIds.mapNotNull {
+            // null means it's outdated
+            idToFile[it]?.path
         }
-
-        if (size > MINIMUM_GARBAGE_COLLECTIBLE_SIZE && filtered.size.toDouble() / fileIds.size.toDouble() < DELETED_TO_SIZE_TRESHOLD) {
-            lookupMap[key] = filtered
-        }
-
-        return paths
     }
 
     @Synchronized
@@ -92,8 +81,8 @@ open class LookupStorage(
             val key = LookupSymbolKey(lookupSymbol.name, lookupSymbol.scope)
             val paths = lookups[lookupSymbol]
             val fileIds = paths.mapTo(TreeSet()) { pathToId[it]!! }
-
-            lookupMap.append(key, fileIds)
+            fileIds.addAll(lookupMap[key] ?: emptySet())
+            lookupMap[key] = fileIds
         }
     }
 
@@ -103,6 +92,7 @@ open class LookupStorage(
             val id = fileToId[file] ?: continue
             idToFile.remove(id)
             fileToId.remove(file)
+            deletedCount++
         }
     }
 
@@ -113,6 +103,7 @@ open class LookupStorage(
         }
 
         size = 0
+        deletedCount = 0
 
         super.clean()
     }
@@ -120,15 +111,18 @@ open class LookupStorage(
     @Synchronized
     override fun flush(memoryCachesOnly: Boolean) {
         try {
+            removeGarbageIfNeeded()
+
             if (size > 0) {
                 if (!countersFile.exists()) {
                     countersFile.parentFile.mkdirs()
                     countersFile.createNewFile()
                 }
 
-                countersFile.writeText("$size\n")
+                countersFile.writeText("$size\n$deletedCount")
             }
-        } finally {
+        }
+        finally {
             super.flush(memoryCachesOnly)
         }
     }
@@ -143,7 +137,13 @@ open class LookupStorage(
         return id
     }
 
-    private fun removeGarbageForTests() {
+    private fun removeGarbageIfNeeded(force: Boolean = false) {
+        if (force || (size > MINIMUM_GARBAGE_COLLECTIBLE_SIZE && deletedCount.toDouble() / size > DELETED_TO_SIZE_TRESHOLD)) {
+            doRemoveGarbage()
+        }
+    }
+
+    private fun doRemoveGarbage() {
         for (hash in lookupMap.keys) {
             lookupMap[hash] = lookupMap[hash]!!.filter { it in idToFile }.toSet()
         }
@@ -153,6 +153,7 @@ open class LookupStorage(
         idToFile.clean()
         fileToId.clean()
         size = 0
+        deletedCount = 0
 
         for ((file, oldId) in oldFileToId.entries.sortedBy { it.key.path }) {
             val newId = addFileIfNeeded(file)
@@ -164,16 +165,15 @@ open class LookupStorage(
 
             if (fileIds.isEmpty()) {
                 lookupMap.remove(lookup)
-            } else {
+            }
+            else {
                 lookupMap[lookup] = fileIds
             }
         }
     }
 
-
-    @TestOnly
-    fun forceGC() {
-        removeGarbageForTests()
+    @TestOnly fun forceGC() {
+        removeGarbageIfNeeded(force = true)
         flush(false)
     }
 

build-common/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt

@@ -1104,11 +1104,6 @@ open class ProtoCompareGenerated(
             if (!checkEquals(old.setter, new.setter)) return false
         }
 
-        if (old.hasDelegateMethod() != new.hasDelegateMethod()) return false
-        if (old.hasDelegateMethod()) {
-            if (!checkEquals(old.delegateMethod, new.delegateMethod)) return false
-        }
-
         return true
     }
 
@@ -2358,10 +2353,6 @@ fun JvmProtoBuf.JvmPropertySignature.hashCode(stringIndexes: (Int) -> Int, fqNam
         hashCode = 31 * hashCode + setter.hashCode(stringIndexes, fqNameIndexes, typeById)
     }
 
-    if (hasDelegateMethod()) {
-        hashCode = 31 * hashCode + delegateMethod.hashCode(stringIndexes, fqNameIndexes, typeById)
-    }
-
     return hashCode
 }
 

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

@@ -27,10 +27,6 @@ class LookupMap(storage: File) : BasicMap<LookupSymbolKey, Collection<Int>>(stor
         storage.append(LookupSymbolKey(name, scope), listOf(fileId))
     }
 
-    fun append(lookup: LookupSymbolKey, fileIds: Collection<Int>) {
-        storage.append(lookup, fileIds)
-    }
-
     operator fun get(key: LookupSymbolKey): Collection<Int>? = storage[key]
 
     operator fun set(key: LookupSymbolKey, fileIds: Set<Int>) {

build-common/test/org/jetbrains/kotlin/metadata/jvm/DebugJvmProtoBuf.java

@@ -3443,34 +3443,6 @@ public final class DebugJvmProtoBuf {
      * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature setter = 4;</code>
      */
     org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getSetterOrBuilder();
-
-    /**
-     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-     *
-     * <pre>
-     * The delegate field of delegated properties may be optimized out; `getDelegate` should
-     * then call this method instead
-     * </pre>
-     */
-    boolean hasDelegateMethod();
-    /**
-     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-     *
-     * <pre>
-     * The delegate field of delegated properties may be optimized out; `getDelegate` should
-     * then call this method instead
-     * </pre>
-     */
-    org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature getDelegateMethod();
-    /**
-     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-     *
-     * <pre>
-     * The delegate field of delegated properties may be optimized out; `getDelegate` should
-     * then call this method instead
-     * </pre>
-     */
-    org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getDelegateMethodOrBuilder();
   }
   /**
    * Protobuf type {@code org.jetbrains.kotlin.metadata.jvm.JvmPropertySignature}
@@ -3576,19 +3548,6 @@ public final class DebugJvmProtoBuf {
               bitField0_ |= 0x00000008;
               break;
             }
-            case 42: {
-              org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder subBuilder = null;
-              if (((bitField0_ & 0x00000010) == 0x00000010)) {
-                subBuilder = delegateMethod_.toBuilder();
-              }
-              delegateMethod_ = input.readMessage(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.PARSER, extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(delegateMethod_);
-                delegateMethod_ = subBuilder.buildPartial();
-              }
-              bitField0_ |= 0x00000010;
-              break;
-            }
           }
         }
       } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -3725,48 +3684,11 @@ public final class DebugJvmProtoBuf {
       return setter_;
     }
 
-    public static final int DELEGATE_METHOD_FIELD_NUMBER = 5;
-    private org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature delegateMethod_;
-    /**
-     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-     *
-     * <pre>
-     * The delegate field of delegated properties may be optimized out; `getDelegate` should
-     * then call this method instead
-     * </pre>
-     */
-    public boolean hasDelegateMethod() {
-      return ((bitField0_ & 0x00000010) == 0x00000010);
-    }
-    /**
-     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-     *
-     * <pre>
-     * The delegate field of delegated properties may be optimized out; `getDelegate` should
-     * then call this method instead
-     * </pre>
-     */
-    public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature getDelegateMethod() {
-      return delegateMethod_;
-    }
-    /**
-     * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-     *
-     * <pre>
-     * The delegate field of delegated properties may be optimized out; `getDelegate` should
-     * then call this method instead
-     * </pre>
-     */
-    public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getDelegateMethodOrBuilder() {
-      return delegateMethod_;
-    }
-
     private void initFields() {
       field_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmFieldSignature.getDefaultInstance();
       syntheticMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
       getter_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
       setter_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
-      delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
@@ -3793,9 +3715,6 @@ public final class DebugJvmProtoBuf {
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         output.writeMessage(4, setter_);
       }
-      if (((bitField0_ & 0x00000010) == 0x00000010)) {
-        output.writeMessage(5, delegateMethod_);
-      }
       getUnknownFields().writeTo(output);
     }
 
@@ -3821,10 +3740,6 @@ public final class DebugJvmProtoBuf {
         size += org.jetbrains.kotlin.protobuf.CodedOutputStream
           .computeMessageSize(4, setter_);
       }
-      if (((bitField0_ & 0x00000010) == 0x00000010)) {
-        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
-          .computeMessageSize(5, delegateMethod_);
-      }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
       return size;
@@ -3938,7 +3853,6 @@ public final class DebugJvmProtoBuf {
           getSyntheticMethodFieldBuilder();
           getGetterFieldBuilder();
           getSetterFieldBuilder();
-          getDelegateMethodFieldBuilder();
         }
       }
       private static Builder create() {
@@ -3971,12 +3885,6 @@ public final class DebugJvmProtoBuf {
           setterBuilder_.clear();
         }
         bitField0_ = (bitField0_ & ~0x00000008);
-        if (delegateMethodBuilder_ == null) {
-          delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
-        } else {
-          delegateMethodBuilder_.clear();
-        }
-        bitField0_ = (bitField0_ & ~0x00000010);
         return this;
       }
 
@@ -4037,14 +3945,6 @@ public final class DebugJvmProtoBuf {
         } else {
           result.setter_ = setterBuilder_.build();
         }
-        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
-          to_bitField0_ |= 0x00000010;
-        }
-        if (delegateMethodBuilder_ == null) {
-          result.delegateMethod_ = delegateMethod_;
-        } else {
-          result.delegateMethod_ = delegateMethodBuilder_.build();
-        }
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
@@ -4073,9 +3973,6 @@ public final class DebugJvmProtoBuf {
         if (other.hasSetter()) {
           mergeSetter(other.getSetter());
         }
-        if (other.hasDelegateMethod()) {
-          mergeDelegateMethod(other.getDelegateMethod());
-        }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
@@ -4603,167 +4500,6 @@ public final class DebugJvmProtoBuf {
         return setterBuilder_;
       }
 
-      private org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
-      private org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
-          org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder> delegateMethodBuilder_;
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public boolean hasDelegateMethod() {
-        return ((bitField0_ & 0x00000010) == 0x00000010);
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature getDelegateMethod() {
-        if (delegateMethodBuilder_ == null) {
-          return delegateMethod_;
-        } else {
-          return delegateMethodBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public Builder setDelegateMethod(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature value) {
-        if (delegateMethodBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          delegateMethod_ = value;
-          onChanged();
-        } else {
-          delegateMethodBuilder_.setMessage(value);
-        }
-        bitField0_ |= 0x00000010;
-        return this;
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public Builder setDelegateMethod(
-          org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder builderForValue) {
-        if (delegateMethodBuilder_ == null) {
-          delegateMethod_ = builderForValue.build();
-          onChanged();
-        } else {
-          delegateMethodBuilder_.setMessage(builderForValue.build());
-        }
-        bitField0_ |= 0x00000010;
-        return this;
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public Builder mergeDelegateMethod(org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature value) {
-        if (delegateMethodBuilder_ == null) {
-          if (((bitField0_ & 0x00000010) == 0x00000010) &&
-              delegateMethod_ != org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance()) {
-            delegateMethod_ =
-              org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.newBuilder(delegateMethod_).mergeFrom(value).buildPartial();
-          } else {
-            delegateMethod_ = value;
-          }
-          onChanged();
-        } else {
-          delegateMethodBuilder_.mergeFrom(value);
-        }
-        bitField0_ |= 0x00000010;
-        return this;
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public Builder clearDelegateMethod() {
-        if (delegateMethodBuilder_ == null) {
-          delegateMethod_ = org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance();
-          onChanged();
-        } else {
-          delegateMethodBuilder_.clear();
-        }
-        bitField0_ = (bitField0_ & ~0x00000010);
-        return this;
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder getDelegateMethodBuilder() {
-        bitField0_ |= 0x00000010;
-        onChanged();
-        return getDelegateMethodFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      public org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder getDelegateMethodOrBuilder() {
-        if (delegateMethodBuilder_ != null) {
-          return delegateMethodBuilder_.getMessageOrBuilder();
-        } else {
-          return delegateMethod_;
-        }
-      }
-      /**
-       * <code>optional .org.jetbrains.kotlin.metadata.jvm.JvmMethodSignature delegate_method = 5;</code>
-       *
-       * <pre>
-       * The delegate field of delegated properties may be optimized out; `getDelegate` should
-       * then call this method instead
-       * </pre>
-       */
-      private org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
-          org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder> 
-          getDelegateMethodFieldBuilder() {
-        if (delegateMethodBuilder_ == null) {
-          delegateMethodBuilder_ = new org.jetbrains.kotlin.protobuf.SingleFieldBuilder<
-              org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignature.Builder, org.jetbrains.kotlin.metadata.jvm.DebugJvmProtoBuf.JvmMethodSignatureOrBuilder>(
-                  getDelegateMethod(),
-                  getParentForChildren(),
-                  isClean());
-          delegateMethod_ = null;
-        }
-        return delegateMethodBuilder_;
-      }
-
       // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.metadata.jvm.JvmPropertySignature)
     }
 
@@ -5004,7 +4740,7 @@ public final class DebugJvmProtoBuf {
       "\020DESC_TO_CLASS_ID\020\002\"<\n\022JvmMethodSignatur" +
       "e\022\022\n\004name\030\001 \001(\005B\004\230\265\030\001\022\022\n\004desc\030\002 \001(\005B\004\230\265\030" +
       "\001\";\n\021JvmFieldSignature\022\022\n\004name\030\001 \001(\005B\004\230\265" +
-      "\030\001\022\022\n\004desc\030\002 \001(\005B\004\230\265\030\001\"\212\003\n\024JvmPropertySi" +
+      "\030\001\022\022\n\004desc\030\002 \001(\005B\004\230\265\030\001\"\272\002\n\024JvmPropertySi" +
       "gnature\022C\n\005field\030\001 \001(\01324.org.jetbrains.k" +
       "otlin.metadata.jvm.JvmFieldSignature\022O\n\020",
       "synthetic_method\030\002 \001(\01325.org.jetbrains.k" +
@@ -5012,13 +4748,11 @@ public final class DebugJvmProtoBuf {
       "\006getter\030\003 \001(\01325.org.jetbrains.kotlin.met" +
       "adata.jvm.JvmMethodSignature\022E\n\006setter\030\004" +
       " \001(\01325.org.jetbrains.kotlin.metadata.jvm" +
-      ".JvmMethodSignature\022N\n\017delegate_method\030\005" +
-      " \001(\01325.org.jetbrains.kotlin.metadata.jvm" +
       ".JvmMethodSignature:\200\001\n\025constructor_sign" +
       "ature\022*.org.jetbrains.kotlin.metadata.Co" +
-      "nstructor\030d \001(\01325.org.jetbrains.kotlin.m",
+      "nstructor\030d \001(\01325.org.jetbrains.kotlin.m" +
       "etadata.jvm.JvmMethodSignature:x\n\020method" +
-      "_signature\022\'.org.jetbrains.kotlin.metada" +
+      "_signature\022\'.org.jetbrains.kotlin.metada",
       "ta.Function\030d \001(\01325.org.jetbrains.kotlin" +
       ".metadata.jvm.JvmMethodSignature:O\n\030lamb" +
       "da_class_origin_name\022\'.org.jetbrains.kot" +
@@ -5026,9 +4760,9 @@ public final class DebugJvmProtoBuf {
       "perty_signature\022\'.org.jetbrains.kotlin.m" +
       "etadata.Property\030d \001(\01327.org.jetbrains.k" +
       "otlin.metadata.jvm.JvmPropertySignature:" +
-      "9\n\005flags\022\'.org.jetbrains.kotlin.metadata",
+      "9\n\005flags\022\'.org.jetbrains.kotlin.metadata" +
       ".Property\030e \001(\005:\0010:g\n\017type_annotation\022#." +
-      "org.jetbrains.kotlin.metadata.Type\030d \003(\013" +
+      "org.jetbrains.kotlin.metadata.Type\030d \003(\013",
       "2).org.jetbrains.kotlin.metadata.Annotat" +
       "ion:3\n\006is_raw\022#.org.jetbrains.kotlin.met" +
       "adata.Type\030e \001(\010:z\n\031type_parameter_annot" +
@@ -5036,9 +4770,9 @@ public final class DebugJvmProtoBuf {
       "peParameter\030d \003(\0132).org.jetbrains.kotlin" +
       ".metadata.Annotation:E\n\021class_module_nam" +
       "e\022$.org.jetbrains.kotlin.metadata.Class\030" +
-      "e \001(\005B\004\230\265\030\001:k\n\024class_local_variable\022$.or",
+      "e \001(\005B\004\230\265\030\001:k\n\024class_local_variable\022$.or" +
       "g.jetbrains.kotlin.metadata.Class\030f \003(\0132" +
-      "\'.org.jetbrains.kotlin.metadata.Property" +
+      "\'.org.jetbrains.kotlin.metadata.Property",
       ":P\n\034anonymous_object_origin_name\022$.org.j" +
       "etbrains.kotlin.metadata.Class\030g \001(\005B\004\230\265" +
       "\030\001:@\n\017jvm_class_flags\022$.org.jetbrains.ko" +
@@ -5046,7 +4780,7 @@ public final class DebugJvmProtoBuf {
       "module_name\022&.org.jetbrains.kotlin.metad" +
       "ata.Package\030e \001(\005B\004\230\265\030\001:o\n\026package_local" +
       "_variable\022&.org.jetbrains.kotlin.metadat" +
-      "a.Package\030f \003(\0132\'.org.jetbrains.kotlin.m",
+      "a.Package\030f \003(\0132\'.org.jetbrains.kotlin.m" +
       "etadata.PropertyB\022B\020DebugJvmProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
@@ -5092,7 +4826,7 @@ public final class DebugJvmProtoBuf {
     internal_static_org_jetbrains_kotlin_metadata_jvm_JvmPropertySignature_fieldAccessorTable = new
       org.jetbrains.kotlin.protobuf.GeneratedMessage.FieldAccessorTable(
         internal_static_org_jetbrains_kotlin_metadata_jvm_JvmPropertySignature_descriptor,
-        new java.lang.String[] { "Field", "SyntheticMethod", "Getter", "Setter", "DelegateMethod", });
+        new java.lang.String[] { "Field", "SyntheticMethod", "Getter", "Setter", });
     constructorSignature.internalInit(descriptor.getExtensions().get(0));
     methodSignature.internalInit(descriptor.getExtensions().get(1));
     lambdaClassOriginName.internalInit(descriptor.getExtensions().get(2));

build.gradle.kts

@@ -153,6 +153,7 @@ if (!project.hasProperty("versions.kotlin-native")) {
 
 val effectSystemEnabled by extra(project.getBooleanProperty("kotlin.compiler.effectSystemEnabled") ?: false)
 val newInferenceEnabled by extra(project.getBooleanProperty("kotlin.compiler.newInferenceEnabled") ?: false)
+val useJvmIrBackend by extra(project.kotlinBuildProperties.useIR)
 val useJvmFir by extra(project.kotlinBuildProperties.useFir)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
@@ -474,6 +475,10 @@ allprojects {
         kotlinOptions {
             freeCompilerArgs = commonCompilerArgs + jvmCompilerArgs
 
+            if (useJvmIrBackend) {
+                useIR = true
+            }
+
             if (useJvmFir && this@allprojects.path !in projectsWithDisabledFirBootstrap) {
                 freeCompilerArgs += "-Xuse-fir"
                 freeCompilerArgs += "-Xabi-stability=stable"
@@ -734,6 +739,14 @@ 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")
     }
 
@@ -1128,13 +1141,3 @@ plugins.withType(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin:
         nodeVersion = "16.2.0"
     }
 }
-
-afterEvaluate {
-    val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
-    if (cacheRedirectorEnabled) {
-        rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin::class.java) {
-            rootProject.the<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension>().downloadBaseUrl =
-                "https://cache-redirector.jetbrains.com/github.com/yarnpkg/yarn/releases/download"
-        }
-    }
-}

buildSrc/build.gradle.kts

@@ -155,7 +155,7 @@ dependencies {
     implementation("net.sf.proguard:proguard-gradle:6.2.2")
     implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
-    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.0.1")
+    implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 
     implementation("org.gradle:test-retry-gradle-plugin:1.2.0")
     implementation("com.gradle.enterprise:test-distribution-gradle-plugin:2.1")

buildSrc/src/main/kotlin/BuildPropertiesExt.kt

@@ -22,4 +22,5 @@ val KotlinBuildProperties.ignoreTestFailures: Boolean get() = getBoolean("ignore
 val KotlinBuildProperties.disableWerror: Boolean get() = getBoolean("kotlin.build.disable.werror", false)
 
 val KotlinBuildProperties.isObsoleteJdkOverrideEnabled: Boolean
-    get() = getBoolean("kotlin.build.isObsoleteJdkOverrideEnabled", false)
+    get() = !isTeamcityBuild &&
+            getBoolean("kotlin.build.isObsoleteJdkOverrideEnabled", false)

buildSrc/src/main/kotlin/ComponentsXmlResourceTransformerPatched.kt

@@ -1,144 +0,0 @@
-/*
- * 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.
- */
-
-import com.github.jengelman.gradle.plugins.shadow.relocation.RelocateClassContext
-import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
-import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
-import org.gradle.api.file.FileTreeElement
-import shadow.org.apache.tools.zip.ZipEntry
-import shadow.org.apache.tools.zip.ZipOutputStream
-import shadow.org.codehaus.plexus.util.IOUtil
-import shadow.org.codehaus.plexus.util.ReaderFactory
-import shadow.org.codehaus.plexus.util.WriterFactory
-import shadow.org.codehaus.plexus.util.xml.Xpp3Dom
-import shadow.org.codehaus.plexus.util.xml.Xpp3DomBuilder
-import shadow.org.codehaus.plexus.util.xml.Xpp3DomWriter
-import java.io.*
-import java.lang.Exception
-import java.util.LinkedHashMap
-
-/**
- * A resource processor that aggregates plexus `components.xml` files.
- *
- * Fixed version of [com.github.jengelman.gradle.plugins.shadow.transformers.ComponentsXmlResourceTransformer],
- * may be dropped after [the fix in ShadowJAR](https://github.com/johnrengelman/shadow/pull/678/files) will be accepted
- */
-class ComponentsXmlResourceTransformerPatched : Transformer {
-    private val components: MutableMap<String, Xpp3Dom> =
-        LinkedHashMap<String, Xpp3Dom>()
-
-    override fun canTransformResource(element: FileTreeElement): Boolean {
-        val path = element.relativePath.pathString
-        return COMPONENTS_XML_PATH == path
-    }
-
-    override fun transform(context: TransformerContext) {
-        val newDom: Xpp3Dom = try {
-            val bis: BufferedInputStream = object : BufferedInputStream(context.getIs()) {
-                override fun close() {
-                    // leave ZIP open
-                }
-            }
-            val reader: Reader = ReaderFactory.newXmlReader(bis)
-            Xpp3DomBuilder.build(reader)
-        } catch (e: Exception) {
-            throw (IOException("Error parsing components.xml in " + context.getIs()).initCause(e) as IOException)
-        }
-
-        // Only try to merge in components if there are some elements in the component-set
-        if (newDom.getChild("components") == null) {
-            return
-        }
-        val children: Array<Xpp3Dom>? = newDom.getChild("components")?.getChildren("component")
-        children?.forEach { component ->
-            var role: String? = getValue(component, "role")
-            role = getRelocatedClass(role, context)
-            setValue(component, "role", role)
-            val roleHint = getValue(component, "role-hint")
-            var impl: String? = getValue(component, "implementation")
-            impl = getRelocatedClass(impl, context)
-            setValue(component, "implementation", impl)
-            val key = "$role:$roleHint"
-            if (components.containsKey(key)) {
-                // configuration carry over
-                val dom: Xpp3Dom? = components[key]
-                if (dom?.getChild("configuration") != null) {
-                    component.addChild(dom.getChild("configuration"))
-                }
-            }
-            val requirements: Xpp3Dom? = component.getChild("requirements")
-            if (requirements != null && requirements.childCount > 0) {
-                for (r in requirements.childCount - 1 downTo 0) {
-                    val requirement: Xpp3Dom = requirements.getChild(r)
-                    var requiredRole: String? = getValue(requirement, "role")
-                    requiredRole = getRelocatedClass(requiredRole, context)
-                    setValue(requirement, "role", requiredRole)
-                }
-            }
-            components[key] = component
-        }
-    }
-
-    override fun modifyOutputStream(os: ZipOutputStream, preserveFileTimestamps: Boolean) {
-        val data = transformedResource
-        val entry = ZipEntry(COMPONENTS_XML_PATH)
-        entry.time = TransformerContext.getEntryTimestamp(preserveFileTimestamps, entry.time)
-        os.putNextEntry(entry)
-        IOUtil.copy(data, os)
-        components.clear()
-    }
-
-    override fun hasTransformedResource(): Boolean {
-        return components.isNotEmpty()
-    }
-
-    private val transformedResource: ByteArray
-        get() {
-            val baos = ByteArrayOutputStream(1024 * 4)
-            val writer: Writer = WriterFactory.newXmlWriter(baos)
-            try {
-                val dom = Xpp3Dom("component-set")
-                val componentDom = Xpp3Dom("components")
-                dom.addChild(componentDom)
-                for (component in components.values) {
-                    componentDom.addChild(component)
-                }
-                Xpp3DomWriter.write(writer, dom)
-            } finally {
-                IOUtil.close(writer)
-            }
-            return baos.toByteArray()
-        }
-
-    companion object {
-        private const val COMPONENTS_XML_PATH = "META-INF/plexus/components.xml"
-        private fun getRelocatedClass(className: String?, context: TransformerContext): String? {
-            val relocators = context.relocators
-            val stats = context.stats
-            if (className != null && className.isNotEmpty() && relocators != null) {
-                for (relocator in relocators) {
-                    if (relocator.canRelocateClass(className)) {
-                        val relocateClassContext = RelocateClassContext(className, stats)
-                        return relocator.relocateClass(relocateClassContext)
-                    }
-                }
-            }
-            return className
-        }
-
-        private fun getValue(dom: Xpp3Dom, element: String): String {
-            val child: Xpp3Dom? = dom.getChild(element)
-            return if (child?.value != null) child.value else ""
-        }
-
-        private fun setValue(dom: Xpp3Dom, element: String, value: String?) {
-            val child: Xpp3Dom? = dom.getChild(element)
-            if (value == null || value.isEmpty()) {
-                return
-            }
-            child?.value = value
-        }
-    }
-}

buildSrc/src/main/kotlin/JvmToolchain.kt

@@ -18,8 +18,8 @@ enum class JdkMajorVersion(
     JDK_1_6(6, targetName = "1.6", overrideMajorVersion = 8),
     JDK_1_7(7, targetName = "1.7", overrideMajorVersion = 8),
     JDK_1_8(8, targetName = "1.8"),
-    JDK_9(9, overrideMajorVersion = 11),
-    JDK_10(10, mandatory = false, overrideMajorVersion = 11),
+    JDK_9(9),
+    JDK_10(10, mandatory = false),
     JDK_11(11, mandatory = false),
     JDK_15(15, mandatory = false),
     JDK_16(16, mandatory = false);
@@ -43,9 +43,6 @@ fun Project.shouldOverrideObsoleteJdk(
 fun Project.configureJvmToolchain(
     jdkVersion: JdkMajorVersion
 ) {
-    // Ensure java only modules also set default toolchain
-    configureJavaOnlyToolchain(jdkVersion)
-
     plugins.withId("org.jetbrains.kotlin.jvm") {
         val kotlinExtension = extensions.getByType<KotlinTopLevelExtension>()
 
@@ -154,7 +151,7 @@ fun Project.updateJvmTarget(
     }
 }
 
-private fun Project.getToolchainCompilerFor(
+fun Project.getToolchainCompilerFor(
     jdkVersion: JdkMajorVersion
 ): Provider<JavaCompiler> {
     val service = project.extensions.getByType<JavaToolchainService>()
@@ -167,17 +164,7 @@ fun Project.getToolchainLauncherFor(
     jdkVersion: JdkMajorVersion
 ): Provider<JavaLauncher> {
     val service = project.extensions.getByType<JavaToolchainService>()
-    val jdkVersionWithOverride = project.getJdkVersionWithOverride(jdkVersion)
     return service.launcherFor {
-        this.languageVersion.set(JavaLanguageVersion.of(jdkVersionWithOverride.majorVersion))
+        this.languageVersion.set(JavaLanguageVersion.of(jdkVersion.majorVersion))
     }
 }
-
-
-fun Project.getJdkVersionWithOverride(jdkVersion: JdkMajorVersion): JdkMajorVersion {
-    return if (project.shouldOverrideObsoleteJdk(jdkVersion)) {
-        JdkMajorVersion.fromMajorVersion(jdkVersion.overrideMajorVersion!!)
-    } else {
-        jdkVersion
-    }
-}

buildSrc/src/main/kotlin/LibrariesCommon.kt

@@ -26,9 +26,9 @@ fun Project.configureJava9Compilation(
     tasks.named("compileJava9Java", JavaCompile::class.java) {
         dependsOn(moduleOutputs)
 
+        javaCompiler.set(getToolchainCompilerFor(JdkMajorVersion.JDK_9))
         targetCompatibility = JavaVersion.VERSION_1_9.toString()
         sourceCompatibility = JavaVersion.VERSION_1_9.toString()
-        configureTaskToolchain(JdkMajorVersion.JDK_9)
 
         // module-info.java should be in java9 source set by convention
         val java9SourceSet = sourceSets["java9"].java

buildSrc/src/main/kotlin/gradle-plugin-common-configuration.gradle.kts

@@ -42,8 +42,7 @@ tasks.withType<KotlinCompile> {
     kotlinOptions.freeCompilerArgs += listOf(
         "-Xskip-prerelease-check",
         "-Xskip-runtime-version-check",
-        "-Xsuppress-version-warnings",
-        "-Xuse-ir" // Needed as long as languageVersion is less than 1.5.
+        "-Xsuppress-version-warnings"
     )
 }
 

buildSrc/src/main/kotlin/ideaExtKotlinDsl.kt

@@ -24,16 +24,16 @@ fun ProjectSettings.compiler(block: IdeaCompilerConfiguration.() -> Unit) =
 fun ProjectSettings.delegateActions(block: ActionDelegationConfig.() -> Unit) =
     (this@delegateActions as ExtensionAware).extensions.configure(block)
 
-fun ProjectSettings.runConfigurations(block: RunConfigurationContainer.() -> Unit) =
+fun ProjectSettings.runConfigurations(block: DefaultRunConfigurationContainer.() -> Unit) =
     (this@runConfigurations as ExtensionAware).extensions.configure("runConfigurations", block)
 
-inline fun <reified T: RunConfiguration> RunConfigurationContainer.defaults(noinline block: T.() -> Unit) =
+inline fun <reified T: RunConfiguration> DefaultRunConfigurationContainer.defaults(noinline block: T.() -> Unit) =
     defaults(T::class.java, block)
 
-fun RunConfigurationContainer.junit(name: String, block: JUnit.() -> Unit) =
+fun DefaultRunConfigurationContainer.junit(name: String, block: JUnit.() -> Unit) =
     create(name, JUnit::class.java, block)
 
-fun RunConfigurationContainer.application(name: String, block: Application.() -> Unit) =
+fun DefaultRunConfigurationContainer.application(name: String, block: Application.() -> Unit) =
     create(name, Application::class.java, block)
 
 fun ProjectSettings.ideArtifacts(block: NamedDomainObjectContainer<org.jetbrains.gradle.ext.TopLevelArtifact>.() -> Unit) =

buildSrc/src/main/kotlin/localDependencies.kt

@@ -17,11 +17,16 @@
 // 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 =
@@ -141,4 +146,70 @@ fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFi
         rootProject = project.rootProject
     )
 
-fun Project.intellijRootDir() = IntellijRootUtils.getIntellijRootDir(project)
+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()
+    }
+}

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument
-import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
 import org.jetbrains.kotlin.types.upperIfFlexible
 import org.jetbrains.org.objectweb.asm.Type
@@ -52,7 +51,7 @@ class CallBasedArgumentGenerator(
         callGenerator.putValueIfNeeded(
             getJvmKotlinType(i),
             StackValue.createDefaultValue(valueParameterTypes[i]),
-            if (InlineUtil.isInlineParameter(valueParameters[i])) ValueKind.DEFAULT_INLINE_PARAMETER else ValueKind.DEFAULT_PARAMETER,
+            ValueKind.DEFAULT_PARAMETER,
             i
         )
     }

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

@@ -15,9 +15,9 @@ enum class ValueKind {
     GENERAL,
     GENERAL_VARARG,
     DEFAULT_PARAMETER,
-    DEFAULT_INLINE_PARAMETER,
     DEFAULT_MASK,
     METHOD_HANDLE_IN_DEFAULT,
+    CAPTURED,
     NON_INLINEABLE_ARGUMENT_FOR_INLINE_PARAMETER_CALLED_IN_SUSPEND,
     NON_INLINEABLE_ARGUMENT_FOR_INLINE_SUSPEND_PARAMETER
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java

@@ -27,16 +27,24 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.config.AnalysisFlags;
 import org.jetbrains.kotlin.config.JvmAnalysisFlags;
+import org.jetbrains.kotlin.descriptors.ClassDescriptor;
+import org.jetbrains.kotlin.descriptors.DescriptorUtilKt;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.load.kotlin.ModuleMappingUtilKt;
 import org.jetbrains.kotlin.metadata.ProtoBuf;
 import org.jetbrains.kotlin.metadata.jvm.JvmModuleProtoBuf;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMapping;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMappingKt;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.PackageParts;
+import org.jetbrains.kotlin.metadata.serialization.StringTable;
+import org.jetbrains.kotlin.name.ClassId;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration;
+import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.serialization.StringTableImpl;
 import org.jetbrains.org.objectweb.asm.Type;
@@ -44,6 +52,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.getMappingFileName;
 
@@ -125,6 +134,11 @@ public class ClassFileFactory implements OutputFileCollection {
         StringTableImpl stringTable = new StringTableImpl();
         ClassFileUtilsKt.addDataFromCompiledModule(builder, packagePartRegistry, stringTable, state);
 
+        List<String> experimental = state.getLanguageVersionSettings().getFlag(AnalysisFlags.getExperimental());
+        if (!experimental.isEmpty()) {
+            writeExperimentalMarkers(state.getModule(), builder, experimental, stringTable);
+        }
+
         Pair<ProtoBuf.StringTable, ProtoBuf.QualifiedNameTable> tables = stringTable.buildProto();
         builder.setStringTable(tables.getFirst());
         builder.setQualifiedNameTable(tables.getSecond());
@@ -148,6 +162,26 @@ public class ClassFileFactory implements OutputFileCollection {
         });
     }
 
+    private static void writeExperimentalMarkers(
+            @NotNull ModuleDescriptor module,
+            @NotNull JvmModuleProtoBuf.Module.Builder builder,
+            @NotNull List<String> experimental,
+            @NotNull StringTable stringTable
+    ) {
+        for (String fqName : experimental) {
+            ClassDescriptor descriptor =
+                    DescriptorUtilKt.resolveClassByFqName(module, new FqName(fqName), NoLookupLocation.FOR_ALREADY_TRACKED);
+            if (descriptor != null) {
+                ProtoBuf.Annotation.Builder annotation = ProtoBuf.Annotation.newBuilder();
+                ClassId classId = DescriptorUtilsKt.getClassId(descriptor);
+                if (classId != null) {
+                    annotation.setId(stringTable.getQualifiedClassNameIndex(classId.asString(), false));
+                    builder.addAnnotation(annotation);
+                }
+            }
+        }
+    }
+
     @NotNull
     @Override
     public List<OutputFile> asList() {

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -2971,10 +2971,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         if (isDefaultCompilation) {
             return new InlineCodegenForDefaultBody(functionDescriptor, this, state, signature, sourceCompiler);
         } else {
-            return new PsiInlineCodegen(
-                    this, state, functionDescriptor, signature, typeParameterMappings, sourceCompiler,
-                    typeMapper.mapImplementationOwner(functionDescriptor), typeMapper.mapOwner(descriptor), callElement
-            );
+            return new PsiInlineCodegen(this, state, functionDescriptor, signature, typeParameterMappings, sourceCompiler,
+                                        typeMapper.mapImplementationOwner(functionDescriptor), typeMapper.mapOwner(descriptor));
         }
     }
 

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

@@ -136,6 +136,8 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
+        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
+
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
@@ -192,8 +194,6 @@ class CoroutineTransformerMethodVisitor(
         dropUnboxInlineClassMarkers(methodNode, suspensionPoints)
         methodNode.removeEmptyCatchBlocks()
 
-        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
-
         if (languageVersionSettings.isReleaseCoroutines()) {
             writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
         }
@@ -791,30 +791,19 @@ class CoroutineTransformerMethodVisitor(
         // Mutate method node
 
         fun generateSpillAndUnspill(suspension: SuspensionPoint, slot: Int, spillableVariable: SpillableVariable?) {
-            fun splitLvtRecord(local: LocalVariableNode?, localRestart: LabelNode) {
-                // Split the local variable range for the local so that it is visible until the next state label, but is
-                // not visible until it has been unspilled from the continuation on the reentry path.
-                if (local != null) {
-                    val previousEnd = local.end
-                    local.end = suspension.stateLabel
-                    // Add the local back, but end it at the next state label.
-                    methodNode.localVariables.add(local)
-                    // Add a new entry that starts after the local variable is restored from the continuation.
-                    methodNode.localVariables.add(
-                        LocalVariableNode(
-                            local.name,
-                            local.desc,
-                            local.signature,
-                            localRestart,
-                            previousEnd,
-                            local.index
-                        )
-                    )
+            if (spillableVariable == null) {
+                with(instructions) {
+                    insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                        aconst(null)
+                        store(slot, AsmTypes.OBJECT_TYPE)
+                    })
                 }
+                return
             }
 
             // Find and remove the local variable node, if any, in the local variable table corresponding to the slot that is spilled.
             var local: LocalVariableNode? = null
+            val localRestart = LabelNode().linkWithLabel()
             val iterator = methodNode.localVariables.listIterator()
             while (iterator.hasNext()) {
                 val node = iterator.next()
@@ -828,19 +817,6 @@ class CoroutineTransformerMethodVisitor(
                 }
             }
 
-            if (spillableVariable == null) {
-                with(instructions) {
-                    insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                        aconst(null)
-                        store(slot, AsmTypes.OBJECT_TYPE)
-                    })
-                }
-                val newStart = suspension.tryCatchBlocksContinuationLabel.findNextOrNull { it is LabelNode } as? LabelNode ?: return
-                splitLvtRecord(local, newStart)
-                return
-            }
-
-            val localRestart = LabelNode().linkWithLabel()
             with(instructions) {
                 // store variable before suspension call
                 insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
@@ -870,7 +846,25 @@ class CoroutineTransformerMethodVisitor(
                 })
             }
 
-            splitLvtRecord(local, localRestart)
+            // Split the local variable range for the local so that it is visible until the next state label, but is
+            // not visible until it has been unspilled from the continuation on the reentry path.
+            if (local != null) {
+                val previousEnd = local.end
+                local.end = suspension.stateLabel
+                // Add the local back, but end it at the next state label.
+                methodNode.localVariables.add(local)
+                // Add a new entry that starts after the local variable is restored from the continuation.
+                methodNode.localVariables.add(
+                    LocalVariableNode(
+                        local.name,
+                        local.desc,
+                        local.signature,
+                        localRestart,
+                        previousEnd,
+                        local.index
+                    )
+                )
+            }
         }
 
         fun cleanUpField(suspension: SuspensionPoint, fieldIndex: Int) {
@@ -1260,9 +1254,6 @@ internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, contin
     }
 }
 
-private fun MethodNode.nodeTextWithLiveness(liveness: List<VariableLivenessFrame>): String =
-    liveness.zip(this.instructions.asSequence().toList()).joinToString("\n") { (a, b) -> "$a|${b.insnText}" }
-
 /* We do not want to spill dead variables, thus, we shrink its LVT record to region, where the variable is alive,
  * so, the variable will not be visible in debugger. User can still prolong life span of the variable by using it.
  *
@@ -1297,6 +1288,9 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     fun min(a: LabelNode, b: LabelNode): LabelNode =
         if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) a else b
 
+    fun max(a: LabelNode, b: LabelNode): LabelNode =
+        if (method.instructions.indexOf(a) < method.instructions.indexOf(b)) b else a
+
     val oldLvt = arrayListOf<LocalVariableNode>()
     for (record in method.localVariables) {
         oldLvt += record
@@ -1304,6 +1298,7 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
     method.localVariables.clear()
     // Skip `this` for suspend lambda
     val start = if (isForNamedFunction) 0 else 1
+    val oldLvtNodeToLatestNewLvtNode = mutableMapOf<LocalVariableNode, LocalVariableNode>()
     for (variableIndex in start until method.maxLocals) {
         if (oldLvt.none { it.index == variableIndex }) continue
         var startLabel: LabelNode? = null
@@ -1315,7 +1310,7 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
             if (isAlive(insnIndex, variableIndex) && !isAlive(insnIndex + 1, variableIndex)) {
                 // No variable in LVT -> do not add one
                 val lvtRecord = oldLvt.findRecord(insnIndex, variableIndex) ?: continue
-                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME || lvtRecord.name == SUSPEND_CALL_RESULT_NAME) continue
+                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME) continue
                 // End the local when it is no longer live. Since it is not live, we will not spill and unspill it across
                 // suspension points. It is tempting to keep it alive until the next suspension point to leave it visible in
                 // the debugger for as long as possible. However, in the case of loops, the resumption after suspension can
@@ -1342,32 +1337,14 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
                 // startLabel can be null in case of parameters
                 @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
                 val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                method.localVariables.add(node)
+                if (lvtRecord !in oldLvtNodeToLatestNewLvtNode) {
+                    method.localVariables.add(node)
+                }
+                oldLvtNodeToLatestNewLvtNode[lvtRecord] = node
             }
         }
     }
 
-    // Merge consequent LVT records, otherwise, atomicfu goes crazy (KT-47749)
-    val toRemove = arrayListOf<LocalVariableNode>()
-    val sortedLVT = method.localVariables.sortedBy { method.instructions.indexOf(it.start) }
-    for (i in sortedLVT.indices) {
-        var endIndex = method.instructions.indexOf(sortedLVT[i].end)
-        for (j in (i + 1) until sortedLVT.size) {
-            val startIndex = method.instructions.indexOf(sortedLVT[j].start)
-            if (endIndex < startIndex) break
-            if (endIndex != startIndex ||
-                sortedLVT[i].index != sortedLVT[j].index ||
-                sortedLVT[i].name != sortedLVT[j].name ||
-                sortedLVT[i].desc != sortedLVT[j].desc
-            ) continue
-            sortedLVT[i].end = sortedLVT[j].end
-            endIndex = method.instructions.indexOf(sortedLVT[j].end)
-            toRemove += sortedLVT[j]
-        }
-    }
-
-    method.localVariables.removeAll(toRemove)
-
     for (variable in oldLvt) {
         // $continuation and $result are dead, but they are used by debugger, as well as fake inliner variables
         // For example, $continuation is used to create async stack trace

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
-import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.common.removeAll
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
@@ -85,7 +85,7 @@ private class UnitSourceInterpreter(private val localVariables: Set<Int>) : Basi
     }
 
     fun run(internalClassName: String, methodNode: MethodNode): Array<Frame<BasicValue>?> {
-        val frames = FastMethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
+        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
         // The ASM analyzer does not visit POP instructions, so we do so here.
         for ((insn, frame) in methodNode.instructions.asSequence().zip(frames.asSequence())) {
             if (frame != null && insn.opcode == Opcodes.POP) {

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.codegen.coroutines
 
 import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
+import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -130,11 +130,11 @@ internal fun performSpilledVariableFieldTypesAnalysis(
     thisName: String
 ): Array<out Frame<BasicValue>?> {
     val interpreter = IntLikeCoerceInterpreter()
-    FastMethodAnalyzer(thisName, methodNode, interpreter).analyze()
+    MethodAnalyzer(thisName, methodNode, interpreter).analyze()
     for ((insn, type) in interpreter.needsToBeCoerced) {
         methodNode.instructions.insert(insn, withInstructionAdapter { coerceInt(type, this) })
     }
-    return FastMethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
+    return MethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
 }
 
 private fun coerceInt(to: Type, v: InstructionAdapter) {

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

@@ -159,8 +159,8 @@ internal class MethodNodeExaminer(
      * @return indices of safely reachable returns for each instruction in the method node
      */
     private fun findSafelyReachableReturns(): Array<Set<Int>?> {
-        val insns = methodNode.instructions.toArray()
-        val reachableReturnsIndices = Array(insns.size) init@{ index ->
+        val insns = methodNode.instructions
+        val reachableReturnsIndices = Array(insns.size()) init@{ index ->
             val insn = insns[index]
 
             if (insn.opcode == Opcodes.ARETURN && !insn.isAreturnAfterSafeUnitInstance()) {
@@ -182,7 +182,7 @@ internal class MethodNodeExaminer(
         var changed: Boolean
         do {
             changed = false
-            for (index in insns.indices.reversed()) {
+            for (index in 0 until insns.size()) {
                 if (insns[index].opcode == Opcodes.ARETURN) continue
 
                 @Suppress("RemoveExplicitTypeArguments")

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

@@ -295,6 +295,7 @@ class AnonymousObjectTransformer(
         capturedBuilder: ParametersBuilder,
         isConstructor: Boolean
     ): InlineResult {
+        val typeParametersToReify = inliningContext.root.inlineMethodReifier.reifyInstructions(sourceNode)
         val parameters =
             if (isConstructor) capturedBuilder.buildParameters() else getMethodParametersWithCaptured(capturedBuilder, sourceNode)
 
@@ -303,10 +304,7 @@ class AnonymousObjectTransformer(
             transformationInfo.capturedLambdasToInline, parentRemapper, isConstructor
         )
 
-        val reifiedTypeParametersUsages = if (inliningContext.shouldReifyTypeParametersInObjects)
-            inliningContext.root.inlineMethodReifier.reifyInstructions(sourceNode)
-        else null
-        val result = MethodInliner(
+        val inliner = MethodInliner(
             sourceNode,
             parameters,
             inliningContext.subInline(transformationInfo.nameGenerator),
@@ -321,8 +319,10 @@ class AnonymousObjectTransformer(
                 inliningContext.callSiteInfo.file,
                 inliningContext.callSiteInfo.lineNumber
             ), null
-        ).doInline(deferringVisitor, LocalVarRemapper(parameters, 0), false, mapOf())
-        reifiedTypeParametersUsages?.let(result.reifiedTypeParametersUsages::mergeAll)
+        )
+
+        val result = inliner.doInline(deferringVisitor, LocalVarRemapper(parameters, 0), false, mapOf())
+        result.reifiedTypeParametersUsages.mergeAll(typeParametersToReify)
         deferringVisitor.visitMaxs(-1, -1)
         return result
     }
@@ -421,13 +421,11 @@ class AnonymousObjectTransformer(
     }
 
     private fun getMethodParametersWithCaptured(capturedBuilder: ParametersBuilder, sourceNode: MethodNode): Parameters {
-        val builder = ParametersBuilder.newBuilder()
-        if (sourceNode.access and Opcodes.ACC_STATIC == 0) {
-            builder.addThis(oldObjectType, skipped = false)
-        }
-        for (type in Type.getArgumentTypes(sourceNode.desc)) {
-            builder.addNextParameter(type, false)
-        }
+        val builder = ParametersBuilder.initializeBuilderFrom(
+            oldObjectType,
+            sourceNode.desc,
+            isStatic = sourceNode.access and Opcodes.ACC_STATIC != 0
+        )
         for (param in capturedBuilder.listCaptured()) {
             builder.addCapturedParamCopy(param)
         }

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

@@ -33,9 +33,9 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
 
     protected val invocationParamBuilder = ParametersBuilder.newBuilder()
     protected val expressionMap = linkedMapOf<Int, FunctionalArgument>()
-    private val maskValues = ArrayList<Int>()
-    private var maskStartIndex = -1
-    private var methodHandleInDefaultMethodIndex = -1
+    protected val maskValues = ArrayList<Int>()
+    protected var maskStartIndex = -1
+    protected var methodHandleInDefaultMethodIndex = -1
 
     protected fun generateStub(text: String, codegen: BaseExpressionCodegen) {
         leaveTemps()
@@ -71,25 +71,14 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
     private fun inlineCall(nodeAndSmap: SMAPAndMethodNode, isInlineOnly: Boolean): InlineResult {
         val node = nodeAndSmap.node
         if (maskStartIndex != -1) {
-            val parameters = invocationParamBuilder.buildParameters()
-            val infos = expandMaskConditionsAndUpdateVariableNodes(
-                node, maskStartIndex, maskValues, methodHandleInDefaultMethodIndex,
-                parameters.parameters.filter { it.functionalArgument === DefaultValueOfInlineParameter }
-                    .mapTo(mutableSetOf()) { parameters.getDeclarationSlot(it) }
-            )
-            for (info in infos) {
-                val lambda = DefaultLambda(info, sourceCompiler)
-                parameters.getParameterByDeclarationSlot(info.offset).functionalArgument = lambda
-                val prev = expressionMap.put(info.offset, lambda)
-                assert(prev == null) { "Lambda with offset ${info.offset} already exists: $prev" }
-                if (info.needReification) {
+            for (lambda in extractDefaultLambdas(node)) {
+                invocationParamBuilder.buildParameters().getParameterByDeclarationSlot(lambda.offset).functionalArgument = lambda
+                val prev = expressionMap.put(lambda.offset, lambda)
+                assert(prev == null) { "Lambda with offset ${lambda.offset} already exists: $prev" }
+                if (lambda.needReification) {
                     lambda.reifiedTypeParametersUsages.mergeAll(reifiedTypeInliner.reifyInstructions(lambda.node.node))
                 }
-                for (captured in lambda.capturedVars) {
-                    val param = invocationParamBuilder.addCapturedParam(captured, captured.fieldName, false)
-                    param.remapValue = StackValue.local(codegen.frameMap.enterTemp(param.type), param.type)
-                    param.isSynthetic = true
-                }
+                rememberCapturedForDefaultLambda(lambda)
             }
         }
 
@@ -147,6 +136,16 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         return result
     }
 
+    abstract fun extractDefaultLambdas(node: MethodNode): List<DefaultLambda>
+
+    protected inline fun <T> extractDefaultLambdas(
+        node: MethodNode, parameters: Map<Int, T>, block: ExtractedDefaultLambda.(T) -> DefaultLambda
+    ): List<DefaultLambda> = expandMaskConditionsAndUpdateVariableNodes(
+        node, maskStartIndex, maskValues, methodHandleInDefaultMethodIndex, parameters.keys
+    ).map {
+        it.block(parameters[it.offset]!!)
+    }
+
     private fun generateAndInsertFinallyBlocks(
         intoNode: MethodNode,
         insertPoints: List<MethodInliner.PointForExternalFinallyBlocks>,
@@ -239,12 +238,10 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                 NonInlineableArgumentForInlineableParameterCalledInSuspend
             ValueKind.NON_INLINEABLE_ARGUMENT_FOR_INLINE_SUSPEND_PARAMETER ->
                 NonInlineableArgumentForInlineableSuspendParameter
-            ValueKind.DEFAULT_INLINE_PARAMETER ->
-                DefaultValueOfInlineParameter
             else -> null
         }
         when {
-            kind === ValueKind.DEFAULT_PARAMETER || kind === ValueKind.DEFAULT_INLINE_PARAMETER ->
+            kind === ValueKind.DEFAULT_PARAMETER ->
                 codegen.frameMap.enterTemp(info.type) // the inline function will put the value into this slot
             stackValue.isLocalWithNoBoxing(jvmKotlinType) ->
                 info.remapValue = stackValue
@@ -263,6 +260,14 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         }
     }
 
+    private fun rememberCapturedForDefaultLambda(defaultLambda: DefaultLambda) {
+        for (captured in defaultLambda.capturedVars) {
+            val info = invocationParamBuilder.addCapturedParam(captured, captured.fieldName, false)
+            info.remapValue = StackValue.local(codegen.frameMap.enterTemp(info.type), info.type)
+            info.isSynthetic = true
+        }
+    }
+
     private fun processDefaultMaskOrMethodHandler(value: StackValue, kind: ValueKind) {
         assert(value is StackValue.Constant) { "Additional default method argument should be constant, but $value" }
         val constantValue = (value as StackValue.Constant).value

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

@@ -44,16 +44,8 @@ open class InliningContext(
     val lambdaInfo: LambdaInfo?,
     val classRegeneration: Boolean
 ) {
-    val isInliningLambda
-        get() = lambdaInfo != null
 
-    // Consider this arrangement:
-    //     inline fun <reified T> f(x: () -> Unit = { /* uses `T` in a local class */ }) = x()
-    //     inline fun <reified V> g() = f<...> { /* uses `V` in a local class */ }
-    // When inlining `f` into `g`, we need to reify the contents of the default for `x` (if it was used), but not the
-    // contents of the lambda passed as the argument in `g` as all reified type parameters used by the latter are not from `f`.
-    val shouldReifyTypeParametersInObjects: Boolean
-        get() = lambdaInfo == null || lambdaInfo is DefaultLambda
+    val isInliningLambda = lambdaInfo != null
 
     var generateAssertField = false
 
@@ -62,8 +54,7 @@ open class InliningContext(
 
     var isContinuation: Boolean = false
 
-    val isRoot: Boolean
-        get() = parent == null
+    val isRoot: Boolean = parent == null
 
     val root: RootInliningContext
         get() = if (isRoot) this as RootInliningContext else parent!!.root

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.codegen.coroutines.isCoroutineSuperClass
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.org.objectweb.asm.ClassReader
@@ -18,6 +17,10 @@ import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
 interface FunctionalArgument
 
 abstract class LambdaInfo : FunctionalArgument {
+    abstract val isBoundCallableReference: Boolean
+
+    abstract val isSuspend: Boolean
+
     abstract val lambdaClassType: Type
 
     abstract val invokeMethod: Method
@@ -35,17 +38,11 @@ abstract class LambdaInfo : FunctionalArgument {
 
     val reifiedTypeParametersUsages = ReifiedTypeParametersUsages()
 
-    open val hasDispatchReceiver
-        get() = true
+    open val hasDispatchReceiver = true
 
     fun addAllParameters(remapper: FieldRemapper): Parameters {
-        val builder = ParametersBuilder.newBuilder()
-        if (hasDispatchReceiver) {
-            builder.addThis(lambdaClassType, skipped = true).functionalArgument = this
-        }
-        for (type in Type.getArgumentTypes(invokeMethod.descriptor)) {
-            builder.addNextParameter(type, skipped = false)
-        }
+        val builder = ParametersBuilder.initializeBuilderFrom(OBJECT_TYPE, invokeMethod.descriptor, this)
+
         for (info in capturedVars) {
             val field = remapper.findField(FieldInsnNode(0, info.containingLambdaName, info.fieldName, ""))
                 ?: error("Captured field not found: " + info.containingLambdaName + "." + info.fieldName)
@@ -67,7 +64,6 @@ abstract class LambdaInfo : FunctionalArgument {
 
 object NonInlineableArgumentForInlineableParameterCalledInSuspend : FunctionalArgument
 object NonInlineableArgumentForInlineableSuspendParameter : FunctionalArgument
-object DefaultValueOfInlineParameter : FunctionalArgument
 
 abstract class ExpressionLambda : LambdaInfo() {
     fun generateLambdaBody(sourceCompiler: SourceCompilerForInline) {
@@ -76,64 +72,67 @@ abstract class ExpressionLambda : LambdaInfo() {
     }
 }
 
-class DefaultLambda(info: ExtractedDefaultLambda, sourceCompiler: SourceCompilerForInline) : LambdaInfo() {
-    val isBoundCallableReference: Boolean
+abstract class DefaultLambda(
+    final override val lambdaClassType: Type,
+    capturedArgs: Array<Type>,
+    val offset: Int,
+    val needReification: Boolean,
+    sourceCompiler: SourceCompilerForInline
+) : LambdaInfo() {
+    final override val isSuspend
+        get() = false // TODO: it should probably be true sometimes, but it never was
+    final override val isBoundCallableReference: Boolean
+    final override val capturedVars: List<CapturedParamDesc>
 
-    override val lambdaClassType: Type = info.type
-    override val capturedVars: List<CapturedParamDesc>
-
-    override val invokeMethod: Method
+    final override val invokeMethod: Method
         get() = Method(node.node.name, node.node.desc)
 
-    private val nullableAnyType = sourceCompiler.state.module.builtIns.nullableAnyType
-
-    override val invokeMethodParameters: List<KotlinType>
-        get() = List(invokeMethod.argumentTypes.size) { nullableAnyType }
-
-    override val invokeMethodReturnType: KotlinType
-        get() = nullableAnyType
-
     val originalBoundReceiverType: Type?
 
+    protected val isPropertyReference: Boolean
+    protected val isFunctionReference: Boolean
+
     init {
-        val classBytes =
-            sourceCompiler.state.inlineCache.classBytes.getOrPut(lambdaClassType.internalName) {
-                loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
-            }
+        val classBytes = loadClass(sourceCompiler)
         val superName = ClassReader(classBytes).superName
-        // TODO: suspend lambdas are their own continuations, so the body is pre-inlined into `invokeSuspend`
-        //   and thus can't be detangled from the state machine. To make them inlinable, this needs to be redesigned.
-        //   See `SuspendLambdaLowering`.
-        require(!sourceCompiler.state.languageVersionSettings.isCoroutineSuperClass(superName)) {
-            "suspend default lambda ${lambdaClassType.internalName} cannot be inlined; use a function reference instead"
-        }
+        isPropertyReference = superName in PROPERTY_REFERENCE_SUPER_CLASSES
+        isFunctionReference = superName == FUNCTION_REFERENCE.internalName || superName == FUNCTION_REFERENCE_IMPL.internalName
 
-        val constructorMethod = Method("<init>", Type.VOID_TYPE, info.capturedArgs)
-        val constructor = getMethodNode(classBytes, lambdaClassType, constructorMethod)?.node
-        assert(constructor != null || info.capturedArgs.isEmpty()) {
-            "can't find constructor '$constructorMethod' for default lambda '${lambdaClassType.internalName}'"
+        val constructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
+        val constructor = getMethodNode(classBytes, "<init>", constructorDescriptor, lambdaClassType)?.node
+        assert(constructor != null || capturedArgs.isEmpty()) {
+            "Can't find non-default constructor <init>$constructorDescriptor for default lambda $lambdaClassType"
         }
-
-        val isPropertyReference = superName in PROPERTY_REFERENCE_SUPER_CLASSES
-        val isReference = isPropertyReference ||
-                superName == FUNCTION_REFERENCE.internalName || superName == FUNCTION_REFERENCE_IMPL.internalName
         // This only works for primitives but not inline classes, since information about the Kotlin type of the bound
         // receiver is not present anywhere. This is why with JVM_IR the constructor argument of bound references
         // is already `Object`, and this field is never used.
         originalBoundReceiverType =
-            info.capturedArgs.singleOrNull()?.takeIf { isReference && AsmUtil.isPrimitive(it) }
+            capturedArgs.singleOrNull()?.takeIf { (isFunctionReference || isPropertyReference) && AsmUtil.isPrimitive(it) }
         capturedVars =
-            if (isReference)
-                info.capturedArgs.singleOrNull()?.let {
-                    // See `InlinedLambdaRemapper`
-                    listOf(capturedParamDesc(AsmUtil.RECEIVER_PARAMETER_NAME, OBJECT_TYPE, isSuspend = false))
+            if (isFunctionReference || isPropertyReference)
+                capturedArgs.singleOrNull()?.let {
+                    listOf(capturedParamDesc(AsmUtil.RECEIVER_PARAMETER_NAME, AsmUtil.boxType(it), isSuspend = false))
                 } ?: emptyList()
             else
                 constructor?.findCapturedFieldAssignmentInstructions()?.map { fieldNode ->
                     capturedParamDesc(fieldNode.name, Type.getType(fieldNode.desc), isSuspend = false)
                 }?.toList() ?: emptyList()
-        isBoundCallableReference = isReference && capturedVars.isNotEmpty()
-        node = loadDefaultLambdaBody(classBytes, lambdaClassType, isPropertyReference)
+        isBoundCallableReference = (isFunctionReference || isPropertyReference) && capturedVars.isNotEmpty()
+    }
+
+    private fun loadClass(sourceCompiler: SourceCompilerForInline): ByteArray =
+        sourceCompiler.state.inlineCache.classBytes.getOrPut(lambdaClassType.internalName) {
+            loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
+        }
+
+    // Returns whether the loaded invoke is erased, i.e. the name equals the fallback and all types are `Object`.
+    protected fun loadInvoke(sourceCompiler: SourceCompilerForInline, erasedName: String, actualMethod: Method): Boolean {
+        val classBytes = loadClass(sourceCompiler)
+        // TODO: `signatureAmbiguity = true` ignores the argument types from `invokeMethod` and only looks at the count.
+        node = getMethodNode(classBytes, actualMethod.name, actualMethod.descriptor, lambdaClassType, signatureAmbiguity = true)
+            ?: getMethodNode(classBytes, erasedName, actualMethod.descriptor, lambdaClassType, signatureAmbiguity = true)
+                    ?: error("Can't find method '$actualMethod' in '${lambdaClassType.internalName}'")
+        return invokeMethod.run { name == erasedName && returnType == OBJECT_TYPE && argumentTypes.all { it == OBJECT_TYPE } }
     }
 
     private companion object {

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

@@ -92,6 +92,10 @@ class MethodInliner(
     ): InlineResult {
         //analyze body
         var transformedNode = markPlacesForInlineAndRemoveInlinable(node, returnLabels, finallyDeepShift)
+        if (inliningContext.isInliningLambda && isDefaultLambdaWithReification(inliningContext.lambdaInfo!!)) {
+            //TODO maybe move reification in one place
+            inliningContext.root.inlineMethodReifier.reifyInstructions(transformedNode)
+        }
 
         //substitute returns with "goto end" instruction to keep non local returns in lambdas
         val end = linkedLabel()
@@ -228,7 +232,7 @@ class MethodInliner(
                     val expectedParameters = info.invokeMethod.argumentTypes
                     val expectedKotlinParameters = info.invokeMethodParameters
                     val argumentCount = Type.getArgumentTypes(desc).size.let {
-                        if (info is PsiExpressionLambda && info.invokeMethodDescriptor.isSuspend && it < expectedParameters.size) {
+                        if (!inliningContext.root.state.isIrBackend && info.isSuspend && it < expectedParameters.size) {
                             // Inlining suspend lambda into a function that takes a non-suspend lambda.
                             // In the IR backend, this cannot happen as inline lambdas are not lowered.
                             addFakeContinuationMarker(this)
@@ -317,11 +321,10 @@ class MethodInliner(
                     } else {
                         super.visitMethodInsn(opcode, owner, name, desc, itf)
                     }
-                } else if (ReifiedTypeInliner.isNeedClassReificationMarker(MethodInsnNode(opcode, owner, name, desc, false))) {
-                    // If objects are reified, the marker will be recreated by `handleAnonymousObjectRegeneration` above.
-                    if (!inliningContext.shouldReifyTypeParametersInObjects) {
-                        super.visitMethodInsn(opcode, owner, name, desc, itf)
-                    }
+                } else if ((!inliningContext.isInliningLambda || isDefaultLambdaWithReification(inliningContext.lambdaInfo!!)) &&
+                    ReifiedTypeInliner.isNeedClassReificationMarker(MethodInsnNode(opcode, owner, name, desc, false))
+                ) {
+                    //we shouldn't process here content of inlining lambda it should be reified at external level except default lambdas
                 } else {
                     super.visitMethodInsn(opcode, owner, name, desc, itf)
                 }
@@ -346,6 +349,9 @@ class MethodInliner(
         return resultNode
     }
 
+    private fun isDefaultLambdaWithReification(lambdaInfo: LambdaInfo) =
+        lambdaInfo is DefaultLambda && lambdaInfo.needReification
+
     private fun prepareNode(node: MethodNode, finallyDeepShift: Int): MethodNode {
         node.instructions.resetLabels()
 
@@ -375,7 +381,10 @@ class MethodInliner(
             private fun getNewIndex(`var`: Int): Int {
                 val lambdaInfo = inliningContext.lambdaInfo
                 if (reorderIrLambdaParameters && lambdaInfo is IrExpressionLambda) {
-                    val extensionSize = if (lambdaInfo.isExtensionLambda) lambdaInfo.invokeMethod.argumentTypes[0].size else 0
+                    val extensionSize =
+                        if (lambdaInfo.isExtensionLambda && !lambdaInfo.isBoundCallableReference)
+                            lambdaInfo.invokeMethod.argumentTypes[0].size
+                        else 0
                     return when {
                         //                v-- extensionSize     v-- argsSizeOnStack
                         // |- extension -|- captured -|- real -|- locals -|    old descriptor
@@ -628,8 +637,9 @@ class MethodInliner(
     private fun replaceContinuationAccessesWithFakeContinuationsIfNeeded(processingNode: MethodNode) {
         // in ir backend inline suspend lambdas do not use ALOAD 0 to get continuation, since they are generated as static functions
         // instead they get continuation from parameter.
+        if (inliningContext.state.isIrBackend) return
         val lambdaInfo = inliningContext.lambdaInfo ?: return
-        if (lambdaInfo !is PsiExpressionLambda || !lambdaInfo.invokeMethodDescriptor.isSuspend) return
+        if (!lambdaInfo.isSuspend) return
         val sources = analyzeMethodNodeWithInterpreter(processingNode, Aload0Interpreter(processingNode))
         val cfg = ControlFlowGraph.build(processingNode)
         val aload0s = processingNode.instructions.asSequence().filter { it.opcode == Opcodes.ALOAD && it.safeAs<VarInsnNode>()?.`var` == 0 }

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

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
-import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
 import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
@@ -17,6 +17,15 @@ import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
 import org.jetbrains.org.objectweb.asm.tree.analysis.*
 
+fun parameterOffsets(isStatic: Boolean, valueParameters: List<JvmMethodParameterSignature>): Array<Int> {
+    var nextOffset = if (isStatic) 0 else 1
+    return Array(valueParameters.size) { index ->
+        nextOffset.also {
+            nextOffset += valueParameters[index].asmType.size
+        }
+    }
+}
+
 fun MethodNode.remove(instructions: Sequence<AbstractInsnNode>) =
     instructions.forEach {
         this@remove.instructions.remove(it)
@@ -127,7 +136,7 @@ internal class Aload0Interpreter(private val node: MethodNode) : BasicInterprete
 internal fun AbstractInsnNode.isAload0() = opcode == Opcodes.ALOAD && (this as VarInsnNode).`var` == 0
 
 internal fun analyzeMethodNodeWithInterpreter(node: MethodNode, interpreter: BasicInterpreter): Array<out Frame<BasicValue>?> {
-    val analyzer = object : FastMethodAnalyzer<BasicValue>("fake", node, interpreter) {
+    val analyzer = object : Analyzer<BasicValue>(interpreter) {
         override fun newFrame(nLocals: Int, nStack: Int): Frame<BasicValue> {
 
             return object : Frame<BasicValue>(nLocals, nStack) {
@@ -142,7 +151,7 @@ internal fun analyzeMethodNodeWithInterpreter(node: MethodNode, interpreter: Bas
     }
 
     try {
-        return analyzer.analyze()
+        return analyzer.analyze("fake", node)
     } catch (e: AnalyzerException) {
         throw RuntimeException(e)
     }

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

@@ -107,5 +107,22 @@ class ParametersBuilder private constructor() {
         fun newBuilder(): ParametersBuilder {
             return ParametersBuilder()
         }
+
+        @JvmOverloads
+        @JvmStatic
+        fun initializeBuilderFrom(
+            objectType: Type, descriptor: String, inlineLambda: LambdaInfo? = null, isStatic: Boolean = false
+        ): ParametersBuilder {
+            val builder = newBuilder()
+            if (inlineLambda?.hasDispatchReceiver != false && !isStatic) {
+                //skipped this for inlined lambda cause it will be removed
+                builder.addThis(objectType, inlineLambda != null).functionalArgument = inlineLambda
+            }
+
+            for (type in Type.getArgumentTypes(descriptor)) {
+                builder.addNextParameter(type, false)
+            }
+            return builder
+        }
     }
 }

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

@@ -5,13 +5,16 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getMethodAsmFlags
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
@@ -25,9 +28,12 @@ import org.jetbrains.kotlin.resolve.inline.isInlineOnly
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.Method
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class PsiInlineCodegen(
     codegen: ExpressionCodegen,
@@ -37,12 +43,11 @@ class PsiInlineCodegen(
     typeParameterMappings: TypeParameterMappings<KotlinType>,
     sourceCompiler: SourceCompilerForInline,
     private val methodOwner: Type,
-    private val actualDispatchReceiver: Type,
-    reportErrorsOn: KtElement,
+    private val actualDispatchReceiver: Type
 ) : InlineCodegen<ExpressionCodegen>(
     codegen, state, signature, typeParameterMappings, sourceCompiler,
     ReifiedTypeInliner(
-        typeParameterMappings, PsiInlineIntrinsicsSupport(state, reportErrorsOn), codegen.typeSystem,
+        typeParameterMappings, PsiInlineIntrinsicsSupport(state), codegen.typeSystem,
         state.languageVersionSettings, state.unifiedNullChecks
     ),
 ), CallGenerator {
@@ -89,7 +94,8 @@ class PsiInlineCodegen(
     private val hiddenParameters = mutableListOf<Pair<ParameterInfo, Int>>()
 
     override fun processHiddenParameters() {
-        if (!DescriptorAsmUtil.isStaticMethod((sourceCompiler as PsiSourceCompilerForInline).context.contextKind, functionDescriptor)) {
+        val contextKind = (sourceCompiler as PsiSourceCompilerForInline).context.contextKind
+        if (getMethodAsmFlags(functionDescriptor, contextKind, state) and Opcodes.ACC_STATIC == 0) {
             hiddenParameters += invocationParamBuilder.addNextParameter(methodOwner, false, actualDispatchReceiver) to
                     codegen.frameMap.enterTemp(methodOwner)
         }
@@ -111,6 +117,14 @@ class PsiInlineCodegen(
         hiddenParameters.clear()
     }
 
+    /*lambda or callable reference*/
+    private fun isInliningParameter(expression: KtExpression, valueParameterDescriptor: ValueParameterDescriptor): Boolean {
+        //TODO deparenthesize typed
+        val deparenthesized = KtPsiUtil.deparenthesize(expression)
+
+        return InlineUtil.isInlineParameter(valueParameterDescriptor) && isInlinableParameterExpression(deparenthesized)
+    }
+
     override fun genValueAndPut(
         valueParameterDescriptor: ValueParameterDescriptor?,
         argumentExpression: KtExpression,
@@ -122,9 +136,7 @@ class PsiInlineCodegen(
                     "which cannot be declared in Kotlin and thus be inline: $codegen"
         }
 
-        val isInlineParameter = InlineUtil.isInlineParameter(valueParameterDescriptor)
-        //TODO deparenthesize typed
-        if (isInlineParameter && isInlinableParameterExpression(KtPsiUtil.deparenthesize(argumentExpression))) {
+        if (isInliningParameter(argumentExpression, valueParameterDescriptor)) {
             rememberClosure(argumentExpression, parameterType.type, valueParameterDescriptor)
         } else {
             val value = codegen.gen(argumentExpression)
@@ -185,6 +197,11 @@ class PsiInlineCodegen(
         putCapturedToLocalVal(stackValue, activeLambda!!.capturedVars[paramIndex], stackValue.kotlinType)
 
     override fun reorderArgumentsIfNeeded(actualArgsWithDeclIndex: List<ArgumentAndDeclIndex>, valueParameterTypes: List<Type>) = Unit
+
+    override fun extractDefaultLambdas(node: MethodNode): List<DefaultLambda> =
+        extractDefaultLambdas(node, extractDefaultLambdaOffsetAndDescriptor(jvmSignature, functionDescriptor)) { parameter ->
+            PsiDefaultLambda(type, capturedArgs, parameter, offset, needReification, sourceCompiler)
+        }
 }
 
 private val FunctionDescriptor.explicitParameters
@@ -194,7 +211,7 @@ class PsiExpressionLambda(
     expression: KtExpression,
     private val state: GenerationState,
     val isCrossInline: Boolean,
-    val isBoundCallableReference: Boolean
+    override val isBoundCallableReference: Boolean
 ) : ExpressionLambda() {
     override val lambdaClassType: Type
 
@@ -204,7 +221,7 @@ class PsiExpressionLambda(
 
     override val invokeMethodParameters: List<KotlinType?>
         get() {
-            val actualInvokeDescriptor = if (invokeMethodDescriptor.isSuspend)
+            val actualInvokeDescriptor = if (isSuspend)
                 getOrCreateJvmSuspendFunctionView(invokeMethodDescriptor, state)
             else
                 invokeMethodDescriptor
@@ -222,6 +239,8 @@ class PsiExpressionLambda(
 
     override val returnLabels: Map<String, Label?>
 
+    override val isSuspend: Boolean
+
     val closure: CalculatedClosure
 
     init {
@@ -250,6 +269,7 @@ class PsiExpressionLambda(
             ?: throw AssertionError("null closure for lambda ${expression.text}")
         returnLabels = getDeclarationLabels(expression, invokeMethodDescriptor).associateWith { null }
         invokeMethod = state.typeMapper.mapAsmMethod(invokeMethodDescriptor)
+        isSuspend = invokeMethodDescriptor.isSuspend
     }
 
     // This can only be computed after generating the body, hence `lazy`.
@@ -280,3 +300,32 @@ class PsiExpressionLambda(
     val isPropertyReference: Boolean
         get() = propertyReferenceInfo != null
 }
+
+class PsiDefaultLambda(
+    lambdaClassType: Type,
+    capturedArgs: Array<Type>,
+    parameterDescriptor: ValueParameterDescriptor,
+    offset: Int,
+    needReification: Boolean,
+    sourceCompiler: SourceCompilerForInline
+) : DefaultLambda(lambdaClassType, capturedArgs, offset, needReification, sourceCompiler) {
+    private val invokeMethodDescriptor: FunctionDescriptor
+
+    override val invokeMethodParameters: List<KotlinType?>
+        get() = invokeMethodDescriptor.explicitParameters.map { it.returnType }
+
+    override val invokeMethodReturnType: KotlinType?
+        get() = invokeMethodDescriptor.returnType
+
+    init {
+        val name = if (isPropertyReference) OperatorNameConventions.GET else OperatorNameConventions.INVOKE
+        val descriptor = parameterDescriptor.type.memberScope
+            .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
+            .single()
+            .let { if (parameterDescriptor.type.isSuspendFunctionType) getOrCreateJvmSuspendFunctionView(it, sourceCompiler.state) else it }
+        // This is technically wrong as it always uses `invoke`, but `loadInvoke` will fall back to `get` which is never mangled...
+        val asmMethod = sourceCompiler.state.typeMapper.mapAsmMethod(descriptor)
+        val invokeIsErased = loadInvoke(sourceCompiler, name.asString(), asmMethod)
+        invokeMethodDescriptor = if (invokeIsErased) descriptor.original else descriptor
+    }
+}

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

@@ -12,12 +12,8 @@ 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.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.types.KotlinType
 import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.Type
@@ -25,10 +21,7 @@ import org.jetbrains.org.objectweb.asm.Type.INT_TYPE
 import org.jetbrains.org.objectweb.asm.Type.VOID_TYPE
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
-class PsiInlineIntrinsicsSupport(
-    override val state: GenerationState,
-    private val reportErrorsOn: KtElement,
-) : ReifiedTypeInliner.IntrinsicsSupport<KotlinType> {
+class PsiInlineIntrinsicsSupport(override val state: GenerationState) : ReifiedTypeInliner.IntrinsicsSupport<KotlinType> {
     override fun putClassInstance(v: InstructionAdapter, type: KotlinType) {
         DescriptorAsmUtil.putJavaLangClassInstance(v, state.typeMapper.mapType(type), type, state.typeMapper)
     }
@@ -71,12 +64,4 @@ class PsiInlineIntrinsicsSupport(
     }
 
     override fun toKotlinType(type: KotlinType): KotlinType = type
-
-    override fun reportSuspendTypeUnsupported() {
-        state.diagnostics.report(TYPEOF_SUSPEND_TYPE.on(reportErrorsOn))
-    }
-
-    override fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name) {
-        state.diagnostics.report(TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND.on(reportErrorsOn, typeParameterName.asString()))
-    }
 }

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

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -74,9 +73,6 @@ class ReifiedTypeInliner<KT : KotlinTypeMarker>(
         fun isMutableCollectionType(type: KT): Boolean
 
         fun toKotlinType(type: KT): KotlinType
-
-        fun reportSuspendTypeUnsupported()
-        fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name)
     }
 
     companion object {

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

@@ -78,12 +78,12 @@ fun loadCompiledInlineFunction(
     state: GenerationState
 ): SMAPAndMethodNode {
     val containerType = AsmUtil.asmTypeByClassId(containerId)
+    val bytes = state.inlineCache.classBytes.getOrPut(containerType.internalName) {
+        findVirtualFile(state, containerId)?.contentsToByteArray()
+            ?: throw IllegalStateException("Couldn't find declaration file for $containerId")
+    }
     val resultInCache = state.inlineCache.methodNodeById.getOrPut(MethodId(containerType.descriptor, asmMethod)) {
-        val bytes = state.inlineCache.classBytes.getOrPut(containerType.internalName) {
-            findVirtualFile(state, containerId)?.contentsToByteArray()
-                ?: throw IllegalStateException("Couldn't find declaration file for $containerId")
-        }
-        getMethodNode(containerType, bytes, asmMethod, isSuspend, isMangled)
+        getMethodNode(containerType, bytes, asmMethod.name, asmMethod.descriptor, isSuspend, isMangled)
     }
     return SMAPAndMethodNode(cloneMethodNode(resultInCache.node), resultInCache.classSMAP)
 }
@@ -91,24 +91,25 @@ fun loadCompiledInlineFunction(
 private fun getMethodNode(
     owner: Type,
     bytes: ByteArray,
-    method: Method,
+    name: String,
+    descriptor: String,
     isSuspend: Boolean,
     isMangled: Boolean
 ): SMAPAndMethodNode {
-    getMethodNode(owner, bytes, method, isSuspend)?.let { return it }
+    getMethodNode(owner, bytes, name, descriptor, isSuspend)?.let { return it }
     if (isMangled) {
         // Compatibility with old inline class ABI versions.
-        val dashIndex = method.name.indexOf('-')
-        val nameWithoutManglingSuffix = if (dashIndex > 0) method.name.substring(0, dashIndex) else method.name
-        if (nameWithoutManglingSuffix != method.name) {
-            getMethodNode(owner, bytes, Method(nameWithoutManglingSuffix, method.descriptor), isSuspend)?.let { return it }
+        val dashIndex = name.indexOf('-')
+        val nameWithoutManglingSuffix = if (dashIndex > 0) name.substring(0, dashIndex) else name
+        if (nameWithoutManglingSuffix != name) {
+            getMethodNode(owner, bytes, nameWithoutManglingSuffix, descriptor, isSuspend)?.let { return it }
         }
-        getMethodNode(owner, bytes, Method("$nameWithoutManglingSuffix-impl", method.descriptor), isSuspend)?.let { return it }
+        getMethodNode(owner, bytes, "$nameWithoutManglingSuffix-impl", descriptor, isSuspend)?.let { return it }
     }
-    throw IllegalStateException("couldn't find inline method $owner.$method")
+    throw IllegalStateException("couldn't find inline method $owner.$name$descriptor")
 }
 
 // If an `inline suspend fun` has a state machine, it should have a `$$forInline` version without one.
-private fun getMethodNode(owner: Type, bytes: ByteArray, method: Method, isSuspend: Boolean) =
-    (if (isSuspend) getMethodNode(bytes, owner, Method(method.name + FOR_INLINE_SUFFIX, method.descriptor)) else null)
-        ?: getMethodNode(bytes, owner, method)
+private fun getMethodNode(owner: Type, bytes: ByteArray, name: String, descriptor: String, isSuspend: Boolean) =
+    (if (isSuspend) getMethodNode(bytes, name + FOR_INLINE_SUFFIX, descriptor, owner) else null)
+        ?: getMethodNode(bytes, name, descriptor, owner)

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

@@ -16,16 +16,20 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
+import org.jetbrains.kotlin.codegen.DescriptorAsmUtil
+import org.jetbrains.kotlin.codegen.OwnerKind
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner.Companion.isNeedClassReificationMarker
 import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.util.OperatorNameConventions
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.inline.InlineUtil
+import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
+import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.*
-import kotlin.math.max
 
 private data class Condition(
     val mask: Int, val constant: Int,
@@ -37,6 +41,25 @@ private data class Condition(
     val varIndex = varInsNode?.`var` ?: 0
 }
 
+fun extractDefaultLambdaOffsetAndDescriptor(
+    jvmSignature: JvmMethodSignature,
+    functionDescriptor: FunctionDescriptor
+): Map<Int, ValueParameterDescriptor> {
+    val valueParameters = jvmSignature.valueParameters
+    val containingDeclaration = functionDescriptor.containingDeclaration
+    val kind =
+        if (DescriptorUtils.isInterface(containingDeclaration)) OwnerKind.DEFAULT_IMPLS
+        else OwnerKind.getMemberOwnerKind(containingDeclaration)
+    val parameterOffsets = parameterOffsets(DescriptorAsmUtil.isStaticMethod(kind, functionDescriptor), valueParameters)
+    val valueParameterOffset = valueParameters.takeWhile { it.kind != JvmMethodParameterKind.VALUE }.size
+
+    return functionDescriptor.valueParameters.filter {
+        InlineUtil.isInlineParameter(it) && it.declaresDefaultValue()
+    }.associateBy {
+        parameterOffsets[valueParameterOffset + it.index]
+    }
+}
+
 class ExtractedDefaultLambda(val type: Type, val capturedArgs: Array<Type>, val offset: Int, val needReification: Boolean)
 
 fun expandMaskConditionsAndUpdateVariableNodes(
@@ -179,68 +202,3 @@ private fun defaultLambdaFakeCallStub(args: Array<Type>, lambdaOffset: Int): Met
         false
     )
 }
-
-fun loadDefaultLambdaBody(classBytes: ByteArray, classType: Type, isPropertyReference: Boolean): SMAPAndMethodNode {
-    // In general we can't know what the correct unboxed `invoke` is, and what Kotlin types its arguments have,
-    // as the type of this object may be any subtype of the parameter's type. All we know is that Function<N>
-    // has to have a `invoke` that takes `Object`s and returns an `Object`; everything else needs to be figured
-    // out from its contents. TODO: for > 22 arguments, the only argument is an array. `MethodInliner` can't do that.
-    val invokeName = if (isPropertyReference) OperatorNameConventions.GET.asString() else OperatorNameConventions.INVOKE.asString()
-    val invokeNode = getMethodNode(classBytes, classType) {
-        it.name == invokeName && it.returnType == AsmTypes.OBJECT_TYPE && it.argumentTypes.all { arg -> arg == AsmTypes.OBJECT_TYPE }
-    } ?: error("can't find erased invoke '$invokeName(Object...): Object' in default lambda '${classType.internalName}'")
-    return if (invokeNode.node.access.and(Opcodes.ACC_BRIDGE) == 0)
-        invokeNode
-    else
-        invokeNode.node.inlineBridge(classBytes, classType)
-}
-
-private fun MethodNode.inlineBridge(classBytes: ByteArray, classType: Type): SMAPAndMethodNode {
-    // If the erased invoke is a bridge, we need to locate the unboxed invoke and inline it. As mentioned above,
-    // we don't know what the Kotlin types of its arguments/returned value are, so we can't generate our own
-    // boxing/unboxing code; luckily, the bridge already has that.
-    val invokeInsn = instructions.singleOrNull { it is MethodInsnNode && it.owner == classType.internalName } as MethodInsnNode?
-        ?: error("no single invoke of method on this in '${name}${desc}' of default lambda '${classType.internalName}'")
-    val targetMethod = Method(invokeInsn.name, invokeInsn.desc)
-    val target = getMethodNode(classBytes, classType, targetMethod)
-        ?: error("can't find non-bridge invoke '$targetMethod' in default lambda '${classType.internalName}")
-
-    // Store unboxed/casted arguments in the correct variable slots
-    val targetArgs = targetMethod.argumentTypes
-    val targetArgsSize = targetArgs.sumOf { it.size } + if (target.node.access.and(Opcodes.ACC_STATIC) == 0) 1 else 0
-    var offset = targetArgsSize
-    for (type in targetArgs.reversed()) {
-        offset -= type.size
-        instructions.insertBefore(invokeInsn, VarInsnNode(type.getOpcode(Opcodes.ISTORE), offset))
-    }
-    if (target.node.access.and(Opcodes.ACC_STATIC) == 0) {
-        instructions.insertBefore(invokeInsn, InsnNode(Opcodes.POP)) // this
-    }
-
-    // Remap returns and ranges for arguments' LVT entries
-    val invokeLabel = LabelNode()
-    val returnLabel = LabelNode()
-    instructions.insertBefore(invokeInsn, invokeLabel)
-    instructions.insert(invokeInsn, returnLabel)
-    for (insn in target.node.instructions) {
-        if (insn.opcode in Opcodes.IRETURN..Opcodes.RETURN) {
-            target.node.instructions.set(insn, JumpInsnNode(Opcodes.GOTO, returnLabel))
-        }
-    }
-    for (local in target.node.localVariables) {
-        if (local.index < targetArgsSize) {
-            local.start = invokeLabel
-            local.end = returnLabel
-        }
-    }
-
-    // Insert contents of the method into the bridge
-    instructions.filterIsInstance<LineNumberNode>().forEach { instructions.remove(it) } // those are not meaningful
-    instructions.insertBefore(invokeInsn, target.node.instructions)
-    instructions.remove(invokeInsn)
-    localVariables = target.node.localVariables
-    tryCatchBlocks = target.node.tryCatchBlocks
-    maxLocals = max(maxLocals, target.node.maxLocals)
-    maxStack = max(maxStack, target.node.maxStack)
-    return SMAPAndMethodNode(this, target.classSMAP)
-}

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-import org.jetbrains.org.objectweb.asm.commons.Method
 import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.util.Printer
 import org.jetbrains.org.objectweb.asm.util.Textifier
@@ -85,18 +84,40 @@ private const val INLINE_MARKER_AFTER_INLINE_SUSPEND_ID = 7
 private const val INLINE_MARKER_BEFORE_UNBOX_INLINE_CLASS = 8
 private const val INLINE_MARKER_AFTER_UNBOX_INLINE_CLASS = 9
 
-internal inline fun getMethodNode(classData: ByteArray, classType: Type, crossinline match: (Method) -> Boolean): SMAPAndMethodNode? {
+internal fun getMethodNode(
+    classData: ByteArray,
+    methodName: String,
+    methodDescriptor: String,
+    classType: Type,
+    signatureAmbiguity: Boolean = false
+): SMAPAndMethodNode? {
+    val cr = ClassReader(classData)
     var node: MethodNode? = null
-    var sourceFile: String? = null
-    var sourceMap: String? = null
-    ClassReader(classData).accept(object : ClassVisitor(Opcodes.API_VERSION) {
+    val debugInfo = arrayOfNulls<String>(2)
+
+    cr.accept(object : ClassVisitor(Opcodes.API_VERSION) {
         override fun visitSource(source: String?, debug: String?) {
-            sourceFile = source
-            sourceMap = debug
+            super.visitSource(source, debug)
+            debugInfo[0] = source
+            debugInfo[1] = debug
         }
 
-        override fun visitMethod(access: Int, name: String, desc: String, signature: String?, exceptions: Array<String>?): MethodVisitor? {
-            if (!match(Method(name, desc))) return null
+        override fun visitMethod(
+            access: Int,
+            name: String,
+            desc: String,
+            signature: String?,
+            exceptions: Array<String>?
+        ): MethodVisitor? {
+            if (methodName != name || (signatureAmbiguity && access.and(Opcodes.ACC_SYNTHETIC) != 0)) return null
+
+            if (methodDescriptor != desc) {
+                val sameNumberOfParameters = Type.getArgumentTypes(methodDescriptor).size == Type.getArgumentTypes(desc).size
+                if (!signatureAmbiguity || !sameNumberOfParameters) {
+                    return null
+                }
+            }
+
             node?.let { existing ->
                 throw AssertionError("Can't find proper '$name' method for inline: ambiguity between '${existing.name + existing.desc}' and '${name + desc}'")
             }
@@ -105,14 +126,14 @@ internal inline fun getMethodNode(classData: ByteArray, classType: Type, crossin
         }
     }, ClassReader.SKIP_FRAMES or if (GENERATE_SMAP) 0 else ClassReader.SKIP_DEBUG)
 
-    return node?.let{
-        val (first, last) = listOfNotNull(it).lineNumberRange()
-        SMAPAndMethodNode(it, SMAPParser.parseOrCreateDefault(sourceMap, sourceFile, classType.internalName, first, last))
+    if (node == null) {
+        return null
     }
-}
 
-internal fun getMethodNode(classData: ByteArray, classType: Type, method: Method): SMAPAndMethodNode? =
-    getMethodNode(classData, classType) { it == method }
+    val (first, last) = listOfNotNull(node).lineNumberRange()
+    val smap = SMAPParser.parseOrCreateDefault(debugInfo[1], debugInfo[0], classType.internalName, first, last)
+    return SMAPAndMethodNode(node!!, smap)
+}
 
 internal fun Collection<MethodNode>.lineNumberRange(): Pair<Int, Int> {
     var minLine = Int.MAX_VALUE
@@ -326,42 +347,8 @@ internal val AbstractInsnNode?.insnText: String
         return sw.toString().trim()
     }
 
-fun AbstractInsnNode?.insnText(insnList: InsnList): String {
-    if (this == null) return "<null>"
-
-    fun AbstractInsnNode.indexOf() =
-        insnList.indexOf(this)
-
-    fun LabelNode.labelText() =
-        "L#${this.indexOf()}"
-
-    return when (this) {
-        is LabelNode ->
-            labelText()
-        is JumpInsnNode ->
-            "$insnOpcodeText ${label.labelText()}"
-        is LookupSwitchInsnNode ->
-            "$insnOpcodeText " +
-                    this.keys.zip(this.labels).joinToString(prefix = "[", postfix = "]") { (key, label) -> "$key:${label.labelText()}" }
-        is TableSwitchInsnNode ->
-            "$insnOpcodeText " +
-                    (min..max).zip(this.labels).joinToString(prefix = "[", postfix = "]") { (key, label) -> "$key:${label.labelText()}" }
-        else ->
-            insnText
-    }
-}
-
 internal val AbstractInsnNode?.insnOpcodeText: String
-    get() = when (this) {
-        null -> "null"
-        is LabelNode -> "LABEL"
-        is LineNumberNode -> "LINENUMBER"
-        is FrameNode -> "FRAME"
-        else -> Printer.OPCODES[opcode]
-    }
-
-internal fun TryCatchBlockNode.text(insns: InsnList): String =
-    "[${insns.indexOf(start)} .. ${insns.indexOf(end)} -> ${insns.indexOf(handler)}]"
+    get() = if (this == null) "null" else Printer.OPCODES[opcode]
 
 internal fun loadClassBytesByInternalName(state: GenerationState, internalName: String): ByteArray {
     //try to find just compiled classes then in dependencies

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.codegen.inline
 
-import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -44,9 +43,9 @@ fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeOf(
     val typeParameter = type.typeConstructor().getTypeParameterClassifier()
     if (typeParameter != null) {
         if (!doesTypeContainTypeParametersWithRecursiveBounds(type)) {
-            intrinsicsSupport.reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameter.getName())
-            v.aconst(null)
-            return
+            throw UnsupportedOperationException(
+                "Non-reified type parameters with recursive bounds are not supported yet: ${typeParameter.getName()}"
+            )
         }
 
         generateNonReifiedTypeParameter(v, typeParameter, intrinsicsSupport)
@@ -91,15 +90,9 @@ fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeOf(
 
     v.invokestatic(REFLECTION, methodName, signature, false)
 
-    if (intrinsicsSupport.toKotlinType(type).isSuspendFunctionType) {
-        intrinsicsSupport.reportSuspendTypeUnsupported()
-    }
-
     if (intrinsicsSupport.state.stableTypeOf) {
         if (intrinsicsSupport.isMutableCollectionType(type)) {
             v.invokestatic(REFLECTION, "mutableCollectionType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)
-        } else if (type.typeConstructor().isNothingConstructor()) {
-            v.invokestatic(REFLECTION, "nothingType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)
         }
 
         if (type.isFlexible()) {

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

@@ -34,26 +34,11 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 class ConstantConditionEliminationMethodTransformer : MethodTransformer() {
 
     override fun transform(internalClassName: String, methodNode: MethodNode) {
-        if (!methodNode.hasOptimizableConditions()) {
-            return
-        }
         do {
             val changes = ConstantConditionsOptimization(internalClassName, methodNode).run()
         } while (changes)
     }
 
-    private fun MethodNode.hasOptimizableConditions(): Boolean {
-        val insns = instructions.toArray()
-        return insns.any { it.isIntJump() } && insns.any { it.isIntConst() }
-    }
-
-    private fun AbstractInsnNode.isIntConst() =
-        opcode in Opcodes.ICONST_M1..Opcodes.ICONST_5 || opcode == Opcodes.BIPUSH || opcode == Opcodes.SIPUSH ||
-                (opcode == Opcodes.LDC && this is LdcInsnNode && cst is Int)
-
-    private fun AbstractInsnNode.isIntJump() =
-        opcode in Opcodes.IFEQ..Opcodes.IFLE || opcode in Opcodes.IF_ICMPEQ..Opcodes.IF_ICMPLE
-
     private class ConstantConditionsOptimization(val internalClassName: String, val methodNode: MethodNode) {
         fun run(): Boolean {
             val actions = collectRewriteActions()

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

@@ -72,21 +72,14 @@ class OptimizationMethodVisitor(
     }
 
     companion object {
-        private const val MEMORY_LIMIT_BY_METHOD_MB = 50
-        private const val TRY_CATCH_BLOCKS_LIMIT = 512
+        private val MEMORY_LIMIT_BY_METHOD_MB = 50
 
         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
         }
 
         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)

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

@@ -17,16 +17,13 @@
 package org.jetbrains.kotlin.codegen.optimization.boxing
 
 import org.jetbrains.kotlin.codegen.optimization.OptimizationMethodVisitor
-import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.isLoadOperation
 import org.jetbrains.kotlin.codegen.optimization.fixStack.peekWords
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
-import org.jetbrains.org.objectweb.asm.tree.InsnNode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.analysis.Analyzer
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.SourceInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
@@ -55,7 +52,7 @@ class PopBackwardPropagationTransformer : MethodTransformer() {
         private val dontTouchInsnIndices = BitSet(insns.size)
 
         fun transform() {
-            val frames = FastMethodAnalyzer("fake", methodNode, HazardsTrackingInterpreter()).analyze()
+            val frames = Analyzer(HazardsTrackingInterpreter()).analyze("fake", methodNode)
             for ((i, insn) in insns.withIndex()) {
                 val frame = frames[i] ?: continue
                 when (insn.opcode) {

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

@@ -5,160 +5,46 @@
 
 package org.jetbrains.kotlin.codegen.optimization.common
 
-import gnu.trove.TIntHashSet
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.*
+import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
+import org.jetbrains.org.objectweb.asm.tree.InsnList
+import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 
 
 class ControlFlowGraph private constructor(private val insns: InsnList) {
-    private val successors: Array<MutableList<Int>> = Array(insns.size()) { ArrayList(2) }
-    private val predecessors: Array<MutableList<Int>> = Array(insns.size()) { ArrayList(2) }
+    private val edges: Array<MutableList<Int>> = Array(insns.size()) { arrayListOf<Int>() }
+    private val backwardEdges: Array<MutableList<Int>> = Array(insns.size()) { arrayListOf<Int>() }
 
     fun getSuccessorsIndices(insn: AbstractInsnNode): List<Int> = getSuccessorsIndices(insns.indexOf(insn))
-    fun getSuccessorsIndices(index: Int): List<Int> = successors[index]
+    fun getSuccessorsIndices(index: Int): List<Int> = edges[index]
     fun getPredecessorsIndices(insn: AbstractInsnNode): List<Int> = getPredecessorsIndices(insns.indexOf(insn))
-    fun getPredecessorsIndices(index: Int): List<Int> = predecessors[index]
-
-    private class Builder(
-        private val method: MethodNode,
-        private val followExceptions: Boolean
-    ) {
-        private val instructions = method.instructions
-        private val nInsns = instructions.size()
-
-        private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
-
-        private val queued = BooleanArray(nInsns)
-        private val queue = IntArray(nInsns)
-        private var top = 0
-
-        private val predecessors = Array(nInsns) { TIntHashSet() }
-
-        private val AbstractInsnNode.indexOf get() = instructions.indexOf(this)
-
-        fun build(): ControlFlowGraph {
-            val graph = ControlFlowGraph(method.instructions)
-            if (nInsns == 0) return graph
-
-            checkAssertions()
-            computeExceptionHandlersForEachInsn()
-            initControlFlowAnalysis()
-            traverseCfg()
-
-            for ((i, preds) in predecessors.withIndex()) {
-                for (pred in preds.toArray()) {
-                    graph.predecessors[i].add(pred)
-                    graph.successors[pred].add(i)
-                }
-            }
-            return graph
-        }
-
-        private fun traverseCfg() {
-            while (top > 0) {
-                val insn = queue[--top]
-                val insnNode = method.instructions[insn]
-                val insnOpcode = insnNode.opcode
-
-                when (insnNode.type) {
-                    AbstractInsnNode.LABEL, AbstractInsnNode.LINE, AbstractInsnNode.FRAME ->
-                        visitOpInsn(insn)
-                    AbstractInsnNode.JUMP_INSN ->
-                        visitJumpInsnNode(insnNode as JumpInsnNode, insn, insnOpcode)
-                    AbstractInsnNode.LOOKUPSWITCH_INSN ->
-                        visitLookupSwitchInsnNode(insn, insnNode as LookupSwitchInsnNode)
-                    AbstractInsnNode.TABLESWITCH_INSN ->
-                        visitTableSwitchInsnNode(insn, insnNode as TableSwitchInsnNode)
-                    else -> {
-                        if (insnOpcode != Opcodes.ATHROW && (insnOpcode < Opcodes.IRETURN || insnOpcode > Opcodes.RETURN)) {
-                            visitOpInsn(insn)
-                        }
-                    }
-                }
-
-
-                handlers[insn]?.forEach { tcb ->
-                    visitExceptionEdge(insn, tcb.handler.indexOf)
-                }
-            }
-        }
-
-        private fun checkAssertions() {
-            if (instructions.any { it.opcode == Opcodes.JSR || it.opcode == Opcodes.RET })
-                throw AssertionError("Subroutines are deprecated since Java 6")
-        }
-
-        private fun visitOpInsn(insn: Int) {
-            visitEdge(insn, insn + 1)
-        }
-
-        private fun visitTableSwitchInsnNode(insn: Int, insnNode: TableSwitchInsnNode) {
-            var jump = insnNode.dflt.indexOf
-            visitEdge(insn, jump)
-            for (label in insnNode.labels) {
-                jump = label.indexOf
-                visitEdge(insn, jump)
-            }
-        }
-
-        private fun visitLookupSwitchInsnNode(insn: Int, insnNode: LookupSwitchInsnNode) {
-            var jump = insnNode.dflt.indexOf
-            visitEdge(insn, jump)
-            for (label in insnNode.labels) {
-                jump = label.indexOf
-                visitEdge(insn, jump)
-            }
-        }
-
-        private fun visitJumpInsnNode(insnNode: JumpInsnNode, insn: Int, insnOpcode: Int) {
-            if (insnOpcode != Opcodes.GOTO && insnOpcode != Opcodes.JSR) {
-                visitEdge(insn, insn + 1)
-            }
-            val jump = insnNode.label.indexOf
-            visitEdge(insn, jump)
-        }
-
-        private fun initControlFlowAnalysis() {
-            queued[0] = true
-            queue[top++] = 0
-        }
-
-        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 insnHandlers = handlers[j]
-                        ?: ArrayList<TryCatchBlockNode>().also { handlers[j] = it }
-                    insnHandlers.add(tcb)
-                }
-            }
-        }
-
-        private fun visitExceptionEdge(from: Int, to: Int) {
-            if (followExceptions) {
-                predecessors[to].add(from)
-            }
-            enqueue(to)
-        }
-
-        private fun visitEdge(from: Int, to: Int) {
-            predecessors[to].add(from)
-            enqueue(to)
-        }
-
-        private fun enqueue(insn: Int) {
-            if (!queued[insn]) {
-                queued[insn] = true
-                queue[top++] = insn
-            }
-        }
-    }
+    fun getPredecessorsIndices(index: Int): List<Int> = backwardEdges[index]
 
     companion object {
         @JvmStatic
         fun build(node: MethodNode, followExceptions: Boolean = true): ControlFlowGraph {
-            return Builder(node, followExceptions).build()
+            val graph = ControlFlowGraph(node.instructions)
+
+            fun addEdge(from: Int, to: Int) {
+                graph.edges[from].add(to)
+                graph.backwardEdges[to].add(from)
+            }
+
+            object : MethodAnalyzer<BasicValue>("fake", node, OptimizationBasicInterpreter()) {
+                override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
+                    addEdge(insn, successor)
+                    return true
+                }
+
+                override fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean {
+                    if (followExceptions) {
+                        addEdge(insn, successor)
+                    }
+                    return true
+                }
+            }.analyze()
+
+            return graph
         }
     }
 }

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

@@ -24,6 +24,6 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Value
 class CustomFramesMethodAnalyzer<V : Value>(
     owner: String, method: MethodNode, interpreter: Interpreter<V>,
     private val frameFactory: (Int, Int) -> Frame<V>
-) : FastMethodAnalyzer<V>(owner, method, interpreter) {
+) : MethodAnalyzer<V>(owner, method, interpreter) {
     override fun newFrame(nLocals: Int, nStack: Int) = frameFactory(nLocals, nStack)
 }

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

@@ -1,374 +0,0 @@
-/*
- * 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.common
-
-import org.jetbrains.kotlin.codegen.inline.insnOpcodeText
-import org.jetbrains.kotlin.codegen.inline.insnText
-import org.jetbrains.kotlin.utils.SmartList
-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.fixStack.HackedFixStackMethodAnalyzerBase
- */
-@Suppress("DuplicatedCode")
-open class FastMethodAnalyzer<V : Value>(
-    private val owner: String,
-    val method: MethodNode,
-    private val interpreter: Interpreter<V>
-) {
-    private val insnsArray = method.instructions.toArray()
-    private val nInsns = method.instructions.size()
-
-    // Single Predecessor Block (SPB) is a continuous sequence of instructions { I1, ... In } such that
-    //  if I=insns[i] and J=insns[i+1] both belong to SPB,
-    //  then I is a single immediate predecessor of J in a complete method control flow graph
-    //  (including exception edges).
-    //
-    // Note that classic basic blocks are SPBs, but the opposite is not true:
-    // SPBs have single entry point, but can have multiple exit points
-    // (which lead to instructions not belonging to the given SPB).
-    // Example:
-    //      aload 1
-    //      dup
-    //      ifnull LA
-    //      invokevirtual foo()
-    //      dup
-    //      ifnull LB
-    //      invokevirtual bar()
-    //      goto LC
-    // is SPB (but not a basic block).
-    //
-    // For each J=insns[i+1] such that I=insns[i] belongs to the same SPB,
-    // data flow transfer function
-    //      Execute( J, Merge( { Out(K) | K <- Pred(J) } ) )
-    // is effectively
-    //      Execute( J, Out(I) ) )
-    // so, we don't need to merge frames for such I->J edges.
-    private val singlePredBlock = IntArray(nInsns)
-
-    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)
-
-    fun analyze(): Array<Frame<V>?> {
-        if (nInsns == 0) return frames
-
-        checkAssertions()
-
-        computeExceptionHandlersForEachInsn(method)
-
-        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()
-
-                    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 AbstractInsnNode.indexOf() =
-        method.instructions.indexOf(this)
-
-    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
-            }
-        }
-    }
-
-    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) {
-        mergeControlFlowEdge(insn, insn + 1, current)
-    }
-
-    private fun visitTableSwitchInsnNode(insnNode: TableSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = insnNode.dflt.indexOf()
-        mergeControlFlowEdge(insn, jump, current)
-        // 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()
-            mergeControlFlowEdge(insn, jump, current)
-        }
-    }
-
-    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
-        var jump = insnNode.dflt.indexOf()
-        mergeControlFlowEdge(insn, jump, current)
-        for (label in insnNode.labels) {
-            jump = label.indexOf()
-            mergeControlFlowEdge(insn, jump, current)
-        }
-    }
-
-    private fun visitJumpInsnNode(insnNode: JumpInsnNode, current: Frame<V>, insn: Int, insnOpcode: Int) {
-        if (insnOpcode != Opcodes.GOTO) {
-            mergeControlFlowEdge(insn, insn + 1, current)
-        }
-        val jump = insnNode.label.indexOf()
-        mergeControlFlowEdge(insn, jump, current)
-    }
-
-    private fun visitNopInsn(f: Frame<V>, insn: Int) {
-        mergeControlFlowEdge(insn, insn + 1, f)
-    }
-
-    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(m: MethodNode) {
-        for (tcb in m.tryCatchBlocks) {
-            val begin = tcb.start.indexOf()
-            val end = tcb.end.indexOf()
-            for (j in begin until end) {
-                if (!insnsArray[j].isMeaningful) continue
-                var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[j]
-                if (insnHandlers == null) {
-                    insnHandlers = SmartList()
-                    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
-        }
-    }
-
-    @Suppress("unused")
-    private fun dumpBlocksInfo() {
-        fun LabelNode?.labelText() =
-            if (this != null) "L#${indexOf()}" else "L<null>"
-
-        println("===== ${method.name} ${method.signature} ======")
-        for ((i, insn) in insnsArray.withIndex()) {
-            val insnText = when (insn) {
-                is LabelNode ->
-                    "L#$i"
-                is JumpInsnNode ->
-                    "${insn.insnOpcodeText} ${insn.label.labelText()}"
-                is TableSwitchInsnNode ->
-                    "${insn.insnOpcodeText} min=${insn.min} max=${insn.max} \n\t\t\t" +
-                            "[${insn.labels.joinToString { it.labelText() }}] \n\t\t\t" +
-                            "dflt:${insn.dflt.labelText()}"
-                is LookupSwitchInsnNode ->
-                    "${insn.insnOpcodeText} \n\t\t\t" +
-                            "[${insn.keys.zip(insn.labels).joinToString { (key, label) -> "$key: ${label.labelText()}"}}] \n\t\t\t" +
-                            "dflt:${insn.dflt.labelText()}"
-                else ->
-                    insn.insnText
-            }
-            println("$i\t${singlePredBlock[i]}\t$insnText")
-        }
-        for (tcb in method.tryCatchBlocks) {
-            println("\tTCB start:${tcb.start.labelText()} end:${tcb.end.labelText()} handler:${tcb.handler.labelText()}")
-        }
-        println()
-    }
-}

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

@@ -1,35 +1,6 @@
 /*
  * 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.common
@@ -124,7 +95,7 @@ class InstructionLivenessAnalyzer(val method: MethodNode) {
         var jump = insnNode.dflt.indexOf
         visitControlFlowEdge(jump)
         for (label in insnNode.labels) {
-            jump = label.indexOf
+            jump = instructions.indexOf(label)
             visitControlFlowEdge(jump)
         }
     }
@@ -155,10 +126,9 @@ class InstructionLivenessAnalyzer(val method: MethodNode) {
             val begin = tcb.start.indexOf
             val end = tcb.end.indexOf
             for (j in begin until end) {
-                if (!instructions[j].isMeaningful) continue
                 var insnHandlers = handlers[j]
                 if (insnHandlers == null) {
-                    insnHandlers = ArrayList()
+                    insnHandlers = ArrayList<TryCatchBlockNode>()
                     handlers[j] = insnHandlers
                 }
                 insnHandlers.add(tcb)

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

@@ -0,0 +1,263 @@
+/*
+ * 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
+import java.util.*
+
+/**
+ * This class is a modified version of `org.objectweb.asm.tree.analysis.Analyzer`
+ * @author Eric Bruneton
+ * @author Dmitry Petrov
+ */
+open class MethodAnalyzer<V : Value>(
+    private val owner: String,
+    val method: MethodNode,
+    protected val interpreter: Interpreter<V>
+) {
+    val instructions: InsnList = method.instructions
+    private val nInsns: Int = instructions.size()
+
+    val frames: Array<Frame<V>?> = arrayOfNulls(nInsns)
+
+    private val handlers: Array<MutableList<TryCatchBlockNode>?> = arrayOfNulls(nInsns)
+    private val queued: BooleanArray = BooleanArray(nInsns)
+    private val queue: IntArray = IntArray(nInsns)
+    private var top: Int = 0
+
+    protected open fun init(owner: String, m: MethodNode) {}
+
+    protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
+
+    protected open fun newFrame(src: Frame<out V>): Frame<V> {
+        val frame = newFrame(src.locals, src.maxStackSize)
+        frame.init(src)
+        return frame
+    }
+
+    protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
+
+    protected open fun visitControlFlowExceptionEdge(insn: Int, successor: Int): Boolean = true
+
+    protected open fun visitControlFlowExceptionEdge(insn: Int, tcb: TryCatchBlockNode): Boolean =
+        visitControlFlowExceptionEdge(insn, instructions.indexOf(tcb.handler))
+
+    fun analyze(): Array<Frame<V>?> {
+        if (nInsns == 0) return frames
+
+        checkAssertions()
+
+        computeExceptionHandlersForEachInsn(method)
+
+        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 = instructions.indexOf(tcb.handler)
+                    if (visitControlFlowExceptionEdge(insn, tcb)) {
+                        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
+    }
+
+    fun getFrame(insn: AbstractInsnNode): Frame<V>? =
+        frames[instructions.indexOf(insn)]
+
+    private fun checkAssertions() {
+        if (instructions.toArray().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 = instructions.indexOf(insnNode.dflt)
+        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 = instructions.indexOf(label)
+            processControlFlowEdge(current, insn, jump)
+        }
+    }
+
+    private fun visitLookupSwitchInsnNode(insnNode: LookupSwitchInsnNode, current: Frame<V>, insn: Int) {
+        var jump = instructions.indexOf(insnNode.dflt)
+        processControlFlowEdge(current, insn, jump)
+        for (label in insnNode.labels) {
+            jump = instructions.indexOf(label)
+            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 = instructions.indexOf(insnNode.label)
+        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)
+
+        init(owner, m)
+    }
+
+    private fun computeExceptionHandlersForEachInsn(m: MethodNode) {
+        for (tcb in m.tryCatchBlocks) {
+            val begin = instructions.indexOf(tcb.start)
+            val end = instructions.indexOf(tcb.end)
+            for (j in begin until end) {
+                var insnHandlers: MutableList<TryCatchBlockNode>? = handlers[j]
+                if (insnHandlers == null) {
+                    insnHandlers = ArrayList<TryCatchBlockNode>()
+                    handlers[j] = insnHandlers
+                }
+                insnHandlers.add(tcb)
+            }
+        }
+    }
+
+    private fun mergeControlFlowEdge(insn: Int, frame: Frame<V>) {
+        val oldFrame = frames[insn]
+        val changes =
+            if (oldFrame != null)
+                oldFrame.merge(frame, interpreter)
+            else {
+                frames[insn] = newFrame(frame)
+                true
+            }
+        if (changes && !queued[insn]) {
+            queued[insn] = true
+            queue[top++] = insn
+        }
+    }
+
+}

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

@@ -38,12 +38,13 @@ fun <F : VarFrame<F>> analyze(node: MethodNode, interpreter: BackwardAnalysisInt
     val frames = (1..insnList.size()).map { interpreter.newFrame(node.maxLocals) }.toMutableList()
     val insnArray = insnList.toArray()
 
+    // see Figure 9.16 from Dragon book
     var wereChanges: Boolean
 
     do {
         wereChanges = false
-        for (index in insnArray.indices.reversed()) {
-            val insn = insnArray[index]
+        for (insn in insnArray) {
+            val index = insnList.indexOf(insn)
             val newFrame = interpreter.newFrame(node.maxLocals)
             for (successorIndex in graph.getSuccessorsIndices(insn)) {
                 newFrame.mergeFrom(frames[successorIndex])

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

@@ -19,6 +19,9 @@ 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.MethodAnalyzer
+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
@@ -26,6 +29,7 @@ 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.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
 import kotlin.math.max
@@ -45,14 +49,9 @@ internal class FixStackAnalyzer(
 
     val maxExtraStackSize: Int get() = analyzer.maxExtraStackSize
 
-    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 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 getExpectedStackSize(location: AbstractInsnNode): Int {
         // We should look for expected stack size at loop entry point markers if available,
@@ -89,27 +88,25 @@ internal class FixStackAnalyzer(
 
     private val analyzer = InternalAnalyzer(owner)
 
-    private inner class InternalAnalyzer(owner: String) :
-        HackedFixStackMethodAnalyzerBase<FixStackValue>(owner, method, FixStackInterpreter()) {
-
-        val spilledStacks = hashMapOf<AbstractInsnNode, List<FixStackValue>>()
+    private inner class InternalAnalyzer(owner: String) : MethodAnalyzer<BasicValue>(owner, method, OptimizationBasicInterpreter()) {
+        val spilledStacks = hashMapOf<AbstractInsnNode, List<BasicValue>>()
         var maxExtraStackSize = 0; private set
 
         override fun visitControlFlowEdge(insn: Int, successor: Int): Boolean {
             if (!skipBreakContinueGotoEdges) return true
-            val insnNode = insnsArray[insn]
+            val insnNode = instructions[insn]
             return !(insnNode is JumpInsnNode && context.breakContinueGotoNodes.contains(insnNode))
         }
 
-        override fun newFrame(nLocals: Int, nStack: Int): Frame<FixStackValue> =
+        override fun newFrame(nLocals: Int, nStack: Int): Frame<BasicValue> =
             FixStackFrame(nLocals, nStack)
 
         private fun indexOf(node: AbstractInsnNode) = method.instructions.indexOf(node)
 
-        inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<FixStackValue>(nLocals, nStack) {
-            val extraStack = Stack<FixStackValue>()
+        inner class FixStackFrame(nLocals: Int, nStack: Int) : Frame<BasicValue>(nLocals, nStack) {
+            val extraStack = Stack<BasicValue>()
 
-            override fun init(src: Frame<out FixStackValue>): Frame<FixStackValue> {
+            override fun init(src: Frame<out BasicValue>): Frame<BasicValue> {
                 extraStack.clear()
                 extraStack.addAll((src as FixStackFrame).extraStack)
                 return super.init(src)
@@ -120,7 +117,7 @@ internal class FixStackAnalyzer(
                 super.clearStack()
             }
 
-            override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<FixStackValue>) {
+            override fun execute(insn: AbstractInsnNode, interpreter: Interpreter<BasicValue>) {
                 when {
                     PseudoInsn.SAVE_STACK_BEFORE_TRY.isa(insn) ->
                         executeSaveStackBeforeTry(insn)
@@ -130,8 +127,10 @@ internal class FixStackAnalyzer(
                         executeBeforeInlineCallMarker(insn)
                     isAfterInlineMarker(insn) ->
                         executeAfterInlineCallMarker(insn)
-                    insn.opcode == Opcodes.RETURN ->
-                        return
+                    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
+                    }
                 }
 
                 super.execute(insn, interpreter)
@@ -139,16 +138,14 @@ internal class FixStackAnalyzer(
 
             val stackSizeWithExtra: Int get() = super.getStackSize() + extraStack.size
 
-            fun getStackContent(): List<FixStackValue> {
-                val savedStack = ArrayList<FixStackValue>()
-                for (i in 0 until super.getStackSize()) {
-                    savedStack.add(super.getStack(i))
-                }
+            fun getStackContent(): List<BasicValue> {
+                val savedStack = arrayListOf<BasicValue>()
+                IntRange(0, super.getStackSize() - 1).mapTo(savedStack) { super.getStack(it) }
                 savedStack.addAll(extraStack)
                 return savedStack
             }
 
-            override fun push(value: FixStackValue) {
+            override fun push(value: BasicValue) {
                 if (super.getStackSize() < maxStackSize) {
                     super.push(value)
                 } else {
@@ -157,27 +154,24 @@ internal class FixStackAnalyzer(
                 }
             }
 
-            fun pushAll(values: Collection<FixStackValue>) {
+            fun pushAll(values: Collection<BasicValue>) {
                 values.forEach { push(it) }
             }
 
-            override fun pop(): FixStackValue =
-                if (extraStack.isNotEmpty()) {
+            override fun pop(): BasicValue {
+                return if (extraStack.isNotEmpty()) {
                     extraStack.pop()
                 } else {
                     super.pop()
                 }
-
-            override fun setStack(i: Int, value: FixStackValue) {
-                if (i < super.getMaxStackSize()) {
-                    super.setStack(i, value)
-                } else {
-                    extraStack[i - maxStackSize] = value
-                }
             }
 
-            override fun merge(frame: Frame<out FixStackValue>, interpreter: Interpreter<FixStackValue>): Boolean {
-                throw UnsupportedOperationException("Stack normalization should not merge frames")
+            override fun getStack(i: Int): BasicValue {
+                return if (i < super.getMaxStackSize()) {
+                    super.getStack(i)
+                } else {
+                    extraStack[i - maxStackSize]
+                }
             }
         }
 

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

@@ -1,157 +0,0 @@
-/*
- * 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

@@ -1,38 +0,0 @@
-/*
- * 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/HackedFixStackMethodAnalyzerBase.kt

@@ -1,318 +0,0 @@
-/*
- * 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 HackedFixStackMethodAnalyzerBase<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
-
-    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
-
-        // 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()
-
-        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]
-            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).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 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(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/LocalVariablesManager.kt

@@ -18,6 +18,7 @@ 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) {
@@ -38,10 +39,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
         methodNode.maxLocals = max(methodNode.maxLocals, newValue)
     }
 
-    fun allocateVariablesForSaveStackMarker(
-        saveStackMarker: AbstractInsnNode,
-        savedStackValues: List<FixStackValue>
-    ): SavedStackDescriptor {
+    fun allocateVariablesForSaveStackMarker(saveStackMarker: AbstractInsnNode, savedStackValues: List<BasicValue>): SavedStackDescriptor {
         val numRestoreStackMarkers = context.restoreStackMarkersForSaveMarker[saveStackMarker]!!.size
         return allocateNewHandle(numRestoreStackMarkers, saveStackMarker, savedStackValues)
     }
@@ -49,10 +47,10 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
     private fun allocateNewHandle(
         numRestoreStackMarkers: Int,
         saveStackMarker: AbstractInsnNode,
-        savedStackValues: List<FixStackValue>
+        savedStackValues: List<BasicValue>
     ): SavedStackDescriptor {
-        if (savedStackValues.any { it == FixStackValue.UNINITIALIZED }) {
-            throw AssertionError("Uninitialized value on stack at ${methodNode.instructions.indexOf(saveStackMarker)}: $savedStackValues")
+        if (savedStackValues.any { it.type == null }) {
+            throw AssertionError("Uninitialized value on stack at ${methodNode.instructions.indexOf(saveStackMarker)}")
         }
 
         val firstUnusedLocalVarIndex = getFirstUnusedLocalVariableIndex()
@@ -80,7 +78,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
 
     fun allocateVariablesForBeforeInlineMarker(
         beforeInlineMarker: AbstractInsnNode,
-        savedStackValues: List<FixStackValue>
+        savedStackValues: List<BasicValue>
     ): SavedStackDescriptor {
         return allocateNewHandle(1, beforeInlineMarker, savedStackValues)
     }
@@ -103,7 +101,7 @@ internal class LocalVariablesManager(val context: FixStackContext, val methodNod
         }
     }
 
-    fun createReturnValueVariable(returnValue: FixStackValue): Int {
+    fun createReturnValueVariable(returnValue: BasicValue): 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<FixStackValue>,
+    val savedValues: List<BasicValue>,
     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: FixStackValue,
+    returnValue: BasicValue,
     returnValueLocalVarIndex: Int
 ) {
     with(methodNode.instructions) {
-        insertBefore(nodeToReplace, VarInsnNode(returnValue.storeOpcode, returnValueLocalVarIndex))
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.type.getOpcode(Opcodes.ISTORE), returnValueLocalVarIndex))
         generateLoadInstructions(methodNode, nodeToReplace, savedStackDescriptor)
-        insertBefore(nodeToReplace, VarInsnNode(returnValue.loadOpcode, returnValueLocalVarIndex))
+        insertBefore(nodeToReplace, VarInsnNode(returnValue.type.getOpcode(Opcodes.ILOAD), returnValueLocalVarIndex))
         remove(nodeToReplace)
     }
 }
@@ -102,7 +102,10 @@ 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.loadOpcode, localVarIndex))
+        methodNode.instructions.insertBefore(
+            location,
+            VarInsnNode(value.type.getOpcode(Opcodes.ILOAD), localVarIndex)
+        )
         localVarIndex += value.size
     }
 }
@@ -111,7 +114,10 @@ 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.storeOpcode, localVarIndex))
+        methodNode.instructions.insertBefore(
+            location,
+            VarInsnNode(value.type.getOpcode(Opcodes.ISTORE), localVarIndex)
+        )
     }
 }
 
@@ -140,10 +146,10 @@ fun replaceAlwaysTrueIfeqWithGoto(methodNode: MethodNode, node: AbstractInsnNode
     }
 }
 
-fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, stackContent: List<FixStackValue>) {
+fun replaceMarkerWithPops(methodNode: MethodNode, node: AbstractInsnNode, expectedStackSize: Int, stackContent: List<BasicValue>) {
     with(methodNode.instructions) {
         for (stackValue in stackContent.subList(expectedStackSize, stackContent.size)) {
-            insert(node, InsnNode(stackValue.popOpcode))
+            insert(node, getPopInstruction(stackValue))
         }
         remove(node)
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/transformer/MethodTransformer.java

@@ -17,14 +17,13 @@
 package org.jetbrains.kotlin.codegen.optimization.transformer;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.org.objectweb.asm.tree.MethodNode;
 import org.jetbrains.org.objectweb.asm.tree.analysis.*;
 
 public abstract class MethodTransformer {
     @NotNull
-    private static <V extends Value> Frame<V>[] runAnalyzer(
+    protected static <V extends Value> Frame<V>[] runAnalyzer(
             @NotNull Analyzer<V> analyzer,
             @NotNull String internalClassName,
             @NotNull MethodNode node
@@ -43,12 +42,7 @@ public abstract class MethodTransformer {
             @NotNull MethodNode node,
             @NotNull Interpreter<V> interpreter
     ) {
-        try {
-            FastMethodAnalyzer<V> analyser = new FastMethodAnalyzer<>(internalClassName, node, interpreter);
-            return analyser.analyze();
-        } catch (Exception e) {
-            throw ExceptionUtilsKt.rethrow(e);
-        }
+        return runAnalyzer(new Analyzer<>(interpreter), internalClassName, node);
     }
 
     public abstract void transform(@NotNull String internalClassName, @NotNull MethodNode methodNode);

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java

@@ -35,8 +35,6 @@ public final class JvmSerializationBindings {
             SerializationMappingSlice.create();
     public static final SerializationMappingSlice<PropertyDescriptor, Method> SYNTHETIC_METHOD_FOR_PROPERTY =
             SerializationMappingSlice.create();
-    public static final SerializationMappingSlice<PropertyDescriptor, Method> DELEGATE_METHOD_FOR_PROPERTY =
-            SerializationMappingSlice.create();
 
     public static final class SerializationMappingSlice<K, V> extends BasicWritableSlice<K, V> {
         public SerializationMappingSlice() {

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt

@@ -255,15 +255,12 @@ class JvmSerializerExtension @JvmOverloads constructor(
 
         val field = getBinding(FIELD_FOR_PROPERTY, descriptor)
         val syntheticMethod = getBinding(SYNTHETIC_METHOD_FOR_PROPERTY, descriptor)
-        val delegateMethod = getBinding(DELEGATE_METHOD_FOR_PROPERTY, descriptor)
-        assert(descriptor.isDelegated || delegateMethod == null) { "non-delegated property $descriptor has delegate method" }
 
         val signature = signatureSerializer.propertySignature(
             descriptor,
             field?.second,
             field?.first?.descriptor,
             if (syntheticMethod != null) signatureSerializer.methodSignature(null, syntheticMethod) else null,
-            if (delegateMethod != null) signatureSerializer.methodSignature(null, delegateMethod) else null,
             if (getterMethod != null) signatureSerializer.methodSignature(null, getterMethod) else null,
             if (setterMethod != null) signatureSerializer.methodSignature(null, setterMethod) else null
         )
@@ -362,7 +359,6 @@ class JvmSerializerExtension @JvmOverloads constructor(
             fieldName: String?,
             fieldDesc: String?,
             syntheticMethod: JvmProtoBuf.JvmMethodSignature?,
-            delegateMethod: JvmProtoBuf.JvmMethodSignature?,
             getter: JvmProtoBuf.JvmMethodSignature?,
             setter: JvmProtoBuf.JvmMethodSignature?
         ): JvmProtoBuf.JvmPropertySignature? {
@@ -377,10 +373,6 @@ class JvmSerializerExtension @JvmOverloads constructor(
                 signature.syntheticMethod = syntheticMethod
             }
 
-            if (delegateMethod != null) {
-                signature.delegateMethod = delegateMethod
-            }
-
             if (getter != null) {
                 signature.getter = getter
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -407,7 +407,6 @@ class GenerationState private constructor(
             this[KOTLIN_1_4] = JvmMetadataVersion(1, 4, 3)
             this[KOTLIN_1_5] = JvmMetadataVersion.INSTANCE
             this[KOTLIN_1_6] = JvmMetadataVersion(1, 6, 0)
-            this[KOTLIN_1_7] = JvmMetadataVersion(1, 7, 0)
 
             check(size == LanguageVersion.values().size) {
                 "Please add mappings from the missing LanguageVersion instances to the corresponding JvmMetadataVersion " +