Introduce GetScriptingClassByClassLoader interface

It is needed to override default JVM behaviour

.bunch

@@ -1,4 +1,7 @@
-202
 201
-as41_201
-as42
+202
+203_202
+193
+as40_193
+as41
+as42_202

.idea/runConfigurations/Generate_Compiler_Tests.xml

@@ -10,7 +10,7 @@
       </option>
       <option name="taskNames">
         <list>
-          <option value=":compiler:tests-for-compiler-generator:generateTests" />
+          <option value=":compiler:generateTests" />
           <option value=":compiler:tests-java8:generateTests" />
           <option value=":compiler:tests-against-klib:generateTests" />
           <option value=":js:js.tests:generateTests" />
@@ -22,4 +22,4 @@
     <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
     <method />
   </configuration>
-</component>
+</component>

.idea/vcs.xml

@@ -8,13 +8,6 @@
       <inspection_tool class="SubjectLimit" enabled="true" level="WARNING" enabled_by_default="true" />
     </profile>
   </component>
-  <component name="GithubSharedProjectSettings">
-    <option name="branchProtectionPatterns">
-      <list>
-        <option value="master" />
-      </list>
-    </option>
-  </component>
   <component name="IssueNavigationConfiguration">
     <option name="links">
       <list>

ChangeLog.md

@@ -1,336 +1,5 @@
 # CHANGELOG
 
-
-## 1.4.30-M1
-
-### Android
-
-- [`KT-42383`](https://youtrack.jetbrains.com/issue/KT-42383) HMPP: Bad IDEA dependencies: Missing dependency from p1:jvmAndAndroid to p2:jvmAndAndroid
-
-### Backend. Native
-
-- [`KT-38772`](https://youtrack.jetbrains.com/issue/KT-38772) Native: support non-reified type parameters in typeOf
-- [`KT-42234`](https://youtrack.jetbrains.com/issue/KT-42234) Move LLVM optimization parameters into konan.properties
-- [`KT-42649`](https://youtrack.jetbrains.com/issue/KT-42649) IndexOutOfBoundsException during InlineClassTransformer lowering
-- [`KT-42942`](https://youtrack.jetbrains.com/issue/KT-42942) Native: optimize peak backend memory by clearing BindingContext after psi2ir
-- [`KT-43198`](https://youtrack.jetbrains.com/issue/KT-43198) init blocks inside inline classes
-- [`KT-31072`](https://youtrack.jetbrains.com/issue/KT-31072) Don't use non-reified arguments to specialize type operations in IR inliner
-
-### Backend. JS
-- [`KT-41227`](https://youtrack.jetbrains.com/issue/KT-41227) KJS IR: don't copy to child's prototype references to the function from parent
-
-### Backend. IR
-- [`KT-41227`](https://youtrack.jetbrains.com/issue/KT-41227) KJS IR: don't copy to child's prototype references to the function from parent
-
-### Compiler
-
-#### New Features
-
-- [`KT-28055`](https://youtrack.jetbrains.com/issue/KT-28055) Consider supporting `init` blocks inside inline classes
-- [`KT-28056`](https://youtrack.jetbrains.com/issue/KT-28056) Consider supporting non-public primary constructors for inline classes
-- [`KT-42094`](https://youtrack.jetbrains.com/issue/KT-42094) Allow open callable members in expect interfaces
-- [`KT-43129`](https://youtrack.jetbrains.com/issue/KT-43129) FIR: Support OverloadResolutionByLambdaReturnType
-
-#### Performance Improvements
-
-- [`KT-41352`](https://youtrack.jetbrains.com/issue/KT-41352) JVM IR: reduce bytecode size in for loops and range checks with 'until' by not using inclusive end
-- [`KT-41644`](https://youtrack.jetbrains.com/issue/KT-41644) NI: Infinite compilation
-- [`KT-42791`](https://youtrack.jetbrains.com/issue/KT-42791) OutOfMemoryError on compilation using kotlin 1.4 on a class with a lot of type inference
-- [`KT-42920`](https://youtrack.jetbrains.com/issue/KT-42920) NI: Improve performance around adding constraints
-
-#### Fixes
-
-- [`KT-22465`](https://youtrack.jetbrains.com/issue/KT-22465) Excessive synthetic method for private setter from superclass
-- [`KT-26229`](https://youtrack.jetbrains.com/issue/KT-26229) Lambda/anonymous function argument in parentheses is not supported for callsInPlace effect
-- [`KT-32228`](https://youtrack.jetbrains.com/issue/KT-32228) Inconsistent boxing/unboxing for inline classes when interface is specialized by object expression
-- [`KT-32450`](https://youtrack.jetbrains.com/issue/KT-32450) Inline class incorrectly gets re-wrapped when provided to a function
-- [`KT-35849`](https://youtrack.jetbrains.com/issue/KT-35849) Missing nullability assertion on lambda return value if expected type has generic return value type
-- [`KT-35902`](https://youtrack.jetbrains.com/issue/KT-35902) Kotlin generates a private parameterless constructor for constructors taking inline class arguments with default values
-- [`KT-36769`](https://youtrack.jetbrains.com/issue/KT-36769) JVM IR: Missing LVT entries for inline function (default) parameters at call site
-- [`KT-36982`](https://youtrack.jetbrains.com/issue/KT-36982) JVM IR: SAM adapter classes are generated as synthetic
-- [`KT-37007`](https://youtrack.jetbrains.com/issue/KT-37007) JVM IR: extraneous property accessors are generated in multifile facade for InlineOnly property
-- [`KT-37317`](https://youtrack.jetbrains.com/issue/KT-37317) [FIR] Add support of extension functions in postponed lambda completion
-- [`KT-38400`](https://youtrack.jetbrains.com/issue/KT-38400) FIR: interface abstract is preferred to Any method in super resolve
-- [`KT-38536`](https://youtrack.jetbrains.com/issue/KT-38536) JVM IR: bound adapted function references are not inlined
-- [`KT-38656`](https://youtrack.jetbrains.com/issue/KT-38656) FIR: determine overridden member visibility properly
-- [`KT-38901`](https://youtrack.jetbrains.com/issue/KT-38901) FIR: Make behavior of integer literals overflow consistent with FE 1.0
-- [`KT-39709`](https://youtrack.jetbrains.com/issue/KT-39709) [FIR] False positive UNINITIALIZED_VARIABLE in presence of complex graph with jumps
-- [`KT-39923`](https://youtrack.jetbrains.com/issue/KT-39923) Result.Failure will get wrapped with Success when using with RxJava
-- [`KT-40198`](https://youtrack.jetbrains.com/issue/KT-40198) '$default' methods in 'kotlin/test/AssertionsKt' generated as non-synthetic by JVM_IR
-- [`KT-40262`](https://youtrack.jetbrains.com/issue/KT-40262) ACC_DEPRECATED flag not generated for property getter delegate in multifile class facade in JVM_IR
-- [`KT-40282`](https://youtrack.jetbrains.com/issue/KT-40282) Inline class wrapping Any gets double boxed
-- [`KT-40464`](https://youtrack.jetbrains.com/issue/KT-40464) JVM_IR does not generate LINENUMBER at closing brace of (suspend) lambda
-- [`KT-40948`](https://youtrack.jetbrains.com/issue/KT-40948) IllegalAccessError while initializing val property in EXACTLY_ONCE lambda that is passed to another function
-- [`KT-41468`](https://youtrack.jetbrains.com/issue/KT-41468) JVM IR: IllegalAccessError on access to abstract base member from another package, from anonymous object inside abstract class
-- [`KT-41493`](https://youtrack.jetbrains.com/issue/KT-41493) JVM IR: names of classes for local delegated variables contain the variable name twice
-- [`KT-41792`](https://youtrack.jetbrains.com/issue/KT-41792) [FIR] Introduce & use ConeAttribute.UnsafeVariance
-- [`KT-41793`](https://youtrack.jetbrains.com/issue/KT-41793) [FIR] Make captured types accessible at the end of resolve
-- [`KT-41809`](https://youtrack.jetbrains.com/issue/KT-41809) JVM IR: name for internal $default method doesn't include module name
-- [`KT-41810`](https://youtrack.jetbrains.com/issue/KT-41810) JVM IR: Deprecated(HIDDEN) class is incorrectly generated as synthetic
-- [`KT-41841`](https://youtrack.jetbrains.com/issue/KT-41841) JVM IR: delegates for private functions with default arguments are generated in multifile classes
-- [`KT-41857`](https://youtrack.jetbrains.com/issue/KT-41857) Flaky 'ConcurrentModificationException' through `kotlin.serialization.DescriptorSerializer`
-- [`KT-41903`](https://youtrack.jetbrains.com/issue/KT-41903) JVM IR: do not generate LineNumberTable in auto-generated members of data classes
-- [`KT-41957`](https://youtrack.jetbrains.com/issue/KT-41957) JVM IR: step into suspend function goes to the first line of the file
-- [`KT-41960`](https://youtrack.jetbrains.com/issue/KT-41960) JVM IR: smart step into members implemented with delegation to interface doesn't work
-- [`KT-41961`](https://youtrack.jetbrains.com/issue/KT-41961) JVM IR: line numbers are not generated in JvmMultifileClass facade declarations
-- [`KT-41962`](https://youtrack.jetbrains.com/issue/KT-41962) JVM IR: intermittent -1 line numbers in the state machine cause double stepping in the debugger
-- [`KT-42002`](https://youtrack.jetbrains.com/issue/KT-42002) JVM / IR: IllegalStateException: "No mapping for symbol: VAR IR_TEMPORARY_VARIABLE" caused by named arguments
-- [`KT-42021`](https://youtrack.jetbrains.com/issue/KT-42021) JVM / IR: "IndexOutOfBoundsException: Index 0 out of bounds for length 0" during IR lowering with suspend conversion
-- [`KT-42033`](https://youtrack.jetbrains.com/issue/KT-42033) JVM IR: accidental override in Map subclass with custom implementations of some members
-- [`KT-42043`](https://youtrack.jetbrains.com/issue/KT-42043) JVM IR: Don't generate collection stubs when implementing methods with more specific return types
-- [`KT-42044`](https://youtrack.jetbrains.com/issue/KT-42044) Compiler error when lambda with contract surrounded with parentheses
-- [`KT-42114`](https://youtrack.jetbrains.com/issue/KT-42114) JVM_IR generates stub for 'removeIf' in abstract classes implementing 'List' and 'Set'
-- [`KT-42115`](https://youtrack.jetbrains.com/issue/KT-42115) JVM_IR doesn't generate 'next' and 'hasNext' method in an abstract class implementing 'ListIterator'
-- [`KT-42116`](https://youtrack.jetbrains.com/issue/KT-42116) FIR: Java accessor function should not exist in scope together with relevant property
-- [`KT-42117`](https://youtrack.jetbrains.com/issue/KT-42117) IR-based evaluator cannot handle Java static final fields
-- [`KT-42118`](https://youtrack.jetbrains.com/issue/KT-42118) FIR2IR: field-targeted annotation is placed on a property, not on a field
-- [`KT-42130`](https://youtrack.jetbrains.com/issue/KT-42130) FIR: type variable is observed after when condition analysis
-- [`KT-42132`](https://youtrack.jetbrains.com/issue/KT-42132) FIR2IR: companion function reference has no dispatch receiver
-- [`KT-42137`](https://youtrack.jetbrains.com/issue/KT-42137) JVM IR: AbstractMethodError on complex hierarchy where implementation comes from another supertype and has a more specific type
-- [`KT-42186`](https://youtrack.jetbrains.com/issue/KT-42186) JVM / IR: Infinite cycle in for expression when unsigned bytes are used in decreasing loop range
-- [`KT-42251`](https://youtrack.jetbrains.com/issue/KT-42251) JVM / IR: "IllegalStateException: Descriptor can be left only if it is last" when comparing the i-th element of the container of Int? and `i` with change
-- [`KT-42253`](https://youtrack.jetbrains.com/issue/KT-42253) JVM IR: NoSuchFieldError on local delegated property in inline function whose call site happens before declaration in the source
-- [`KT-42281`](https://youtrack.jetbrains.com/issue/KT-42281) JVM / IR: AnalyzerException when comparing Int and array that cast to Any in if condition
-- [`KT-42340`](https://youtrack.jetbrains.com/issue/KT-42340) FIR2IR: duplicating fake overrides
-- [`KT-42344`](https://youtrack.jetbrains.com/issue/KT-42344) IR-based evaluator doesn't support "annotation in annotation"
-- [`KT-42346`](https://youtrack.jetbrains.com/issue/KT-42346) FIR: double-vararg in IR while resolving collection literal as Java annotation argument
-- [`KT-42348`](https://youtrack.jetbrains.com/issue/KT-42348) FIR: false UNINITIALIZED_VARIABLE in local class
-- [`KT-42350`](https://youtrack.jetbrains.com/issue/KT-42350) FIR: false UNINITIALIZED_VARIABLE after initialization in try block
-- [`KT-42351`](https://youtrack.jetbrains.com/issue/KT-42351) FIR: false HIDDEN in enum entry member call
-- [`KT-42354`](https://youtrack.jetbrains.com/issue/KT-42354) JVM / IR: "AssertionError: Unexpected IR element found during code generation" with KProperty `get` invocation
-- [`KT-42359`](https://youtrack.jetbrains.com/issue/KT-42359) FIR2IR: cannot mangle type parameter
-- [`KT-42373`](https://youtrack.jetbrains.com/issue/KT-42373) FIR2IR: local object nested class has no parent if forward-referenced by nested class supertype
-- [`KT-42384`](https://youtrack.jetbrains.com/issue/KT-42384) FIR (BE): top-level field has no parent class in BE
-- [`KT-42496`](https://youtrack.jetbrains.com/issue/KT-42496) FIR resolve: synthetic property is written but has no setter
-- [`KT-42517`](https://youtrack.jetbrains.com/issue/KT-42517) FIR: exception in BE for recursive inline call
-- [`KT-42601`](https://youtrack.jetbrains.com/issue/KT-42601) [FIR] Inherited declaration clash for stdlib inheritors
-- [`KT-42642`](https://youtrack.jetbrains.com/issue/KT-42642) ISE: No `getProgressionLastElement` for progression type IntProgressionType
-- [`KT-42650`](https://youtrack.jetbrains.com/issue/KT-42650) JVM IR: extraneous nullability annotation on a generic function of a flexible type
-- [`KT-42656`](https://youtrack.jetbrains.com/issue/KT-42656) FIR2IR: unsupported callable reference for Java field
-- [`KT-42725`](https://youtrack.jetbrains.com/issue/KT-42725) Debugger steps into core library inline functions in chained calls
-- [`KT-42758`](https://youtrack.jetbrains.com/issue/KT-42758) JVM / IR: Deserialized object that overrides readResolve() is not reference equal to the singleton instance
-- [`KT-42770`](https://youtrack.jetbrains.com/issue/KT-42770) FIR: duplicating signatures in mangler (typealias for functional type)
-- [`KT-42771`](https://youtrack.jetbrains.com/issue/KT-42771) FIR: duplicating signature in mangler (data class with delegate)
-- [`KT-42814`](https://youtrack.jetbrains.com/issue/KT-42814) FIR: false UNINITIALIZED_VARIABLE in local function after if...else
-- [`KT-42844`](https://youtrack.jetbrains.com/issue/KT-42844) FIR: Property write in init block resolved to parameter write
-- [`KT-42846`](https://youtrack.jetbrains.com/issue/KT-42846) JVM_IR: NPE on function reference to @JvmStatic method in a different file
-- [`KT-42933`](https://youtrack.jetbrains.com/issue/KT-42933) JVM / IR: "AnalyzerException: Expected an object reference, but found I" with local delegate in inline class
-- [`KT-43006`](https://youtrack.jetbrains.com/issue/KT-43006) JVM/JVM_IR: do not generate no-arg constructor for constructor with default arguments if there are inline class types in the signature
-- [`KT-43017`](https://youtrack.jetbrains.com/issue/KT-43017) JVM / IR: AssertionError when callable reference passed into a function requiring a suspendable function
-- [`KT-43068`](https://youtrack.jetbrains.com/issue/KT-43068) JVM IR: no generic signatures for explicitly written methods in a List subclass, whose signature coincides with MutableList methods
-- [`KT-43132`](https://youtrack.jetbrains.com/issue/KT-43132) JVM / IR: Method name '<get-...>' in class '...$screenTexts$1$1' cannot be represented in dex format.
-- [`KT-43145`](https://youtrack.jetbrains.com/issue/KT-43145) JVM IR: $default methods in multi-file facades are generated as non-synthetic final
-- [`KT-43156`](https://youtrack.jetbrains.com/issue/KT-43156) FIR: false UNINITIALIZED_VARIABLE after initialization in `synchronized` block
-- [`KT-43196`](https://youtrack.jetbrains.com/issue/KT-43196) JVM: extra non-static member is generated for extension property in inline class
-- [`KT-43199`](https://youtrack.jetbrains.com/issue/KT-43199) JVM IR: synthetic flag for deprecated-hidden is not generated for DeprecatedSinceKotlin and deprecation from override
-- [`KT-43207`](https://youtrack.jetbrains.com/issue/KT-43207) JVM IR: no collection stub for `iterator` is generated on extending AbstractCollection
-- [`KT-43217`](https://youtrack.jetbrains.com/issue/KT-43217) JVM_IR: Multiple FAKE_OVERRIDES for java methods using @NonNull Double and java double
-- [`KT-43226`](https://youtrack.jetbrains.com/issue/KT-43226) "Incompatible stack heights" with non-local return to outer lambda inside suspend lambda
-- [`KT-43242`](https://youtrack.jetbrains.com/issue/KT-43242) JVM / IR: "AnalyzerException: Expected I, but found R" caused by `when` inside object with @Nullable Integer subject
-- [`KT-43249`](https://youtrack.jetbrains.com/issue/KT-43249) Wrong code generated for suspend lambdas with inline class parameters
-- [`KT-43286`](https://youtrack.jetbrains.com/issue/KT-43286) JVM IR: IAE "Inline class types should have the same representation: Lkotlin/UInt; != I" on smart cast of unsigned type value with JVM target 1.8
-- [`KT-43326`](https://youtrack.jetbrains.com/issue/KT-43326) JVM_IR: No deprecated flag for getter of deprecated interface property copied to DefaultImpls
-- [`KT-43327`](https://youtrack.jetbrains.com/issue/KT-43327) JVM_IR: No deprecated or synthetic flag for accessors of deprecated-hidden property of unsigned type
-- [`KT-43332`](https://youtrack.jetbrains.com/issue/KT-43332) FIR: Smart casts lead to false-positive ambiguity
-- [`KT-43370`](https://youtrack.jetbrains.com/issue/KT-43370) JVM IR: No deprecated flag for getter of deprecated property copied via delegation by interface
-- [`KT-43525`](https://youtrack.jetbrains.com/issue/KT-43525) Prohibit JvmOverloads on declarations with inline class types in parameters
-- [`KT-43562`](https://youtrack.jetbrains.com/issue/KT-43562) JVM IR: incorrect mangling for Collection.size in unsigned arrays
-- [`KT-43584`](https://youtrack.jetbrains.com/issue/KT-43584) [FIR] Java annotations with named arguments aren't loaded correctly
-
-### IDE
-
-- [`KT-31553`](https://youtrack.jetbrains.com/issue/KT-31553) Complete Statement: Wrong auto-insertion of closing curly brace for a code block
-- [`KT-33466`](https://youtrack.jetbrains.com/issue/KT-33466) IDE generates incorrect `external override` with body for overriding `open external` method
-- [`KT-39458`](https://youtrack.jetbrains.com/issue/KT-39458) Add CLI support for UL classes
-- [`KT-40403`](https://youtrack.jetbrains.com/issue/KT-40403) UAST: PsiMethod for invoked extension function/property misses `@receiver:` annotations
-- [`KT-41406`](https://youtrack.jetbrains.com/issue/KT-41406) Kotlin doesn't report annotations for type arguments (no way to add `@Nls`, `@NonNls` annotations to String collections in Kotlin)
-- [`KT-41420`](https://youtrack.jetbrains.com/issue/KT-41420) UAST does not return information about type annotations
-- [`KT-42754`](https://youtrack.jetbrains.com/issue/KT-42754) MPP: no smart cast for Common nullable property used in platform module
-- [`KT-42821`](https://youtrack.jetbrains.com/issue/KT-42821) MPP, IDE: Platform-specific errors are reported even when build doesn't target that platform
-
-### IDE. Android
-
-- [`KT-42381`](https://youtrack.jetbrains.com/issue/KT-42381) MPP: Bad IDEA dependencies: JVM module depending on built artifact instead of sources of module with Android Plugin applied
-
-### IDE. Inspections and Intentions
-
-#### New Features
-
-- [`KT-22666`](https://youtrack.jetbrains.com/issue/KT-22666) "Create enum constant" quick fix could be provided
-- [`KT-24556`](https://youtrack.jetbrains.com/issue/KT-24556) Add Remove quick fix for "Expression under 'when' is never equal to null"
-- [`KT-34121`](https://youtrack.jetbrains.com/issue/KT-34121) Report unused result of data class `copy` method
-- [`KT-34533`](https://youtrack.jetbrains.com/issue/KT-34533) INLINE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER: Add quickfix "Add val to parameter"
-- [`KT-35215`](https://youtrack.jetbrains.com/issue/KT-35215) Quickfix for CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT to remove `const` modifier
-- [`KT-40251`](https://youtrack.jetbrains.com/issue/KT-40251) Intention action to evaluate compile time expression
-
-#### Fixes
-
-- [`KT-20420`](https://youtrack.jetbrains.com/issue/KT-20420) Intention "Put arguments/parameters on separate lines" doesn't respect the "Place ')' on new line" Kotlin code style setting
-- [`KT-21799`](https://youtrack.jetbrains.com/issue/KT-21799) Quickfix "Change function signature" for receiver type doesn't change it
-- [`KT-22665`](https://youtrack.jetbrains.com/issue/KT-22665) "Create object" quick fix produce wrong code for enum
-- [`KT-23934`](https://youtrack.jetbrains.com/issue/KT-23934) IntelliJ suggest "merge map to joinToString" even when such action is impossible due to suspending actions in map
-- [`KT-30894`](https://youtrack.jetbrains.com/issue/KT-30894) Wrong results of intention "Add names to call arguments" when backticked argument starts from digit
-- [`KT-31523`](https://youtrack.jetbrains.com/issue/KT-31523) ReplaceWith introduces additional argument name for lambda when named argument is used on call-site
-- [`KT-31833`](https://youtrack.jetbrains.com/issue/KT-31833) JavaMapForEachInspection should report for expression with implicit receiver
-- [`KT-33096`](https://youtrack.jetbrains.com/issue/KT-33096) Turn 'MapGetWithNotNullAssertionOperator' into an intention
-- [`KT-33212`](https://youtrack.jetbrains.com/issue/KT-33212) False positive "map.put() should be converted to assignment" inspection when class inherited from MutableMap has "set" method
-- [`KT-34270`](https://youtrack.jetbrains.com/issue/KT-34270) False negative "Join declaration and assignment" with constructor call
-- [`KT-34859`](https://youtrack.jetbrains.com/issue/KT-34859) False positive "Should be replaced with Kotlin function" inspection for Character.toString(int) function
-- [`KT-34959`](https://youtrack.jetbrains.com/issue/KT-34959) False positive "Redundant overriding method" with different implemented/overridden signatures
-- [`KT-35051`](https://youtrack.jetbrains.com/issue/KT-35051) False positive "Remove redundant backticks" if variable inside the string and isn't followed by space
-- [`KT-35097`](https://youtrack.jetbrains.com/issue/KT-35097) False positive "Call replaceable with binary operator" on explicit 'equals' call on a platform type value
-- [`KT-35165`](https://youtrack.jetbrains.com/issue/KT-35165) "Replace 'if' with elvis operator": don't suggest if val initializer is a complex expression
-- [`KT-35346`](https://youtrack.jetbrains.com/issue/KT-35346) False positive 'Make internal' suggestion for function inside interface
-- [`KT-35357`](https://youtrack.jetbrains.com/issue/KT-35357) "Move lambda argument out of parentheses" does not preserve block comments
-- [`KT-38349`](https://youtrack.jetbrains.com/issue/KT-38349) Invalid suggestion to fold to elvis when having a var-variable
-- [`KT-40704`](https://youtrack.jetbrains.com/issue/KT-40704) False negative "Redundant semicolon" at start of line
-- [`KT-40861`](https://youtrack.jetbrains.com/issue/KT-40861) "Convert to secondary constructor" intention expected on class name
-- [`KT-40879`](https://youtrack.jetbrains.com/issue/KT-40879) False positive "Redundant 'inner' modifier" when calling another inner class with empty constructor
-- [`KT-40985`](https://youtrack.jetbrains.com/issue/KT-40985) "Remove explicit type arguments" is suggested when type has an annotation
-- [`KT-41223`](https://youtrack.jetbrains.com/issue/KT-41223) False positive "Redundant inner modifier" inspection ignores constructor arguments of object expressions
-- [`KT-41246`](https://youtrack.jetbrains.com/issue/KT-41246) False positive "Receiver parameter is never used" with anonymous function expression
-- [`KT-41298`](https://youtrack.jetbrains.com/issue/KT-41298) "Remove redundant 'with' call" intention works incorrectly with non-local returns and single-expression functions
-- [`KT-41311`](https://youtrack.jetbrains.com/issue/KT-41311) False positive "Redundant inner modifier" when deriving from a nested Java class
-- [`KT-41499`](https://youtrack.jetbrains.com/issue/KT-41499) "Convert receiver to parameter" produces code with incorrect order of generic type and function invocation  in case of generic function with lambda as a parameter
-- [`KT-41680`](https://youtrack.jetbrains.com/issue/KT-41680) False positive "Redundant inner modifier" when deriving from class with non-empty constructor and value passed to it from enclosing class
-- [`KT-42201`](https://youtrack.jetbrains.com/issue/KT-42201) Add Opt-In action doesn't work if there is already OptIn annotation
-- [`KT-42255`](https://youtrack.jetbrains.com/issue/KT-42255) "Replace elvis expression with 'if' expression" intention shouldn't introduce unnecessary variable if 'error' expression is used
-
-### IDE. JS
-
-- [`KT-43760`](https://youtrack.jetbrains.com/issue/KT-43760) KJS: Debugging Kotlin code for Node.js runtime doesn't work
-
-### IDE. Scratch
-
-- [`KT-43415`](https://youtrack.jetbrains.com/issue/KT-43415) Kotlin scratch file could not be run and could lead to dead lock
-
-### JavaScript
-
-#### Fixes
-
-- [`KT-31072`](https://youtrack.jetbrains.com/issue/KT-31072) Don't use non-reified arguments to specialize type operations in IR inliner
-- [`KT-39964`](https://youtrack.jetbrains.com/issue/KT-39964) Throwable incorrectly implements constructor for (null, cause) args in K/JS-IR
-- [`KT-40090`](https://youtrack.jetbrains.com/issue/KT-40090) KJS: IR. Invalid behaviour for optional parameters (redundant tail undefined parameters)
-- [`KT-40686`](https://youtrack.jetbrains.com/issue/KT-40686) KJS: Uncaught ReferenceError caused by external class as type inside eventListener in init block
-- [`KT-40771`](https://youtrack.jetbrains.com/issue/KT-40771) KJS / IR: "ReferenceError: Metadata is not defined" caused by default parameter value in inner class constructor
-- [`KT-41032`](https://youtrack.jetbrains.com/issue/KT-41032) KJS / IR: "AssertionError: Assertion failed" caused by class that is delegated to inherited interface
-- [`KT-41771`](https://youtrack.jetbrains.com/issue/KT-41771) KJS / IR: IndexOutOfBoundsException "Index 0 out of bounds for length 0" caused by inline class with List in primary constructor and vararg in secondary
-- [`KT-42025`](https://youtrack.jetbrains.com/issue/KT-42025) KJS / IR:  IrConstructorCallImpl: No such type argument slot: 0
-- [`KT-42112`](https://youtrack.jetbrains.com/issue/KT-42112) KJS: StackOverflowError on @JsExport in case of name clash with function with Enum parameter with star-projection
-- [`KT-42262`](https://youtrack.jetbrains.com/issue/KT-42262) KJS: `break`-statements without label are ignored in a `when`
-- [`KT-42364`](https://youtrack.jetbrains.com/issue/KT-42364) KJS: Properties of interface delegate are non-configurable
-- [`KT-43222`](https://youtrack.jetbrains.com/issue/KT-43222) KJS IR: prototype lazy initialization for top-level properties like in JVM
-- [`KT-43313`](https://youtrack.jetbrains.com/issue/KT-43313) KJS / IR: "Can't find name for declaration FUN" for secondary constructor
-
-### KMM Plugin
-
-- [`KT-41677`](https://youtrack.jetbrains.com/issue/KT-41677) Could not launch iOS project with custom display name
-- [`KT-42463`](https://youtrack.jetbrains.com/issue/KT-42463) Launch common tests on local JVM via run gutter
-- [`KT-43188`](https://youtrack.jetbrains.com/issue/KT-43188) NoSuchMethodError in New Module Wizard of KMM Project
-
-### Libraries
-
-- [`KT-41112`](https://youtrack.jetbrains.com/issue/KT-41112) Docs: add more details about bit shift operations
-- [`KT-41356`](https://youtrack.jetbrains.com/issue/KT-41356) Incorrect documentation for `rangeTo` function
-
-### Middle-end. IR
-
-- [`KT-41765`](https://youtrack.jetbrains.com/issue/KT-41765) [Native/IR]  Could not resolveFakeOverride()
-- [`KT-42054`](https://youtrack.jetbrains.com/issue/KT-42054) Psi2ir: "RuntimeException: IrSimpleFunctionSymbolImpl is already bound" when using result of function with overload resolution by lambda return type
-
-### Native
-
-- [`KT-42822`](https://youtrack.jetbrains.com/issue/KT-42822) Kotlin/Native Worker leaks ObjC/Swift autorelease references (and indirectly bridged K/N references) on Darwin targets
-- [`KT-42397`](https://youtrack.jetbrains.com/issue/KT-42397) Reverse C interop usage of companion object reports spurious leaks
-
-### Native. C and ObjC Import
-
-- [`KT-42412`](https://youtrack.jetbrains.com/issue/KT-42412) [C-interop] Modality of generated property accessors is always FINAL
-
-### Native. ObjC Export
-
-- [`KT-38530`](https://youtrack.jetbrains.com/issue/KT-38530) Native: values() method of enum classes is not exposed to Objective-C/Swift
-
-### Native. Platform libraries
-
-- [`KT-43597`](https://youtrack.jetbrains.com/issue/KT-43597) Support for Xcode 12.2 SDK
-
-### Native. Platforms
-
-- [`KT-43276`](https://youtrack.jetbrains.com/issue/KT-43276) Support watchos_x64 target
-
-### Native. Runtime
-
-- [`KT-42822`](https://youtrack.jetbrains.com/issue/KT-42822) Kotlin/Native Worker leaks ObjC/Swift autorelease references (and indirectly bridged K/N references) on Darwin targets
-
-### Native. Stdlib
-
-- [`KT-42428`](https://youtrack.jetbrains.com/issue/KT-42428) Inconsistent behavior of map.entries on Kotlin.Native
-
-### Reflection
-
-- [`KT-34024`](https://youtrack.jetbrains.com/issue/KT-34024) "KotlinReflectionInternalError: Inconsistent number of parameters" with `javaMethod` on suspending functions with inline class in function signature or inside the function
-
-### Tools. CLI
-
-- [`KT-43406`](https://youtrack.jetbrains.com/issue/KT-43406) JVM: produce deterministic jar files if -d option value is a .jar file
-
-### Tools. CLI. Native
-
-- [`KT-40670`](https://youtrack.jetbrains.com/issue/KT-40670) Allow to override konan.properties via CLI
-
-### Tools. Compiler Plugins
-
-- [`KT-41764`](https://youtrack.jetbrains.com/issue/KT-41764) KJS /IR IllegalStateException: "Symbol for public kotlin/arrayOf is unbound" with serialization plugin
-- [`KT-42976`](https://youtrack.jetbrains.com/issue/KT-42976) kotlinx.serialization + JVM IR: NPE on annotation with @SerialInfo
-
-### Tools. Gradle
-
-- [`KT-38692`](https://youtrack.jetbrains.com/issue/KT-38692) KaptGenerateStubs Gradle task will not clean up outputs when sources are empty and not an incremental build
-- [`KT-40140`](https://youtrack.jetbrains.com/issue/KT-40140) kotlin-android plugin eagerly creates several Gradle tasks
-- [`KT-41295`](https://youtrack.jetbrains.com/issue/KT-41295) Kotlin Gradle Plugin 1.4.20 Configuration Caching bug due to friendPath provider
-- [`KT-42058`](https://youtrack.jetbrains.com/issue/KT-42058) Support moduleName option in Kotlin Gradle plugin for JVM
-- [`KT-43054`](https://youtrack.jetbrains.com/issue/KT-43054) Implementation of `AbstractKotlinTarget#buildAdhocComponentsFromKotlinVariants` breaks configuration caching
-- [`KT-43489`](https://youtrack.jetbrains.com/issue/KT-43489) Incremental compilation - unable to find history files causing full recompilation
-
-### Tools. Gradle. JS
-
-- [`KT-42400`](https://youtrack.jetbrains.com/issue/KT-42400) Kotlin/JS: Gradle DSL: customField() is rejected in Groovy build.gradle
-- [`KT-42462`](https://youtrack.jetbrains.com/issue/KT-42462) NPM dependency declaration with Groovy interpolated string
-- [`KT-42954`](https://youtrack.jetbrains.com/issue/KT-42954) Kotlin/JS: IDE import after changing `kotlin.js.externals.output.format` does not re-generate externals
-- [`KT-43535`](https://youtrack.jetbrains.com/issue/KT-43535) Common webpack configuration breaks on lambda serialization in some cases
-
-### Tools. Gradle. Multiplatform
-
-- [`KT-42269`](https://youtrack.jetbrains.com/issue/KT-42269) Setup default dependsOn edges for Android source sets
-- [`KT-42413`](https://youtrack.jetbrains.com/issue/KT-42413) [MPP/gradle] `withJava` breaks build on 1.4.20-M1
-- [`KT-43141`](https://youtrack.jetbrains.com/issue/KT-43141) Gradle / Configuration cache: NPE from org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon.getKotlinOptions() on reusing configuration cache for task compileCommonMainKotlinMetadata
-- [`KT-43329`](https://youtrack.jetbrains.com/issue/KT-43329) Gradle / Configuration cache: IAE “Parameter specified as non-null is null: method KotlinMetadataTargetConfiguratorKt.isCompatibilityMetadataVariantEnabled, parameter $this$isCompatibilityMetadataVariantEnabled” on reusing configuration cache for task compileKotlinMetadata
-
-### Tools. Gradle. Native
-
-- [`KT-39564`](https://youtrack.jetbrains.com/issue/KT-39564) Make kotlin-native Gradle tasks Cacheable
-- [`KT-42485`](https://youtrack.jetbrains.com/issue/KT-42485) Fail on cinterop: clang_indexTranslationUnit returned 1
-- [`KT-42550`](https://youtrack.jetbrains.com/issue/KT-42550) Adding subspec dependency with git location failed
-- [`KT-42849`](https://youtrack.jetbrains.com/issue/KT-42849) Gradle / Configuration cache: tasks nativeMetadataJar, runReleaseExecutableNative, runDebugExecutableNative are unsupported and fails on reusing configuration cache
-- [`KT-42938`](https://youtrack.jetbrains.com/issue/KT-42938) CocoaPods Gradle plugin: podBuildDependencies doesn't properly report xcodebuild failures
-- [`KT-43151`](https://youtrack.jetbrains.com/issue/KT-43151) Gradle / Configuration cache: UPAE “lateinit property binary has not been initialized” on reusing configuration cache for linkDebugExecutableNative, linkDebugTestNative, linkReleaseExecutableNative tasks
-- [`KT-40999`](https://youtrack.jetbrains.com/issue/KT-40999) CocoaPods Gradle plugin: Support custom cinterop options when declaring a pod dependency.
-
-### Tools. Parcelize
-
-- [`KT-41553`](https://youtrack.jetbrains.com/issue/KT-41553) JVM IR, Parcelize: IrStarProjectionImpl cannot be cast to class IrTypeProjection
-
-### Tools. kapt
-
-- [`KT-34340`](https://youtrack.jetbrains.com/issue/KT-34340) Incremental annotation processor recompile all files (only if KAPT enabled).
-- [`KT-36667`](https://youtrack.jetbrains.com/issue/KT-36667) Kapt: Add a flag to strip kotlin.Metadata() annotations from stubs
-- [`KT-40493`](https://youtrack.jetbrains.com/issue/KT-40493) KAPT does not support aggregating annotations processors in incremental mode
-- [`KT-40882`](https://youtrack.jetbrains.com/issue/KT-40882) Kapt stub generation is non-deterministic for incremental compilation
-- [`KT-41788`](https://youtrack.jetbrains.com/issue/KT-41788) NullPointerException: Random crashes of build using gradle and kapt because of not calling Processor.init()
-- [`KT-42182`](https://youtrack.jetbrains.com/issue/KT-42182) KAPT: Does not consider generated sources for incremental compilation.
-
-
 ## 1.4.20
 
 ### Android
@@ -2718,7 +2387,7 @@
 
 
 ## Recent ChangeLogs:
-### [ChangeLog-1.3.X](docs/changelogs/ChangeLog-1.3.X.md)
-### [ChangeLog-1.2.X](docs/changelogs/ChangeLog-1.2.X.md)
-### [ChangeLog-1.1.X](docs/changelogs/ChangeLog-1.1.X.md)
-### [ChangeLog-1.0.X](docs/changelogs/ChangeLog-1.0.X.md)
+### [ChangeLog-1.3.X](ChangeLog-1.3.X.md)
+### [ChangeLog-1.2.X](ChangeLog-1.2.X.md)
+### [ChangeLog-1.1.X](ChangeLog-1.1.X.md)
+### [ChangeLog-1.0.X](ChangeLog-1.0.X.md)

ReadMe.md

@@ -2,7 +2,6 @@
 [![TeamCity (simple build status)](https://img.shields.io/teamcity/http/teamcity.jetbrains.com/s/Kotlin_KotlinPublic_Compiler.svg)](https://teamcity.jetbrains.com/buildConfiguration/Kotlin_KotlinPublic_Compiler?branch=%3Cdefault%3E&buildTypeTab=overview&mode=builds)
 [![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlin/kotlin-maven-plugin.svg)](https://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.jetbrains.kotlin%22)
 [![GitHub license](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg?style=flat)](https://www.apache.org/licenses/LICENSE-2.0)
-[![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.jetbrains.com/scans?search.rootProjectNames=Kotlin)
 
 # Kotlin Programming Language
 

ant/src/org/jetbrains/kotlin/ant/Kotlin2JvmTask.kt

@@ -16,12 +16,9 @@
 
 package org.jetbrains.kotlin.ant
 
-import org.apache.tools.ant.BuildException
-import org.apache.tools.ant.taskdefs.Execute
-import org.apache.tools.ant.taskdefs.Redirector
-import org.apache.tools.ant.types.*
+import org.apache.tools.ant.types.Path
+import org.apache.tools.ant.types.Reference
 import java.io.File.pathSeparator
-import java.io.File.separator
 
 class Kotlin2JvmTask : KotlinCompilerBaseTask() {
     override val compilerFqName = "org.jetbrains.kotlin.cli.jvm.K2JVMCompiler"
@@ -31,9 +28,6 @@ class Kotlin2JvmTask : KotlinCompilerBaseTask() {
 
     var noReflect: Boolean = false
 
-    private val cmdl = CommandlineJava()
-    var fork: Boolean = false
-
     private var compileClasspath: Path? = null
 
     fun setClasspath(classpath: Path) {
@@ -79,47 +73,4 @@ class Kotlin2JvmTask : KotlinCompilerBaseTask() {
         if (noReflect) args.add("-no-reflect")
         if (includeRuntime) args.add("-include-runtime")
     }
-
-    override fun execute() {
-        if (!fork)
-            super.execute()
-        else {
-            exec()
-        }
-    }
-
-    private fun exec() {
-        val javaHome = System.getProperty("java.home")
-        val javaBin = javaHome + separator + "bin" + separator + "java"
-        val redirector = Redirector(this)
-
-        fillArguments()
-
-        val command = ArrayList<String>()
-        command.add(javaBin)
-        command.addAll(cmdl.vmCommand.arguments) // jvm args
-        command.add("-Dorg.jetbrains.kotlin.cliMessageRenderer=FullPath") // same MessageRenderer as non-forking mode
-        command.add("-cp")
-        command.add(KotlinAntTaskUtil.compilerJar.canonicalPath)
-        command.add(compilerFqName)
-        command.addAll(args) // compiler args
-
-        // streamHandler: used to handle the input and output streams of the subprocess.
-        // watchdog: a watchdog for the subprocess or <code>null</code> to disable a timeout for the subprocess.
-        // TODO: support timeout for the subprocess
-        val exe = Execute(redirector.createHandler(), null)
-        exe.setAntRun(getProject())
-        exe.commandline = command.toTypedArray()
-        log("Executing command: ${command.joinToString(" ")}", LogLevel.DEBUG.level)
-        log("Compiling ${src!!.list().toList()} => [${output!!.canonicalPath}]")
-        val exitCode = exe.execute()
-        redirector.complete()
-        if (failOnError && exitCode != 0) {
-            throw BuildException("Compile failed; see the compiler error output for details.")
-        }
-    }
-
-    fun createJvmarg(): Commandline.Argument {
-        return cmdl.createVmArgument()
-    }
 }

ant/src/org/jetbrains/kotlin/ant/KotlinCompilerBaseTask.kt

@@ -80,7 +80,7 @@ abstract class KotlinCompilerBaseTask : Task() {
         fillSpecificArguments()
     }
 
-    override fun execute() {
+    final override fun execute() {
         fillArguments()
 
         val compilerClass = KotlinAntTaskUtil.getOrCreateClassLoader().loadClass(compilerFqName)

build-common/src/org/jetbrains/kotlin/build/BuildMetaInfo.kt

@@ -17,6 +17,9 @@ interface BuildMetaInfo {
     val compilerBuildVersion: String
     val languageVersionString: String
     val apiVersionString: String
+    val coroutinesEnable: Boolean
+    val coroutinesWarn: Boolean
+    val coroutinesError: Boolean
     val multiplatformEnable: Boolean
     val metadataVersionMajor: Int
     val metadataVersionMinor: Int
@@ -32,6 +35,9 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
         compilerBuildVersion: String,
         languageVersionString: String,
         apiVersionString: String,
+        coroutinesEnable: Boolean,
+        coroutinesWarn: Boolean,
+        coroutinesError: Boolean,
         multiplatformEnable: Boolean,
         ownVersion: Int,
         coroutinesVersion: Int,
@@ -47,6 +53,9 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
             compilerBuildVersion = KotlinCompilerVersion.VERSION,
             languageVersionString = languageVersion.versionString,
             apiVersionString = args.apiVersion ?: languageVersion.versionString,
+            coroutinesEnable = args.coroutinesState == CommonCompilerArguments.ENABLE,
+            coroutinesWarn = args.coroutinesState == CommonCompilerArguments.WARN,
+            coroutinesError = args.coroutinesState == CommonCompilerArguments.ERROR,
             multiplatformEnable = args.multiPlatform,
             ownVersion = OWN_VERSION,
             coroutinesVersion = COROUTINES_VERSION,

build-common/src/org/jetbrains/kotlin/build/CommonBuildMetaInfo.kt

@@ -15,6 +15,9 @@ data class CommonBuildMetaInfo(
     override val compilerBuildVersion: String,
     override val languageVersionString: String,
     override val apiVersionString: String,
+    override val coroutinesEnable: Boolean,
+    override val coroutinesWarn: Boolean,
+    override val coroutinesError: Boolean,
     override val multiplatformEnable: Boolean,
     override val metadataVersionMajor: Int,
     override val metadataVersionMinor: Int,
@@ -29,6 +32,9 @@ data class CommonBuildMetaInfo(
             compilerBuildVersion: String,
             languageVersionString: String,
             apiVersionString: String,
+            coroutinesEnable: Boolean,
+            coroutinesWarn: Boolean,
+            coroutinesError: Boolean,
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
@@ -41,6 +47,9 @@ data class CommonBuildMetaInfo(
                 compilerBuildVersion = compilerBuildVersion,
                 languageVersionString = languageVersionString,
                 apiVersionString = apiVersionString,
+                coroutinesEnable = coroutinesEnable,
+                coroutinesWarn = coroutinesWarn,
+                coroutinesError = coroutinesError,
                 multiplatformEnable = multiplatformEnable,
                 metadataVersionMajor = metadataVersion.major,
                 metadataVersionMinor = metadataVersion.minor,

build-common/src/org/jetbrains/kotlin/build/JsBuildMetaInfo.kt

@@ -15,6 +15,9 @@ data class JsBuildMetaInfo(
     override val compilerBuildVersion: String,
     override val languageVersionString: String,
     override val apiVersionString: String,
+    override val coroutinesEnable: Boolean,
+    override val coroutinesWarn: Boolean,
+    override val coroutinesError: Boolean,
     override val multiplatformEnable: Boolean,
     override val metadataVersionMajor: Int,
     override val metadataVersionMinor: Int,
@@ -29,6 +32,9 @@ data class JsBuildMetaInfo(
             compilerBuildVersion: String,
             languageVersionString: String,
             apiVersionString: String,
+            coroutinesEnable: Boolean,
+            coroutinesWarn: Boolean,
+            coroutinesError: Boolean,
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
@@ -41,6 +47,9 @@ data class JsBuildMetaInfo(
                 compilerBuildVersion = compilerBuildVersion,
                 languageVersionString = languageVersionString,
                 apiVersionString = apiVersionString,
+                coroutinesEnable = coroutinesEnable,
+                coroutinesWarn = coroutinesWarn,
+                coroutinesError = coroutinesError,
                 multiplatformEnable = multiplatformEnable,
                 metadataVersionMajor = metadataVersion.major,
                 metadataVersionMinor = metadataVersion.minor,

build-common/src/org/jetbrains/kotlin/build/JvmBuildMetaInfo.kt

@@ -27,6 +27,9 @@ data class JvmBuildMetaInfo(
     override val compilerBuildVersion: String,
     override val languageVersionString: String,
     override val apiVersionString: String,
+    override val coroutinesEnable: Boolean,
+    override val coroutinesWarn: Boolean,
+    override val coroutinesError: Boolean,
     override val multiplatformEnable: Boolean,
     override val metadataVersionMajor: Int,
     override val metadataVersionMinor: Int,
@@ -44,6 +47,9 @@ data class JvmBuildMetaInfo(
             compilerBuildVersion: String,
             languageVersionString: String,
             apiVersionString: String,
+            coroutinesEnable: Boolean,
+            coroutinesWarn: Boolean,
+            coroutinesError: Boolean,
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
@@ -56,6 +62,9 @@ data class JvmBuildMetaInfo(
                 compilerBuildVersion = compilerBuildVersion,
                 languageVersionString = languageVersionString,
                 apiVersionString = apiVersionString,
+                coroutinesEnable = coroutinesEnable,
+                coroutinesWarn = coroutinesWarn,
+                coroutinesError = coroutinesError,
                 multiplatformEnable = multiplatformEnable,
                 metadataVersionMajor = metadataVersion.major,
                 metadataVersionMinor = metadataVersion.minor,

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

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.incremental
 import com.intellij.util.io.EnumeratorStringDescriptor
 import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.metadata.ProtoBuf
-import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
 import org.jetbrains.kotlin.metadata.deserialization.TypeTable
 import org.jetbrains.kotlin.metadata.deserialization.supertypes
@@ -35,15 +34,12 @@ interface IncrementalCacheCommon {
     val thisWithDependentCaches: Iterable<AbstractIncrementalCache<*>>
     fun classesFqNamesBySources(files: Iterable<File>): Collection<FqName>
     fun getSubtypesOf(className: FqName): Sequence<FqName>
-    fun getSupertypesOf(className: FqName): Sequence<FqName>
     fun getSourceFileIfClass(fqName: FqName): File?
     fun markDirty(removedAndCompiledSources: Collection<File>)
     fun clearCacheForRemovedClasses(changesCollector: ChangesCollector)
     fun getComplementaryFilesRecursive(dirtyFiles: Collection<File>): Collection<File>
     fun updateComplementaryFiles(dirtyFiles: Collection<File>, expectActualTracker: ExpectActualTrackerImpl)
     fun dump(): String
-
-    fun isSealed(className: FqName): Boolean?
 }
 
 /**
@@ -54,7 +50,6 @@ abstract class AbstractIncrementalCache<ClassName>(
     protected val pathConverter: FileToPathConverter
 ) : BasicMapsOwner(workingDir), IncrementalCacheCommon {
     companion object {
-        private val CLASS_ATTRIBUTES = "class-attributes"
         private val SUBTYPES = "subtypes"
         private val SUPERTYPES = "supertypes"
         private val CLASS_FQ_NAME_TO_SOURCE = "class-fq-name-to-source"
@@ -76,7 +71,6 @@ abstract class AbstractIncrementalCache<ClassName>(
         result
     }
 
-    internal val classAttributesMap = registerMap(ClassAttributesMap(CLASS_ATTRIBUTES.storageFile))
     private val subtypesMap = registerMap(SubtypesMap(SUBTYPES.storageFile))
     private val supertypesMap = registerMap(SupertypesMap(SUPERTYPES.storageFile))
     protected val classFqNameToSourceMap = registerMap(ClassFqNameToSourceMap(CLASS_FQ_NAME_TO_SOURCE.storageFile, pathConverter))
@@ -96,14 +90,6 @@ abstract class AbstractIncrementalCache<ClassName>(
     override fun getSubtypesOf(className: FqName): Sequence<FqName> =
         subtypesMap[className].asSequence()
 
-    override fun getSupertypesOf(className: FqName): Sequence<FqName> {
-        return supertypesMap[className].asSequence()
-    }
-
-    override fun isSealed(className: FqName): Boolean? {
-        return classAttributesMap[className]?.isSealed
-    }
-
     override fun getSourceFileIfClass(fqName: FqName): File? =
         classFqNameToSourceMap[fqName]
 
@@ -132,7 +118,6 @@ abstract class AbstractIncrementalCache<ClassName>(
 
         supertypesMap[child] = parents
         classFqNameToSourceMap[child] = srcFile
-        classAttributesMap[child] = ICClassesAttributes(ProtoBuf.Modality.SEALED == Flags.MODALITY.get(proto.flags))
     }
 
     protected fun removeAllFromClassStorage(removedClasses: Collection<FqName>, changesCollector: ChangesCollector) {
@@ -167,17 +152,14 @@ abstract class AbstractIncrementalCache<ClassName>(
             }
         }
 
-        removedFqNames.forEach {
-            classFqNameToSourceMap.remove(it)
-            classAttributesMap.remove(it)
-        }
+        removedFqNames.forEach { classFqNameToSourceMap.remove(it) }
     }
 
     protected class ClassFqNameToSourceMap(
         storageFile: File,
         private val pathConverter: FileToPathConverter
-    ) : BasicStringMap<String>(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) {
-
+    ) :
+        BasicStringMap<String>(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) {
         operator fun set(fqName: FqName, sourceFile: File) {
             storage[fqName.asString()] = pathConverter.toPath(sourceFile)
         }

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

@@ -19,14 +19,12 @@ package org.jetbrains.kotlin.incremental
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
-import org.jetbrains.kotlin.metadata.deserialization.supertypes
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 
 class ChangesCollector {
     private val removedMembers = hashMapOf<FqName, MutableSet<String>>()
-    private val changedParents = hashMapOf<FqName, MutableSet<FqName>>()
     private val changedMembers = hashMapOf<FqName, MutableSet<String>>()
     private val areSubclassesAffected = hashMapOf<FqName, Boolean>()
 
@@ -49,10 +47,6 @@ class ChangesCollector {
             changes.add(ChangeInfo.SignatureChanged(fqName, areSubclassesAffected))
         }
 
-        for ((fqName, changedParents) in changedParents) {
-            changes.add(ChangeInfo.ParentsChanged(fqName, changedParents))
-        }
-
         return changes
     }
 
@@ -85,12 +79,12 @@ class ChangesCollector {
         }
 
         if (oldData == null) {
-            newData!!.collectAll(isRemoved = false, isAdded = true, collectAllMembersForNewClass = collectAllMembersForNewClass)
+            newData!!.collectAll(isRemoved = false, collectAllMembersForNewClass = collectAllMembersForNewClass)
             return
         }
 
         if (newData == null) {
-            oldData.collectAll(isRemoved = true, isAdded = false)
+            oldData.collectAll(isRemoved = true)
             return
         }
 
@@ -104,7 +98,6 @@ class ChangesCollector {
                             collectSignature(oldData, diff.areSubclassesAffected)
                         }
                         collectChangedMembers(fqName, diff.changedMembersNames)
-                        addChangedParents(fqName, diff.changedSupertypes)
                     }
                     is PackagePartProtoData -> {
                         collectSignature(oldData, areSubclassesAffected = true)
@@ -128,11 +121,10 @@ class ChangesCollector {
     private fun <T> T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List<MessageLite>): Set<String> =
             members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet()
 
-    //TODO remember all sealed parent classes
-    private fun ProtoData.collectAll(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) =
+    private fun ProtoData.collectAll(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) =
         when (this) {
             is PackagePartProtoData -> collectAllFromPackage(isRemoved)
-            is ClassProtoData -> collectAllFromClass(isRemoved, isAdded, collectAllMembersForNewClass)
+            is ClassProtoData -> collectAllFromClass(isRemoved, collectAllMembersForNewClass)
         }
 
     private fun PackagePartProtoData.collectAllFromPackage(isRemoved: Boolean) {
@@ -151,7 +143,7 @@ class ChangesCollector {
         }
     }
 
-    private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) {
+    private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) {
         val classFqName = nameResolver.getClassId(proto.fqName).asSingleFqName()
         val kind = Flags.CLASS_KIND.get(proto.flags)
 
@@ -170,23 +162,6 @@ class ChangesCollector {
 
             collectSignature(classFqName, areSubclassesAffected = true)
         }
-
-        if (isRemoved || isAdded) {
-            collectChangedParents(classFqName, proto.supertypeList)
-        }
-    }
-
-    private fun addChangedParents(fqName: FqName, parents: Collection<FqName>) {
-        if (parents.isNotEmpty()) {
-            changedParents.getOrPut(fqName) { HashSet() }.addAll(parents)
-        }
-    }
-
-    private fun ClassProtoData.collectChangedParents(fqName: FqName, parents: Collection<ProtoBuf.Type>) {
-        val changedParentsFqNames = parents.map { type ->
-            nameResolver.getClassId(type.className).asSingleFqName()
-        }
-        addChangedParents(fqName, changedParentsFqNames)
     }
 
     private fun ClassProtoData.getNonPrivateMemberNames(): Set<String> {

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

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.name.parentOrNull
 import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
-import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
 import java.io.DataInput
 import java.io.DataOutput
 import java.io.File
@@ -327,7 +326,7 @@ private class ProtoDataProvider(private val serializerProtocol: SerializerExtens
         proto.`package`.apply {
             val packageNameId = getExtensionOrNull(serializerProtocol.packageFqName)
             val packageFqName = packageNameId?.let { FqName(nameResolver.getPackageFqName(it)) } ?: FqName.ROOT
-            val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalizeAsciiOnly() + "Kt"))
+            val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalize() + "Kt"))
             classes[packagePartClassId] = PackagePartProtoData(this, nameResolver, packageFqName)
         }
 
@@ -348,7 +347,7 @@ fun getProtoData(sourceFile: File, metadata: ByteArray): Map<ClassId, ProtoData>
 
     proto.`package`.apply {
         val packageFqName = getExtensionOrNull(JsProtoBuf.packageFqName)?.let(nameResolver::getPackageFqName)?.let(::FqName) ?: FqName.ROOT
-        val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalizeAsciiOnly() + "Kt"))
+        val packagePartClassId = ClassId(packageFqName, Name.identifier(sourceFile.nameWithoutExtension.capitalize() + "Kt"))
         classes[packagePartClassId] = PackagePartProtoData(this, nameResolver, packageFqName)
     }
 
@@ -413,4 +412,4 @@ private class PackageMetadataMap(storageFile: File) : BasicStringMap<ByteArray>(
     operator fun get(packageName: String) = storage[packageName]
 
     override fun dumpValue(value: ByteArray): String = "Package metadata: ${value.md5()}"
-}
+}

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

@@ -145,7 +145,6 @@ open class IncrementalJvmCache(
                 }
                 protoMap.remove(className, changesCollector)
                 classFqNameToSourceMap.remove(className.fqNameForClassNameWithoutDollars)
-                classAttributesMap.remove(className.fqNameForClassNameWithoutDollars)
                 internalNameToSource.remove(className.internalName)
 
                 // TODO NO_CHANGES? (delegates only)
@@ -272,7 +271,6 @@ open class IncrementalJvmCache(
 
     private inner class ProtoMap(storageFile: File) : BasicStringMap<ProtoMapValue>(storageFile, ProtoMapValueExternalizer) {
 
-        @Synchronized
         fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             return put(kotlinClass, changesCollector)
         }
@@ -284,12 +282,10 @@ open class IncrementalJvmCache(
         // from files compiled during last round.
         // However there is no need to compare old and new data in this case
         // (also that would fail with exception).
-        @Synchronized
         fun storeModuleMapping(className: JvmClassName, bytes: ByteArray) {
             storage[className.internalName] = ProtoMapValue(isPackageFacade = false, bytes = bytes, strings = emptyArray())
         }
 
-        @Synchronized
         private fun put(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             val header = kotlinClass.classHeader
 
@@ -312,7 +308,6 @@ open class IncrementalJvmCache(
         operator fun get(className: JvmClassName): ProtoMapValue? =
             storage[className.internalName]
 
-        @Synchronized
         fun remove(className: JvmClassName, changesCollector: ChangesCollector) {
             val key = className.internalName
             val oldValue = storage[key] ?: return
@@ -329,8 +324,6 @@ open class IncrementalJvmCache(
 
     private inner class JavaSourcesProtoMap(storageFile: File) :
         BasicStringMap<SerializedJavaClass>(storageFile, JavaClassProtoMapValueExternalizer) {
-
-        @Synchronized
         fun process(jvmClassName: JvmClassName, newData: SerializedJavaClass, changesCollector: ChangesCollector) {
             val key = jvmClassName.internalName
             val oldData = storage[key]
@@ -342,7 +335,6 @@ open class IncrementalJvmCache(
             )
         }
 
-        @Synchronized
         fun remove(className: JvmClassName, changesCollector: ChangesCollector) {
             val key = className.internalName
             val oldValue = storage[key] ?: return
@@ -382,7 +374,6 @@ open class IncrementalJvmCache(
         operator fun contains(className: JvmClassName): Boolean =
             className.internalName in storage
 
-        @Synchronized
         fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             val key = kotlinClass.className.internalName
             val oldMap = storage[key] ?: emptyMap()
@@ -399,7 +390,6 @@ open class IncrementalJvmCache(
             }
         }
 
-        @Synchronized
         fun remove(className: JvmClassName) {
             storage.remove(className.internalName)
         }
@@ -532,7 +522,6 @@ open class IncrementalJvmCache(
             return result
         }
 
-        @Synchronized
         fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) {
             val key = kotlinClass.className.internalName
             val oldMap = storage[key] ?: emptyMap()
@@ -558,7 +547,6 @@ open class IncrementalJvmCache(
         private fun functionNameBySignature(signature: String): String =
             signature.substringBefore("(")
 
-        @Synchronized
         fun remove(className: JvmClassName) {
             storage.remove(className.internalName)
         }
@@ -580,7 +568,6 @@ sealed class ChangeInfo(val fqName: FqName) {
 
     class SignatureChanged(fqName: FqName, val areSubclassesAffected: Boolean) : ChangeInfo(fqName)
 
-    class ParentsChanged(fqName: FqName, val parentsChanged: Collection<FqName>) : ChangeInfo(fqName)
 
     protected open fun toStringProperties(): String = "fqName = $fqName"
 

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

@@ -17,18 +17,19 @@
 package org.jetbrains.kotlin.incremental
 
 import com.intellij.util.containers.MultiMap
+import com.intellij.util.containers.StringInterner
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.components.Position
 import org.jetbrains.kotlin.incremental.components.ScopeKind
 import org.jetbrains.kotlin.incremental.storage.*
 import org.jetbrains.kotlin.utils.Printer
-import org.jetbrains.kotlin.utils.createStringInterner
 import org.jetbrains.kotlin.utils.keysToMap
 import java.io.File
 import java.io.IOException
 import java.util.*
 
+
 open class LookupStorage(
     targetDataDir: File,
     pathConverter: FileToPathConverter
@@ -211,8 +212,8 @@ open class LookupStorage(
 
 class LookupTrackerImpl(private val delegate: LookupTracker) : LookupTracker {
     val lookups = MultiMap.createSet<LookupSymbol, String>()
-    val pathInterner = createStringInterner()
-    private val interner = createStringInterner()
+    val pathInterner = StringInterner()
+    private val interner = StringInterner()
 
     override val requiresPosition: Boolean
         get() = delegate.requiresPosition

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

@@ -136,8 +136,7 @@ fun LookupStorage.update(
 
 data class DirtyData(
     val dirtyLookupSymbols: Collection<LookupSymbol> = emptyList(),
-    val dirtyClassesFqNames: Collection<FqName> = emptyList(),
-    val dirtyClassesFqNamesForceRecompile: Collection<FqName> = emptyList()
+    val dirtyClassesFqNames: Collection<FqName> = emptyList()
 )
 
 fun ChangesCollector.getDirtyData(
@@ -147,9 +146,6 @@ fun ChangesCollector.getDirtyData(
     val dirtyLookupSymbols = HashSet<LookupSymbol>()
     val dirtyClassesFqNames = HashSet<FqName>()
 
-    val sealedParents = HashMap<FqName, MutableSet<FqName>>()
-    val notSealedParents = HashSet<FqName>()
-
     for (change in changes()) {
         reporter.reportVerbose { "Process $change" }
 
@@ -174,35 +170,10 @@ fun ChangesCollector.getDirtyData(
             }
 
             fqNames.mapTo(dirtyLookupSymbols) { LookupSymbol(SAM_LOOKUP_NAME.asString(), it.asString()) }
-        } else if (change is ChangeInfo.ParentsChanged) {
-            fun FqName.isSealed(): Boolean {
-                if (notSealedParents.contains(this)) return false
-                if (sealedParents.containsKey(this)) return true
-                return isSealed(this, caches).also { sealed ->
-                    if (sealed) {
-                        sealedParents[this] = HashSet()
-                    } else {
-                        notSealedParents.add(this)
-                    }
-                }
-            }
-            change.parentsChanged.forEach { parent ->
-                if (parent.isSealed()) {
-                    sealedParents.getOrPut(parent) { HashSet() }.add(change.fqName)
-                }
-            }
         }
     }
 
-    val forceRecompile = HashSet<FqName>().apply {
-        addAll(sealedParents.keys)
-        //we should recompile all inheritors with parent sealed class: add known subtypes
-        addAll(sealedParents.keys.flatMap { withSubtypes(it, caches) })
-        //we should recompile all inheritors with parent sealed class: add new subtypes
-        addAll(sealedParents.values.flatten())
-    }
-
-    return DirtyData(dirtyLookupSymbols, dirtyClassesFqNames, forceRecompile)
+    return DirtyData(dirtyLookupSymbols, dirtyClassesFqNames)
 }
 
 fun mapLookupSymbolsToFiles(
@@ -246,11 +217,6 @@ fun mapClassesFqNamesToFiles(
     return fqNameToAffectedFiles.values.flattenTo(HashSet())
 }
 
-fun isSealed(
-    fqName: FqName,
-    caches: Iterable<IncrementalCacheCommon>
-): Boolean = caches.any { it.isSealed(fqName) ?: false }
-
 fun withSubtypes(
     typeFqName: FqName,
     caches: Iterable<IncrementalCacheCommon>

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

@@ -28,14 +28,12 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
-import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import java.util.*
 
 data class Difference(
     val isClassAffected: Boolean = false,
     val areSubclassesAffected: Boolean = false,
-    val changedMembersNames: Set<String> = emptySet(),
-    val changedSupertypes: Set<FqName> = emptySet()
+    val changedMembersNames: Set<String> = emptySet()
 )
 
 sealed class ProtoData
@@ -189,7 +187,6 @@ class DifferenceCalculatorForClass(
 
         var isClassAffected = false
         var areSubclassesAffected = false
-        val changedSupertypes = HashSet<FqName>()
         val names = hashSetOf<String>()
         val classIsSealed = newProto.isSealed && oldProto.isSealed
 
@@ -250,21 +247,12 @@ class DifferenceCalculatorForClass(
                 ProtoBufClassKind.FLAGS,
                 ProtoBufClassKind.FQ_NAME,
                 ProtoBufClassKind.TYPE_PARAMETER_LIST,
+                ProtoBufClassKind.SUPERTYPE_LIST,
+                ProtoBufClassKind.SUPERTYPE_ID_LIST,
                 ProtoBufClassKind.JS_EXT_CLASS_ANNOTATION_LIST -> {
                     isClassAffected = true
                     areSubclassesAffected = true
                 }
-
-                ProtoBufClassKind.SUPERTYPE_LIST,
-                ProtoBufClassKind.SUPERTYPE_ID_LIST -> {
-                    isClassAffected = true
-                    areSubclassesAffected = true
-
-                    val oldSupertypes = oldProto.supertypeList.map { oldNameResolver.getClassId(it.className).asSingleFqName() }
-                    val newSupertypes = newProto.supertypeList.map { newNameResolver.getClassId(it.className).asSingleFqName() }
-                    val changed = (oldSupertypes union newSupertypes) subtract (oldSupertypes intersect newSupertypes)
-                    changedSupertypes.addAll(changed)
-                }
                 ProtoBufClassKind.JVM_EXT_CLASS_MODULE_NAME,
                 ProtoBufClassKind.JS_EXT_CLASS_CONTAINING_FILE_ID -> {
                     // TODO
@@ -293,7 +281,7 @@ class DifferenceCalculatorForClass(
             }
         }
 
-        return Difference(isClassAffected, areSubclassesAffected, names, changedSupertypes)
+        return Difference(isClassAffected, areSubclassesAffected, names)
     }
 }
 

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

@@ -30,7 +30,6 @@ open class BasicMapsOwner(val cachesDir: File) {
     protected val String.storageFile: File
         get() = File(cachesDir, this + "." + CACHE_EXTENSION)
 
-    @Synchronized
     protected fun <K, V, M : BasicMap<K, V>> registerMap(map: M): M {
         maps.add(map)
         return map
@@ -48,7 +47,6 @@ open class BasicMapsOwner(val cachesDir: File) {
         forEachMapSafe("flush") { it.flush(memoryCachesOnly) }
     }
 
-    @Synchronized
     private fun forEachMapSafe(actionName: String, action: (BasicMap<*, *>) -> Unit) {
         val actionExceptions = LinkedHashMap<String, Exception>()
         maps.forEach {
@@ -68,6 +66,5 @@ open class BasicMapsOwner(val cachesDir: File) {
     }
 
     @TestOnly
-    @Synchronized
     fun dump(): String = maps.joinToString("\n\n") { it.dump() }
 }

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

@@ -17,11 +17,9 @@
 package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
 import com.intellij.util.io.PersistentHashMap
 import java.io.File
-import java.io.IOException
 
 
 /**
@@ -32,6 +30,7 @@ class CachingLazyStorage<K, V>(
     private val keyDescriptor: KeyDescriptor<K>,
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
+    @Volatile
     private var storage: PersistentHashMap<K, V>? = null
 
     @Synchronized
@@ -81,10 +80,8 @@ class CachingLazyStorage<K, V>(
         try {
             storage?.close()
         } finally {
+            PersistentHashMap.deleteFilesStartingWith(storageFile)
             storage = null
-            if (!IOUtil.deleteAllFilesStartingWith(storageFile)) {
-                throw IOException("Could not delete internal storage: ${storageFile.absolutePath}")
-            }
         }
     }
 

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

@@ -1,51 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.incremental.storage
-
-import com.intellij.util.io.DataExternalizer
-import org.jetbrains.kotlin.name.FqName
-import java.io.DataInput
-import java.io.DataOutput
-import java.io.File
-
-internal data class ICClassesAttributes(val isSealed: Boolean)
-
-internal object ICClassesAttributesExternalizer : DataExternalizer<ICClassesAttributes> {
-    override fun read(input: DataInput): ICClassesAttributes {
-        return ICClassesAttributes(input.readBoolean())
-    }
-
-    override fun save(output: DataOutput, value: ICClassesAttributes) {
-        output.writeBoolean(value.isSealed)
-    }
-}
-
-internal open class ClassAttributesMap(
-    storageFile: File
-) : BasicStringMap<ICClassesAttributes>(storageFile, ICClassesAttributesExternalizer) {
-    override fun dumpValue(value: ICClassesAttributes): String = value.toString()
-
-    operator fun set(key: FqName, value: ICClassesAttributes) {
-        storage[key.asString()] = value
-    }
-
-    operator fun get(key: FqName): ICClassesAttributes? = storage[key.asString()]
-
-    fun remove(key: FqName) {
-        storage.remove(key.asString())
-    }
-}

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

@@ -20,18 +20,18 @@ import org.jetbrains.kotlin.incremental.dumpCollection
 import org.jetbrains.kotlin.name.FqName
 import java.io.File
 
-internal open class ClassOneToManyMap(storageFile: File) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
+internal open class ClassOneToManyMap(
+        storageFile: File
+) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
     override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
 
-    @Synchronized
     fun add(key: FqName, value: FqName) {
         storage.append(key.asString(), listOf(value.asString()))
     }
 
     operator fun get(key: FqName): Collection<FqName> =
-        storage[key.asString()]?.map(::FqName) ?: setOf()
+            storage[key.asString()]?.map(::FqName) ?: setOf()
 
-    @Synchronized
     operator fun set(key: FqName, values: Collection<FqName>) {
         if (values.isEmpty()) {
             remove(key)
@@ -41,14 +41,10 @@ internal open class ClassOneToManyMap(storageFile: File) : BasicStringMap<Collec
         storage[key.asString()] = values.map(FqName::asString)
     }
 
-    @Synchronized
     fun remove(key: FqName) {
         storage.remove(key.asString())
     }
 
-    // Access to caches could be done from multiple threads (e.g. JPS worker and RMI). The underlying collection is already synchronized,
-    // thus we need synchronization of this method and all modification methods.
-    @Synchronized
     fun removeValues(key: FqName, removed: Set<FqName>) {
         val notRemoved = this[key].filter { it !in removed }
         this[key] = notRemoved

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

@@ -25,7 +25,8 @@ internal class DirtyClassesJvmNameMap(storageFile: File) : AbstractDirtyClassesM
 internal class DirtyClassesFqNameMap(storageFile: File) : AbstractDirtyClassesMap<FqName>(FqNameTransformer, storageFile)
 
 internal abstract class AbstractDirtyClassesMap<Name>(
-    private val nameTransformer: NameTransformer<Name>, storageFile: File
+        private val nameTransformer: NameTransformer<Name>,
+        storageFile: File
 ) : BasicStringMap<Boolean>(storageFile, BooleanDataDescriptor.INSTANCE) {
     fun markDirty(className: Name) {
         storage[nameTransformer.asString(className)] = true
@@ -36,10 +37,10 @@ internal abstract class AbstractDirtyClassesMap<Name>(
     }
 
     fun getDirtyOutputClasses(): Collection<Name> =
-        storage.keys.map { nameTransformer.asName(it) }
+            storage.keys.map { nameTransformer.asName(it) }
 
     fun isDirty(className: Name): Boolean =
-        storage.contains(nameTransformer.asString(className))
+            storage.contains(nameTransformer.asString(className))
 
     override fun dumpValue(value: Boolean) = ""
 }

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

@@ -17,11 +17,9 @@
 package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
 import com.intellij.util.io.PersistentHashMap
 import java.io.File
-import java.io.IOException
 
 
 class NonCachingLazyStorage<K, V>(
@@ -29,6 +27,7 @@ class NonCachingLazyStorage<K, V>(
     private val keyDescriptor: KeyDescriptor<K>,
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
+    @Volatile
     private var storage: PersistentHashMap<K, V>? = null
 
     @Synchronized
@@ -77,12 +76,11 @@ class NonCachingLazyStorage<K, V>(
     override fun clean() {
         try {
             storage?.close()
-        } finally {
-            storage = null
-            if (!IOUtil.deleteAllFilesStartingWith(storageFile)) {
-                throw IOException("Could not delete internal storage: ${storageFile.absolutePath}")
-            }
+        } catch (ignored: Throwable) {
         }
+
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
     }
 
     @Synchronized

build-common/test/org/jetbrains/kotlin/build/BuildMetaInfoTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.build
 
 import junit.framework.TestCase
+import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.junit.Assert.assertNotEquals
 import org.junit.Test
@@ -33,7 +34,10 @@ class BuildMetaInfoTest : TestCase() {
             "bytecodeVersionMinor",
             "bytecodeVersionPatch",
             "compilerBuildVersion",
+            "coroutinesEnable",
+            "coroutinesError",
             "coroutinesVersion",
+            "coroutinesWarn",
             "isEAP",
             "languageVersionString",
             "metadataVersionMajor",
@@ -67,12 +71,14 @@ class BuildMetaInfoTest : TestCase() {
     @Test
     fun testJvmEquals() {
         val args1 = K2JVMCompilerArguments()
+        args1.coroutinesState = CommonCompilerArguments.ENABLE
         val info1 = JvmBuildMetaInfo.create(args1)
 
         val args2 = K2JVMCompilerArguments()
+        args2.coroutinesState = CommonCompilerArguments.WARN
         val info2 = JvmBuildMetaInfo.create(args2)
 
-        assertEquals(info1, info2)
-        assertEquals(info1, info2.copy())
+        assertNotEquals(info1, info2)
+        assertEquals(info1, info2.copy(coroutinesEnable = true, coroutinesWarn = false))
     }
 }

build.gradle.kts

@@ -188,14 +188,13 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.5-dev-17775"
+    extra["versions.kotlin-native"] = "1.4.30-dev-17200"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
 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
 
@@ -294,7 +293,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:checkers",
     ":compiler:fir:entrypoint",
     ":compiler:fir:analysis-tests",
-    ":compiler:fir:analysis-tests:legacy-fir-tests",
     ":wasm:wasm.ir"
 )
 
@@ -321,23 +319,6 @@ extra["compilerModulesForJps"] = listOf(
     ":compiler:compiler.version"
 )
 
-// TODO: fix remaining warnings and remove this property.
-extra["tasksWithWarnings"] = listOf(
-    ":kotlin-stdlib:compileTestKotlin",
-    ":kotlin-stdlib-jdk7:compileTestKotlin",
-    ":kotlin-stdlib-jdk8:compileTestKotlin",
-    ":compiler:frontend:compileKotlin",
-    ":compiler:fir:tree:compileKotlin",
-    ":compiler:fir:resolve:compileKotlin",
-    ":compiler:fir:checkers:compileKotlin",
-    ":compiler:fir:java:compileKotlin",
-    ":plugins:uast-kotlin:compileKotlin",
-    ":plugins:uast-kotlin:compileTestKotlin",
-    ":plugins:uast-kotlin-idea:compileKotlin"
-)
-
-val tasksWithWarnings: List<String> by extra
-
 val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
@@ -426,6 +407,7 @@ allprojects {
         jcenter()
         maven(protobufRepo)
         maven(intellijRepo)
+        maven("https://dl.bintray.com/kotlin/ktor")
         maven("https://kotlin.bintray.com/kotlin-dependencies")
         maven("https://jetbrains.bintray.com/intellij-third-party-dependencies")
         maven("https://dl.google.com/dl/android/maven2")
@@ -462,25 +444,7 @@ allprojects {
 
             if (useJvmIrBackend) {
                 useIR = true
-            }
-
-            if (useJvmFir) {
-                freeCompilerArgs += "-Xuse-fir"
-            }
-        }
-    }
-
-    if (!kotlinBuildProperties.isInJpsBuildIdeaSync && !kotlinBuildProperties.useFir) {
-        // For compiler and stdlib, allWarningsAsErrors is configured in the corresponding "root" projects
-        // (compiler/build.gradle.kts and libraries/commonConfiguration.gradle).
-        val projectsWithWarningsAsErrors = listOf("core", "plugins").map { File(it).absoluteFile }
-        if (projectsWithWarningsAsErrors.any(projectDir::startsWith)) {
-            tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
-                if (path !in tasksWithWarnings) {
-                    kotlinOptions {
-                        allWarningsAsErrors = true
-                    }
-                }
+                freeCompilerArgs += "-Xir-binary-with-stable-abi"
             }
         }
     }
@@ -503,7 +467,7 @@ allprojects {
     }
 
     tasks.withType<Test> {
-        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KTI-112") { true }
+        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KT-37089") { true }
     }
 
     normalization {
@@ -587,11 +551,10 @@ gradle.taskGraph.whenReady {
 
     val proguardMessage = "proguard is ${kotlinBuildProperties.proguard.toOnOff()}"
     val jarCompressionMessage = "jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()}"
+                val profileMessage = "$profile build profile is active ($proguardMessage, $jarCompressionMessage). " +
+            "Use -Pteamcity=<true|false> to reproduce CI/local build"
 
-    logger.warn(
-        "$profile build profile is active ($proguardMessage, $jarCompressionMessage). " +
-                "Use -Pteamcity=<true|false> to reproduce CI/local build"
-    )
+    logger.warn("\n\n$profileMessage")
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -606,7 +569,7 @@ val dist = tasks.register("dist") {
 }
 
 val syncMutedTests = tasks.register("syncMutedTests") {
-    dependsOn(":compiler:tests-mutes:tc-integration:run")
+    dependsOn(":compiler:tests-mutes:run")
 }
 
 val copyCompilerToIdeaPlugin by task<Copy> {
@@ -667,7 +630,6 @@ tasks {
         dependsOn("dist")
         dependsOn(
             ":compiler:test",
-            ":compiler:tests-common-new:test",
             ":compiler:container:test",
             ":compiler:tests-java8:test",
             ":compiler:tests-spec:test",
@@ -704,7 +666,6 @@ tasks {
         dependsOn(":compiler:fir:raw-fir:psi2fir:test")
         dependsOn(":compiler:fir:raw-fir:light-tree2fir:test")
         dependsOn(":compiler:fir:analysis-tests:test")
-        dependsOn(":compiler:fir:analysis-tests:legacy-fir-tests:test")
         dependsOn(":compiler:fir:fir2ir:test")
     }
 
@@ -714,7 +675,6 @@ tasks {
             ":compiler:fir:raw-fir:psi2fir:test",
             ":compiler:fir:raw-fir:light-tree2fir:test",
             ":compiler:fir:analysis-tests:test",
-            ":compiler:fir:analysis-tests:legacy-fir-tests:test",
             ":compiler:fir:fir2ir:test",
             ":plugins:fir:fir-plugin-prototype:test"
         )
@@ -750,6 +710,7 @@ tasks {
     }
 
     register("miscCompilerTest") {
+        dependsOn("wasmCompilerTest")
         dependsOn("nativeCompilerTest")
         dependsOn("firCompilerTest")
 
@@ -814,6 +775,7 @@ tasks {
 
     if (Ide.IJ()) {
         register("idea-new-project-wizard-tests") {
+            dependsOn("dist")
             dependsOn(
                 ":libraries:tools:new-project-wizard:test",
                 ":libraries:tools:new-project-wizard:new-project-wizard-cli:test",
@@ -886,24 +848,12 @@ tasks {
             ":generators:test"
         )
         if (Ide.IJ()) {
-            dependsOn(
-                ":libraries:tools:new-project-wizard:test",
-                ":libraries:tools:new-project-wizard:new-project-wizard-cli:test",
-                ":idea:idea-new-project-wizard:test" // Temporary here. Remove after enabling builds for ideaIntegrationsTests
-            )
-        }
-    }
-
-    register("ideaIntegrationsTests") {
-        if (Ide.IJ()) {
-            dependsOn(":idea:idea-new-project-wizard:test")
+            dependsOn("idea-new-project-wizard-tests")
         }
     }
 
     register("kaptIdeTest") {
         dependsOn(":kotlin-annotation-processing:test")
-        dependsOn(":kotlin-annotation-processing-base:test")
-        dependsOn(":kotlin-annotation-processing-cli:test")
     }
 
     register("gradleIdeTest") {
@@ -918,7 +868,6 @@ tasks {
             ":idea:idea-gradle:test",
             ":idea:test",
             ":compiler:test",
-            ":compiler:container:test",
             ":js:js.tests:test"
         )
 

buildSrc/build.gradle.kts

@@ -114,7 +114,6 @@ dependencies {
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
 
     implementation("org.gradle:test-retry-gradle-plugin:1.1.9")
-    implementation("com.gradle.enterprise:test-distribution-gradle-plugin:1.2.1")
 }
 
 samWithReceiver {

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -54,12 +54,11 @@ var Project.javaHome: String?
         extra["javaHome"] = v
     }
 
-fun Project.generator(fqName: String, sourceSet: SourceSet? = null, configure: JavaExec.() -> Unit = {}) = smartJavaExec {
+fun Project.generator(fqName: String, sourceSet: SourceSet? = null) = smartJavaExec {
     classpath = (sourceSet ?: testSourceSet).runtimeClasspath
     mainClass.set(fqName)
     workingDir = rootDir
     systemProperty("line.separator", "\n")
-    configure()
 }
 
 fun Project.getBooleanProperty(name: String): Boolean? = this.findProperty(name)?.let {

buildSrc/src/main/kotlin/jdksFinder.kt

@@ -101,12 +101,8 @@ fun MutableCollection<JdkId>.discoverJdks(project: Project) {
     }
 }
 
-private val macOsJavaHomeOutRegexes =
-    listOf(
-        Regex("""\s+(\S+),\s+(\S+):\s+".*?"\s+(.+)"""),
-        Regex("""\s+(\S+)\s+\((.*?)\):\s+(.+)"""),
-        Regex("""\s+(\S+)\s+\((.*?)\)\s+"[^"]*"\s+-\s+"[^"]*"\s(.+)""")
-)
+private val macOsJavaHomeOutRegexes = listOf(Regex("""\s+(\S+),\s+(\S+):\s+".*?"\s+(.+)"""),
+                                             Regex("""\s+(\S+)\s+\((.*?)\):\s+(.+)"""))
 
 fun MutableCollection<JdkId>.discoverJdksOnMacOS(project: Project) {
     val procBuilder = ProcessBuilder("/usr/libexec/java_home", "-V").redirectErrorStream(true)

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -20,10 +20,6 @@ internal const val PLUGIN_MARKER_SUFFIX = ".gradle.plugin"
 
 @OptIn(ExperimentalStdlibApi::class)
 fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
-
-    fun Project.isSonatypePublish(): Boolean =
-        hasProperty("isSonatypePublish") && property("isSonatypePublish") as Boolean
-
     val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
     val publishingExtension = extensions.getByType<PublishingExtension>()
     val mainPublication = publishingExtension.publications[KotlinBuildPublishingPlugin.PUBLICATION_NAME] as MavenPublication
@@ -36,12 +32,7 @@ fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
 
         tasks.named<PublishToMavenRepository>(
             "publish${markerPublication.name.capitalize(Locale.ROOT)}PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository"
-        ).apply {
-            configureRepository()
-            configure {
-                onlyIf { !isSonatypePublish() }
-            }
-        }
+        ).configureRepository()
     }
 }
 

buildSrc/src/main/kotlin/sourceSets.kt

@@ -30,7 +30,6 @@ val SourceSet.projectDefault: Project.() -> Unit
             }
             "test" -> {
                 java.srcDirs("test", "tests")
-                this@projectDefault.resources.srcDir("testResources")
             }
         }
     }

buildSrc/src/main/kotlin/tasks.kt

@@ -76,7 +76,6 @@ fun Project.projectTest(
     taskName: String = "test",
     parallel: Boolean = false,
     shortenTempRootName: Boolean = false,
-    jUnit5Enabled: Boolean = false,
     body: Test.() -> Unit = {}
 ): TaskProvider<Test> = getOrCreateTask(taskName) {
     doFirst {
@@ -110,29 +109,12 @@ fun Project.projectTest(
                 }
             }
 
-            val parentNames = if (jUnit5Enabled) {
-                /*
-                 * If we run test from inner test class with junit 5 we need
-                 *   to include all containing classes of our class
-                 */
-                val nestedNames = classFileNameWithoutExtension.split("$")
-                mutableListOf(nestedNames.first()).also {
-                    for (s in nestedNames.subList(1, nestedNames.size)) {
-                        it += "${it.last()}\$$s"
-                    }
-                }
-            } else emptyList()
-
-            include { treeElement ->
-                val path = treeElement.path
-                if (treeElement.isDirectory) {
+            include {
+                val path = it.path
+                if (it.isDirectory) {
                     classFileNameWithoutExtension.startsWith(path)
                 } else {
-                    if (jUnit5Enabled) {
-                        path == classFileName || (path.endsWith(".class") && parentNames.any { path.startsWith(it) })
-                    } else {
-                        path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
-                    }
+                    path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$"))
                 }
             }
         }

buildSrc/src/main/kotlin/testDistribution.kt

@@ -1,30 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-import com.gradle.enterprise.gradleplugin.testdistribution.TestDistributionExtension
-import org.gradle.api.tasks.testing.Test
-import org.gradle.internal.os.OperatingSystem
-
-
-fun Test.configureTestDistribution(configure: TestDistributionExtension.() -> Unit = {}) {
-    val isTeamcityBuild = project.kotlinBuildProperties.isTeamcityBuild
-    val testDistributionEnabled = project.findProperty("kotlin.build.test.distribution.enabled")?.toString()?.toBoolean()
-        ?: isTeamcityBuild
-
-    useJUnitPlatform()
-    extensions.configure(TestDistributionExtension::class.java) {
-        enabled.set(testDistributionEnabled)
-        maxRemoteExecutors.set(20)
-        if (isTeamcityBuild) {
-            requirements.set(setOf("os=${OperatingSystem.current().familyName}"))
-        } else {
-            maxLocalExecutors.set(0)
-        }
-        configure()
-    }
-}
-
-fun Test.isTestDistributionEnabled(): Boolean =
-    extensions.findByType(TestDistributionExtension::class.java)?.enabled?.orNull ?: false

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.android.tests
 
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.SystemInfo
 import com.intellij.openapi.util.io.FileUtil
@@ -22,7 +23,6 @@ import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.*
-import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.File
 import java.io.FileWriter
@@ -269,7 +269,8 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     continue
                 }
 
-                val fullFileText = FileUtil.loadFile(file, true)
+                val fullFileText =
+                    FileUtil.loadFile(file, true).replace("COROUTINES_PACKAGE", "kotlin.coroutines")
 
                 if (fullFileText.contains("// WITH_COROUTINES")) {
                     if (fullFileText.contains("kotlin.coroutines.experimental")) continue
@@ -303,9 +304,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                         if (kind.withReflection) JVM8REFLECT else JVM8
                     } else if (kind.withReflection) REFLECT else COMMON
                     val filesHolder = holders.getOrPut(key) {
-                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind,
-                                                                               KtTestUtil.getAnnotationsJar()
-                        ).apply {
+                        FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
                             KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
@@ -318,7 +317,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
     }
 
     private fun createTestFiles(file: File, expectedText: String): List<KotlinBaseTest.TestFile> =
-        CodegenTestCase.createTestFilesFromFile(file, expectedText, false, TargetBackend.JVM)
+        CodegenTestCase.createTestFilesFromFile(file, expectedText, "kotlin.coroutines", false, TargetBackend.JVM)
 
     companion object {
         const val GRADLE_VERSION = "5.6.4" // update GRADLE_SHA_256 on change
@@ -343,7 +342,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         @Throws(IOException::class)
         internal fun writeAndroidSkdToLocalProperties(pathManager: PathManager) {
-            val sdkRoot = KtTestUtil.getAndroidSdkSystemIndependentPath()
+            val sdkRoot = KotlinTestUtils.getAndroidSdkSystemIndependentPath()
             println("Writing android sdk to local.properties: $sdkRoot")
             val file = File(pathManager.tmpFolder + "/local.properties")
             FileWriter(file).use { fw -> fw.write("sdk.dir=$sdkRoot") }

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidRunner.kt

@@ -160,6 +160,7 @@ class CodegenTestsOnAndroidRunner private constructor(private val pathManager: P
                 val item = testCases.item(i) as Element
                 val failure = item.getElementsByTagName("failure")
                 val name = item.getAttribute("name")
+                val clazz = item.getAttribute("classname")
 
                 if (failure.length == 0) {
                     object : TestCase(name) {

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/PathManager.java

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android.tests;
 
-import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
 
 import java.io.File;
 
@@ -69,7 +69,7 @@ public class PathManager {
     }
 
     public String getAndroidSdkRoot() {
-        return KtTestUtil.getAndroidSdkSystemIndependentPath();
+        return KotlinTestUtils.getAndroidSdkSystemIndependentPath();
     }
 
     public String getAndroidModuleRoot() {

compiler/backend.common.jvm/src/org/jetbrains/kotlin/codegen/VersionIndependentOpcodes.kt

@@ -1,13 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen
-
-import org.jetbrains.org.objectweb.asm.Opcodes
-
-// This object should help compiling against different ASM versions in different bunch versions
-object VersionIndependentOpcodes {
-    const val ACC_RECORD = Opcodes.ACC_RECORD
-}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/codegen/VersionIndependentOpcodes.kt.201

@@ -1,13 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen
-
-import org.jetbrains.org.objectweb.asm.Opcodes
-
-// This object should help compiling against different ASM versions from different bunch versions
-object VersionIndependentOpcodes {
-    const val ACC_RECORD = 0
-}

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

@@ -26,13 +26,13 @@ import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.org.objectweb.asm.*;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.GENERATE_SMAP;
 
 public abstract class AbstractClassBuilder implements ClassBuilder {
     protected static final MethodVisitor EMPTY_METHOD_VISITOR = new MethodVisitor(Opcodes.API_VERSION) {};
-    public static final RecordComponentVisitor EMPTY_RECORD_VISITOR = new RecordComponentVisitor(Opcodes.API_VERSION) {};
     protected static final FieldVisitor EMPTY_FIELD_VISITOR = new FieldVisitor(Opcodes.API_VERSION) {};
 
     private String thisName;
@@ -91,16 +91,6 @@ public abstract class AbstractClassBuilder implements ClassBuilder {
         return visitor;
     }
 
-    @NotNull
-    @Override
-    public RecordComponentVisitor newRecordComponent(@NotNull String name, @NotNull String desc, @Nullable String signature) {
-        RecordComponentVisitor visitor = getVisitor().visitRecordComponent(name, desc, signature);
-        if (visitor == null) {
-            return EMPTY_RECORD_VISITOR;
-        }
-        return visitor;
-    }
-
     @Override
     @NotNull
     public JvmSerializationBindings getSerializationBindings() {

compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractClassBuilder.java.201

@@ -1,158 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen;
-
-import com.intellij.psi.PsiElement;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.inline.FileMapping;
-import org.jetbrains.kotlin.codegen.inline.SMAPBuilder;
-import org.jetbrains.kotlin.codegen.inline.SourceMapper;
-import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.org.objectweb.asm.*;
-
-import java.util.List;
-
-import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.GENERATE_SMAP;
-
-public abstract class AbstractClassBuilder implements ClassBuilder {
-    protected static final MethodVisitor EMPTY_METHOD_VISITOR = new MethodVisitor(Opcodes.API_VERSION) {};
-    protected static final FieldVisitor EMPTY_FIELD_VISITOR = new FieldVisitor(Opcodes.API_VERSION) {};
-
-    private String thisName;
-
-    private final JvmSerializationBindings serializationBindings = new JvmSerializationBindings();
-
-    private String sourceName;
-
-    private String debugInfo;
-
-    public static class Concrete extends AbstractClassBuilder {
-        private final ClassVisitor v;
-
-        public Concrete(@NotNull ClassVisitor v) {
-            this.v = v;
-        }
-
-        @Override
-        @NotNull
-        public ClassVisitor getVisitor() {
-            return v;
-        }
-    }
-
-    @Override
-    @NotNull
-    public FieldVisitor newField(
-            @NotNull JvmDeclarationOrigin origin,
-            int access,
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature,
-            @Nullable Object value
-    ) {
-        FieldVisitor visitor = getVisitor().visitField(access, name, desc, signature, value);
-        if (visitor == null) {
-            return EMPTY_FIELD_VISITOR;
-        }
-        return visitor;
-    }
-
-    @Override
-    @NotNull
-    public MethodVisitor newMethod(
-            @NotNull JvmDeclarationOrigin origin,
-            int access,
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature,
-            @Nullable String[] exceptions
-    ) {
-        MethodVisitor visitor = getVisitor().visitMethod(access, name, desc, signature, exceptions);
-        if (visitor == null) {
-            return EMPTY_METHOD_VISITOR;
-        }
-        return visitor;
-    }
-
-    @Override
-    @NotNull
-    public JvmSerializationBindings getSerializationBindings() {
-        return serializationBindings;
-    }
-
-    @Override
-    @NotNull
-    public AnnotationVisitor newAnnotation(@NotNull String desc, boolean visible) {
-        return getVisitor().visitAnnotation(desc, visible);
-    }
-
-    @Override
-    public void done() {
-        getVisitor().visitSource(sourceName, debugInfo);
-        getVisitor().visitEnd();
-    }
-
-    @Override
-    public void defineClass(
-            @Nullable PsiElement origin,
-            int version,
-            int access,
-            @NotNull String name,
-            @Nullable String signature,
-            @NotNull String superName,
-            @NotNull String[] interfaces
-    ) {
-        thisName = name;
-        getVisitor().visit(version, access, name, signature, superName, interfaces);
-    }
-
-    @Override
-    public void visitSource(@NotNull String name, @Nullable String debug) {
-        assert sourceName == null || sourceName.equals(name) : "inconsistent file name: " + sourceName + " vs " + name;
-        sourceName = name;
-        debugInfo = debug;
-    }
-
-    @Override
-    public void visitSMAP(@NotNull SourceMapper smap, boolean backwardsCompatibleSyntax) {
-        if (!GENERATE_SMAP) return;
-
-        List<FileMapping> fileMappings = smap.getResultMappings();
-        if (fileMappings.isEmpty()) return;
-
-        visitSource(fileMappings.get(0).getName(), SMAPBuilder.INSTANCE.build(fileMappings, backwardsCompatibleSyntax));
-    }
-
-    @Override
-    public void visitOuterClass(@NotNull String owner, @Nullable String name, @Nullable String desc) {
-        getVisitor().visitOuterClass(owner, name, desc);
-    }
-
-    @Override
-    public void visitInnerClass(@NotNull String name, @Nullable String outerName, @Nullable String innerName, int access) {
-        getVisitor().visitInnerClass(name, outerName, innerName, access);
-    }
-
-    @Override
-    @NotNull
-    public String getThisName() {
-        assert thisName != null : "This name isn't set";
-        return thisName;
-    }
-}

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

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.AnnotationChecker;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker;
 import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
@@ -498,9 +497,6 @@ public abstract class AnnotationCodegen {
             public Void visitKClassValue(KClassValue value, Void data) {
                 KotlinType classType = value.getArgumentType(module);
                 innerClassConsumer.addInnerClassInfoFromAnnotation(DescriptorUtils.getClassDescriptorForType(classType));
-                if (InlineClassesUtilsKt.isInlineClassType(classType)) {
-                    classType = TypeUtils.makeNullable(classType);
-                }
                 annotationVisitor.visit(name, typeMapper.mapType(classType));
                 return null;
             }

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

@@ -29,8 +29,7 @@ class CallableMethod(
     override val generateCalleeType: Type?,
     override val returnKotlinType: KotlinType?,
     val isInterfaceMethod: Boolean,
-    private val isDefaultMethodInInterface: Boolean,
-    private val boxInlineClassBeforeInvoke: Boolean
+    private val isDefaultMethodInInterface: Boolean
 ) : Callable {
     private val defaultImplMethod: Method by lazy(LazyThreadSafetyMode.PUBLICATION, computeDefaultMethod)
 
@@ -50,9 +49,6 @@ class CallableMethod(
         get() = getAsmMethod().argumentTypes
 
     override fun genInvokeInstruction(v: InstructionAdapter) {
-        if (boxInlineClassBeforeInvoke) {
-            StackValue.boxInlineClass(dispatchReceiverKotlinType!!, v)
-        }
         v.visitMethodInsn(
             invokeOpcode,
             owner.internalName,

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

@@ -19,10 +19,14 @@ package org.jetbrains.kotlin.codegen;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.codegen.inline.FileMapping;
 import org.jetbrains.kotlin.codegen.inline.SourceMapper;
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
+import org.jetbrains.org.objectweb.asm.ClassVisitor;
+import org.jetbrains.org.objectweb.asm.FieldVisitor;
+import org.jetbrains.org.objectweb.asm.MethodVisitor;
 
 public interface ClassBuilder {
     @NotNull
@@ -45,12 +49,6 @@ public interface ClassBuilder {
             @Nullable String[] exceptions
     );
 
-    @NotNull RecordComponentVisitor newRecordComponent(
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature
-    );
-
     @NotNull
     JvmSerializationBindings getSerializationBindings();
 

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBuilder.java.201

@@ -1,79 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen;
-
-import com.intellij.psi.PsiElement;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.inline.SourceMapper;
-import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.org.objectweb.asm.*;
-
-public interface ClassBuilder {
-    @NotNull
-    FieldVisitor newField(
-            @NotNull JvmDeclarationOrigin origin,
-            int access,
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature,
-            @Nullable Object value
-    );
-
-    @NotNull
-    MethodVisitor newMethod(
-            @NotNull JvmDeclarationOrigin origin,
-            int access,
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature,
-            @Nullable String[] exceptions
-    );
-
-    @NotNull
-    JvmSerializationBindings getSerializationBindings();
-
-    @NotNull
-    AnnotationVisitor newAnnotation(@NotNull String desc, boolean visible);
-
-    void done();
-
-    @NotNull
-    ClassVisitor getVisitor();
-
-    void defineClass(
-            @Nullable PsiElement origin,
-            int version,
-            int access,
-            @NotNull String name,
-            @Nullable String signature,
-            @NotNull String superName,
-            @NotNull String[] interfaces
-    );
-
-    void visitSource(@NotNull String name, @Nullable String debug);
-
-    void visitSMAP(@NotNull SourceMapper smap, boolean backwardsCompatibleSyntax);
-
-    void visitOuterClass(@NotNull String owner, @Nullable String name, @Nullable String desc);
-
-    void visitInnerClass(@NotNull String name, @Nullable String outerName, @Nullable String innerName, int access);
-
-    @NotNull
-    String getThisName();
-}

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

@@ -1,10 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen
-
-fun ClassBuilder.addRecordComponent(name: String, desc: String, signature: String?) {
-    newRecordComponent(name, desc, signature)
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBuilderRecord.kt.201

@@ -1,11 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen
-
-@Suppress("UNUSED_PARAMETER", "unused")
-fun ClassBuilder.addRecordComponent(name: String, desc: String, signature: String?) {
-    // newRecordComponent(name, desc, signature)
-}

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

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.KtPureClassOrObject
 import org.jetbrains.kotlin.psi.KtPureElement
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue
 import org.jetbrains.kotlin.resolve.isInlineClass
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
@@ -270,7 +269,6 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
         if (classOrObject.isLocal) return false
         if (classDescriptor.isInlineClass()) return false
         if (shouldHideConstructorDueToInlineClassTypeValueParameters(constructorDescriptor)) return false
-        if (DescriptorUtils.isSealedClass(classDescriptor)) return false
 
         if (CodegenBinding.canHaveOuter(state.bindingContext, classDescriptor)) return false
 

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

@@ -19,10 +19,14 @@ package org.jetbrains.kotlin.codegen;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.codegen.inline.FileMapping;
 import org.jetbrains.kotlin.codegen.inline.SourceMapper;
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
+import org.jetbrains.org.objectweb.asm.ClassVisitor;
+import org.jetbrains.org.objectweb.asm.FieldVisitor;
+import org.jetbrains.org.objectweb.asm.MethodVisitor;
 
 public abstract class DelegatingClassBuilder implements ClassBuilder {
     @NotNull
@@ -54,14 +58,6 @@ public abstract class DelegatingClassBuilder implements ClassBuilder {
         return getDelegate().newMethod(origin, access, name, desc, signature, exceptions);
     }
 
-    @NotNull
-    @Override
-    public RecordComponentVisitor newRecordComponent(
-            @NotNull String name, @NotNull String desc, @Nullable String signature
-    ) {
-        return getDelegate().newRecordComponent(name, desc, signature);
-    }
-
     @NotNull
     @Override
     public JvmSerializationBindings getSerializationBindings() {

compiler/backend/src/org/jetbrains/kotlin/codegen/DelegatingClassBuilder.java.201

@@ -1,118 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen;
-
-import com.intellij.psi.PsiElement;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.codegen.inline.SourceMapper;
-import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.org.objectweb.asm.*;
-
-public abstract class DelegatingClassBuilder implements ClassBuilder {
-    @NotNull
-    protected abstract ClassBuilder getDelegate();
-
-    @NotNull
-    @Override
-    public FieldVisitor newField(
-            @NotNull JvmDeclarationOrigin origin,
-            int access,
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature,
-            @Nullable Object value
-    ) {
-        return getDelegate().newField(origin, access, name, desc, signature, value);
-    }
-
-    @NotNull
-    @Override
-    public MethodVisitor newMethod(
-            @NotNull JvmDeclarationOrigin origin,
-            int access,
-            @NotNull String name,
-            @NotNull String desc,
-            @Nullable String signature,
-            @Nullable String[] exceptions
-    ) {
-        return getDelegate().newMethod(origin, access, name, desc, signature, exceptions);
-    }
-
-    @NotNull
-    @Override
-    public JvmSerializationBindings getSerializationBindings() {
-        return getDelegate().getSerializationBindings();
-    }
-
-    @NotNull
-    @Override
-    public AnnotationVisitor newAnnotation(@NotNull String desc, boolean visible) {
-        return getDelegate().newAnnotation(desc, visible);
-    }
-
-    @Override
-    public void done() {
-        getDelegate().done();
-    }
-
-    @NotNull
-    @Override
-    public ClassVisitor getVisitor() {
-        return getDelegate().getVisitor();
-    }
-
-    @Override
-    public void defineClass(
-            @Nullable PsiElement origin,
-            int version,
-            int access,
-            @NotNull String name,
-            @Nullable String signature,
-            @NotNull String superName,
-            @NotNull String[] interfaces
-    ) {
-        getDelegate().defineClass(origin, version, access, name, signature, superName, interfaces);
-    }
-
-    @Override
-    public void visitSource(@NotNull String name, @Nullable String debug) {
-        getDelegate().visitSource(name, debug);
-    }
-
-    @Override
-    public void visitSMAP(@NotNull SourceMapper smap, boolean backwardsCompatibleSyntax) {
-        getDelegate().visitSMAP(smap, backwardsCompatibleSyntax);
-    }
-
-    @Override
-    public void visitOuterClass(@NotNull String owner, @Nullable String name, @Nullable String desc) {
-        getDelegate().visitOuterClass(owner, name, desc);
-    }
-
-    @Override
-    public void visitInnerClass(@NotNull String name, @Nullable String outerName, @Nullable String innerName, int access) {
-        getDelegate().visitInnerClass(name, outerName, innerName, access);
-    }
-
-    @NotNull
-    @Override
-    public String getThisName() {
-        return getDelegate().getThisName();
-    }
-}

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver
-import org.jetbrains.kotlin.resolve.JVM_INLINE_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.resolve.descriptorUtil.secondaryConstructors
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.Synthetic
@@ -56,13 +55,6 @@ class ErasedInlineClassBodyCodegen(
         generateUnboxMethod()
         generateFunctionsFromAny()
         generateSpecializedEqualsStub()
-        generateJvmInlineAnnotation()
-    }
-
-    private fun generateJvmInlineAnnotation() {
-        if (descriptor.isInline) {
-            v.newAnnotation(JVM_INLINE_ANNOTATION_FQ_NAME.topLevelClassAsmType().descriptor, true).visitEnd()
-        }
     }
 
     private fun generateFunctionsFromAny() {

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

@@ -54,7 +54,6 @@ import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
-import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor;
 import org.jetbrains.kotlin.load.kotlin.DescriptorBasedTypeSignatureMappingKt;
 import org.jetbrains.kotlin.load.kotlin.MethodSignatureMappingKt;
 import org.jetbrains.kotlin.name.Name;
@@ -742,11 +741,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         // Some forms of for-loop can be optimized as post-condition loops.
         PseudoInsnsKt.fakeAlwaysFalseIfeq(v, continueLabel);
 
-        // Renew line number cause it could be reset by inline (resetLastLineNumber) in generator.checkPreCondition(loopExit).
-        markStartLineNumber(generator.getForExpression());
-        v.nop();
         generator.beforeBody();
-
         blockStackElements.push(new LoopBlockStackElement(loopExit, continueLabel, targetLabel(generator.getForExpression())));
         generator.body();
         blockStackElements.pop();
@@ -2409,14 +2404,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             fieldName = KotlinTypeMapper.mapDefaultFieldName(propertyDescriptor, isDelegatedProperty);
         }
 
-        KotlinType propertyType = propertyDescriptor.getOriginal().getType();
-        if (propertyDescriptor instanceof JavaPropertyDescriptor && InlineClassesUtilsKt.isInlineClassType(propertyType)) {
-            propertyType = TypeUtils.makeNullable(propertyType);
-        }
-
         return StackValue.property(
                 propertyDescriptor, backingFieldOwner,
-                typeMapper.mapType(isDelegatedProperty && forceField ? delegateType : propertyType),
+                typeMapper.mapType(isDelegatedProperty && forceField ? delegateType : propertyDescriptor.getOriginal().getType()),
                 isStaticBackingField, fieldName, callableGetter, callableSetter, receiver, this, resolvedCall, skipLateinitAssertion,
                 isDelegatedProperty && forceField ? delegateType : null
         );
@@ -4385,10 +4375,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         Type exprType = expressionType(expr);
         KotlinType exprKotlinType = kotlinType(expr);
-        if (exprKotlinType != null && InlineClassesUtilsKt.isInlineClassType(exprKotlinType) &&
-            FlexibleTypesKt.isNullabilityFlexible(exprKotlinType)) {
-            exprKotlinType = TypeUtils.makeNullable(exprKotlinType);
-        }
         StackValue value;
         if (compileTimeConstant != null) {
             value = StackValue.constant(compileTimeConstant.getValue(), exprType, exprKotlinType);

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

@@ -1221,12 +1221,7 @@ public class FunctionCodegen {
 
         // 'null' because the "could not find expected declaration" error has been already reported in isDefaultNeeded earlier
         List<ValueParameterDescriptor> valueParameters =
-                functionDescriptor.isSuspend()
-                ? CollectionsKt.plus(
-                    CodegenUtil.getFunctionParametersForDefaultValueGeneration(
-                            CoroutineCodegenUtilKt.unwrapInitialDescriptorForSuspendFunction(functionDescriptor), null),
-                    CollectionsKt.last(functionDescriptor.getValueParameters()))
-                : CodegenUtil.getFunctionParametersForDefaultValueGeneration(functionDescriptor, null);
+                CodegenUtil.getFunctionParametersForDefaultValueGeneration(functionDescriptor, null);
 
         boolean isStatic = isStaticMethod(methodContext.getContextKind(), functionDescriptor);
         FrameMap frameMap = createFrameMap(state, signature, functionDescriptor.getExtensionReceiverParameter(), valueParameters, isStatic);

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
-import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmClassSignature;
@@ -222,10 +221,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             access |= ACC_ENUM;
         }
 
-        if (JvmAnnotationUtilKt.isJvmRecord(descriptor)) {
-            access |= VersionIndependentOpcodes.ACC_RECORD;
-        }
-
         v.defineClass(
                 myClass.getPsiOrParent(),
                 state.getClassFileVersion(),

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.codegen.inline.SourceMapper;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.codegen.state.TypeMapperUtilsKt;
-import org.jetbrains.kotlin.config.JvmDefaultMode;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotatedImpl;
@@ -84,9 +83,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
 
     private final MemberCodegen<?> parentCodegen;
     private final ReifiedTypeParametersUsages reifiedTypeParametersUsages = new ReifiedTypeParametersUsages();
-
     private final Collection<ClassDescriptor> innerClasses = new LinkedHashSet<>();
-    private final Collection<SyntheticInnerClassInfo> syntheticInnerClasses = new LinkedHashSet<>();
 
     private ExpressionCodegen clInit;
     private NameGenerator inlineNameGenerator;
@@ -319,10 +316,6 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         genClassOrObject(context, descriptor.getSyntheticDeclaration(), state, this, descriptor);
     }
 
-    public void addSyntheticAnonymousInnerClass(SyntheticInnerClassInfo syntheticInnerClassInfo) {
-        syntheticInnerClasses.add(syntheticInnerClassInfo);
-    }
-
     private void writeInnerClasses() {
         // JVMS7 (4.7.6): a nested class or interface member will have InnerClasses information
         // for each enclosing class and for each immediate member
@@ -338,9 +331,6 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         for (ClassDescriptor innerClass : innerClasses) {
             writeInnerClass(innerClass);
         }
-        for (SyntheticInnerClassInfo syntheticInnerClass : syntheticInnerClasses) {
-            v.visitInnerClass(syntheticInnerClass.getInternalName(), null, null, syntheticInnerClass.getFlags());
-        }
     }
 
     protected void addParentsToInnerClassesIfNeeded(@NotNull Collection<ClassDescriptor> innerClasses) {
@@ -386,12 +376,18 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     }
 
     protected void writeOuterClassAndEnclosingMethod() {
-        CodegenContext<?> context = getNonInlineOuterContext(this.context.getParentContext());
+        CodegenContext context = this.context.getParentContext();
+
+        while (context instanceof InlineLambdaContext) {
+            // If this is a lambda which will be inlined, skip its MethodContext and enclosing ClosureContext
+            //noinspection ConstantConditions
+            context = context.getParentContext().getParentContext();
+        }
         assert context != null : "Outermost context can't be null: " + this.context;
 
-        Type enclosingAsmType = computeOuterClass(typeMapper, state.getJvmDefaultMode(), element, context);
+        Type enclosingAsmType = computeOuterClass(context);
         if (enclosingAsmType != null) {
-            Method method = computeEnclosingMethod(typeMapper, context);
+            Method method = computeEnclosingMethod(context);
 
             v.visitOuterClass(
                     enclosingAsmType.getInternalName(),
@@ -401,31 +397,15 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
         }
     }
 
-    public static CodegenContext<?> getNonInlineOuterContext(CodegenContext<?> parentContext) {
-        CodegenContext<?> context = parentContext;
-        while (context instanceof InlineLambdaContext) {
-            // If this is a lambda which will be inlined, skip its MethodContext and enclosing ClosureContext
-            //noinspection ConstantConditions
-            context = context.getParentContext().getParentContext();
-        }
-        return context;
-    }
-
     @Nullable
-    public static Type computeOuterClass(
-            @NotNull KotlinTypeMapper typeMapper,
-            @NotNull JvmDefaultMode jvmDefaultMode,
-            @NotNull KtPureElement element,
-            @NotNull CodegenContext<?> context
-    ) {
+    private Type computeOuterClass(@NotNull CodegenContext<?> context) {
         CodegenContext<? extends ClassOrPackageFragmentDescriptor> outermost = context.getClassOrPackageParentContext();
         if (outermost instanceof ClassContext) {
             ClassDescriptor classDescriptor = ((ClassContext) outermost).getContextDescriptor();
             if (context instanceof MethodContext) {
                 FunctionDescriptor functionDescriptor = ((MethodContext) context).getFunctionDescriptor();
-                if (isInterface(functionDescriptor.getContainingDeclaration()) &&
-                    !JvmAnnotationUtilKt.isCompiledToJvmDefault(functionDescriptor, jvmDefaultMode)
-                ) {
+                if (isInterface(functionDescriptor.getContainingDeclaration()) && !JvmAnnotationUtilKt
+                        .isCompiledToJvmDefault(functionDescriptor, state.getJvmDefaultMode())) {
                     return typeMapper.mapDefaultImpls(classDescriptor);
                 }
             }
@@ -445,7 +425,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     }
 
     @Nullable
-    public static Method computeEnclosingMethod(@NotNull KotlinTypeMapper typeMapper, @NotNull CodegenContext context) {
+    private Method computeEnclosingMethod(@NotNull CodegenContext context) {
         if (context instanceof MethodContext) {
             FunctionDescriptor functionDescriptor = ((MethodContext) context).getFunctionDescriptor();
             if ("<clinit>".equals(functionDescriptor.getName().asString())) {

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

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.util.UnderscoreUtilKt;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
@@ -436,10 +435,9 @@ public class PropertyCodegen {
         v.getSerializationBindings().put(FIELD_FOR_PROPERTY, propertyDescriptor, new Pair<>(type, name));
 
         if (isBackingFieldOwner) {
-            String signature = isDelegate ? null : typeMapper.mapFieldSignature(kotlinType, propertyDescriptor);
             FieldVisitor fv = builder.newField(
                     JvmDeclarationOriginKt.OtherOrigin(propertyDescriptor), modifiers, name, type.getDescriptor(),
-                    signature, defaultValue
+                    isDelegate ? null : typeMapper.mapFieldSignature(kotlinType, propertyDescriptor), defaultValue
             );
 
             if (annotatedField != null) {
@@ -452,10 +450,6 @@ public class PropertyCodegen {
                 AnnotationCodegen.forField(fv, memberCodegen, state, skipNullabilityAnnotations)
                         .genAnnotations(annotatedField, type, propertyDescriptor.getType(), null, additionalVisibleAnnotations);
             }
-
-            if (propertyDescriptor.getContainingDeclaration() instanceof ClassDescriptor && JvmAnnotationUtilKt.isJvmRecord((ClassDescriptor) propertyDescriptor.getContainingDeclaration())) {
-                ClassBuilderRecordKt.addRecordComponent(builder, name, type.getDescriptor(), signature);
-            }
         }
     }
 

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

@@ -20,8 +20,6 @@ import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
-import org.jetbrains.kotlin.codegen.context.CodegenContext;
-import org.jetbrains.kotlin.codegen.context.FieldOwnerContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.*;
@@ -64,7 +62,6 @@ public class SamWrapperCodegen {
     private final SamType samType;
     private final MemberCodegen<?> parentCodegen;
     private final int visibility;
-    private final int classFlags;
     public static final String SAM_WRAPPER_SUFFIX = "$0";
 
     public SamWrapperCodegen(
@@ -79,7 +76,6 @@ public class SamWrapperCodegen {
         this.samType = samType;
         this.parentCodegen = parentCodegen;
         visibility = isInsideInline ? ACC_PUBLIC : NO_FLAG_PACKAGE_PRIVATE;
-        classFlags = visibility | ACC_FINAL | ACC_SUPER;
     }
 
     @NotNull
@@ -125,7 +121,7 @@ public class SamWrapperCodegen {
         cv.defineClass(
                 file,
                 state.getClassFileVersion(),
-                classFlags,
+                ACC_FINAL | ACC_SUPER | visibility,
                 asmType.getInternalName(),
                 null,
                 OBJECT_TYPE.getInternalName(),
@@ -135,8 +131,6 @@ public class SamWrapperCodegen {
 
         WriteAnnotationUtilKt.writeSyntheticClassMetadata(cv, state);
 
-        generateInnerClassInformation(file, asmType, cv);
-
         // e.g. ASM type for Function2
         Type functionAsmType = typeMapper.mapType(functionType);
 
@@ -166,24 +160,6 @@ public class SamWrapperCodegen {
         return asmType;
     }
 
-    private void generateInnerClassInformation(@NotNull KtFile file, Type asmType, ClassBuilder cv) {
-        parentCodegen.addSyntheticAnonymousInnerClass(new SyntheticInnerClassInfo(asmType.getInternalName(), classFlags));
-        FieldOwnerContext<?> parentContext = parentCodegen.context;
-        CodegenContext<?> outerContext = MemberCodegen.getNonInlineOuterContext(parentContext);
-        assert outerContext != null :
-                "Outer context for SAM wrapper " + asmType.getInternalName() + " is null, parentContext:" + parentContext;
-        Type outerClassType = MemberCodegen.computeOuterClass(state.getTypeMapper(), state.getJvmDefaultMode(), file, outerContext);
-        assert outerClassType != null :
-                "Outer class for SAM wrapper " + asmType.getInternalName() + " is null, parentContext:" + parentContext;
-        Method enclosingMethod = MemberCodegen.computeEnclosingMethod(state.getTypeMapper(), outerContext);
-        cv.visitOuterClass(
-                outerClassType.getInternalName(),
-                enclosingMethod == null ? null : enclosingMethod.getName(),
-                enclosingMethod == null ? null : enclosingMethod.getDescriptor()
-        );
-        cv.visitInnerClass(asmType.getInternalName(), null, null, classFlags);
-    }
-
     private void generateConstructor(Type ownerType, Type functionType, ClassBuilder cv) {
         MethodVisitor mv = cv.newMethod(JvmDeclarationOriginKt.OtherOrigin(samType.getClassDescriptor()),
                                         visibility, "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, functionType), null, null);

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

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.psi.PsiElement
+import com.intellij.util.containers.LinkedMultiMap
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
@@ -48,7 +49,7 @@ abstract class SignatureCollectingClassBuilderFactory(
 
         private lateinit var classInternalName: String
 
-        private val signatures = MultiMap.createLinked<RawSignature, JvmDeclarationOrigin>()
+        private val signatures = LinkedMultiMap<RawSignature, JvmDeclarationOrigin>()
 
         override fun defineClass(origin: PsiElement?, version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array<out String>) {
             classInternalName = name

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

@@ -1,8 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen
-
-data class SyntheticInnerClassInfo(val internalName: String, val flags: Int)

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

@@ -1113,7 +1113,7 @@ inline fun withInstructionAdapter(block: InstructionAdapter.() -> Unit): InsnLis
     return tmpMethodNode.instructions
 }
 
-fun Type.normalize() =
+internal fun Type.normalize() =
     when (sort) {
         Type.ARRAY, Type.OBJECT -> AsmTypes.OBJECT_TYPE
         else -> this
@@ -1222,9 +1222,8 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
         oldLvt += record
     }
     method.localVariables.clear()
-    // Skip `this` for suspend lambda
+    // Skip `this` for suspend lamdba
     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
@@ -1240,15 +1239,25 @@ private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction:
                 val endLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode ?: continue
                 // startLabel can be null in case of parameters
                 @Suppress("NAME_SHADOWING") val startLabel = startLabel ?: lvtRecord.start
-                // Attempt to extend existing local variable node corresponding to the record in
-                // the original local variable table.
-                var recordToExtend: LocalVariableNode? = oldLvtNodeToLatestNewLvtNode[lvtRecord]
-                if (recordToExtend != null && InsnSequence(recordToExtend.end, startLabel).none { isBeforeSuspendMarker(it) }) {
+                var recordToExtend: LocalVariableNode? = null
+                for (record in method.localVariables) {
+                    if (record.name == lvtRecord.name &&
+                        record.desc == lvtRecord.desc &&
+                        record.signature == lvtRecord.signature &&
+                        record.index == lvtRecord.index
+                    ) {
+                        if (InsnSequence(record.end, startLabel).none { isBeforeSuspendMarker(it) }) {
+                            recordToExtend = record
+                            break
+                        }
+                    }
+                }
+                if (recordToExtend != null) {
                     recordToExtend.end = endLabel
                 } else {
-                    val node = LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                    method.localVariables.add(node)
-                    oldLvtNodeToLatestNewLvtNode[lvtRecord] = node
+                    method.localVariables.add(
+                        LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
+                    )
                 }
             }
         }

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

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicArrayConstructors
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.Position
 import org.jetbrains.kotlin.incremental.components.ScopeKind
@@ -137,7 +136,9 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
     ) {
         var nodeAndSmap: SMAPAndMethodNode? = null
         try {
-            nodeAndSmap = createInlineMethodNode(mapDefaultSignature, typeArguments, typeSystem)
+            nodeAndSmap = createInlineMethodNode(
+                functionDescriptor, methodOwner, jvmSignature, mapDefaultSignature, typeArguments, typeSystem, state, sourceCompiler
+            )
             endCall(inlineCall(nodeAndSmap, inlineDefaultLambdas), registerLineNumberAfterwards)
         } catch (e: CompilationException) {
             throw e
@@ -273,8 +274,6 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
 
     abstract fun extractDefaultLambdas(node: MethodNode): List<DefaultLambda>
 
-    abstract fun descriptorIsDeserialized(memberDescriptor: CallableMemberDescriptor): Boolean
-
     fun generateAndInsertFinallyBlocks(
         intoNode: MethodNode,
         insertPoints: List<MethodInliner.PointForExternalFinallyBlocks>,
@@ -513,42 +512,38 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
     }
 
 
-    internal fun createInlineMethodNode(
-        callDefault: Boolean,
-        typeArguments: List<TypeParameterMarker>?,
-        typeSystem: TypeSystemCommonBackendContext
-    ): SMAPAndMethodNode {
-        val intrinsic = generateInlineIntrinsic(state, functionDescriptor, typeArguments, typeSystem)
-        if (intrinsic != null) {
-            return SMAPAndMethodNode(intrinsic, createDefaultFakeSMAP())
-        }
-
-        var asmMethod = mapMethod(callDefault)
-        if (asmMethod.name.contains("-") &&
-            !state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) &&
-            classFileContainsMethod(functionDescriptor, state, asmMethod) == false
-        ) {
-            state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = true
-            asmMethod = mapMethod(callDefault)
-            state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = false
-        }
-
-        val directMember = getDirectMemberAndCallableFromObject(functionDescriptor)
-        if (!isBuiltInArrayIntrinsic(functionDescriptor) && !descriptorIsDeserialized(directMember)) {
-            val node = sourceCompiler.doCreateMethodNodeFromSource(functionDescriptor, jvmSignature, callDefault, asmMethod)
-            node.node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
-            return node
-        }
-
-        return getCompiledMethodNodeInner(functionDescriptor, directMember, asmMethod, methodOwner, state, jvmSignature)
-    }
-
-    private fun mapMethod(callDefault: Boolean): Method =
-        if (callDefault) state.typeMapper.mapDefaultMethod(functionDescriptor, sourceCompiler.contextKind)
-        else mangleSuspendInlineFunctionAsmMethodIfNeeded(functionDescriptor, jvmSignature.asmMethod)
-
     companion object {
 
+        internal fun createInlineMethodNode(
+            functionDescriptor: FunctionDescriptor,
+            methodOwner: Type,
+            jvmSignature: JvmMethodSignature,
+            callDefault: Boolean,
+            typeArguments: List<TypeParameterMarker>?,
+            typeSystem: TypeSystemCommonBackendContext,
+            state: GenerationState,
+            sourceCompilerForInline: SourceCompilerForInline
+        ): SMAPAndMethodNode {
+            val intrinsic = generateInlineIntrinsic(state, functionDescriptor, typeArguments, typeSystem)
+            if (intrinsic != null) {
+                return SMAPAndMethodNode(intrinsic, createDefaultFakeSMAP())
+            }
+
+            val asmMethod = if (callDefault)
+                state.typeMapper.mapDefaultMethod(functionDescriptor, sourceCompilerForInline.contextKind)
+            else
+                mangleSuspendInlineFunctionAsmMethodIfNeeded(functionDescriptor, jvmSignature.asmMethod)
+
+            val directMember = getDirectMemberAndCallableFromObject(functionDescriptor)
+            if (!isBuiltInArrayIntrinsic(functionDescriptor) && directMember !is DescriptorWithContainerSource) {
+                val node = sourceCompilerForInline.doCreateMethodNodeFromSource(functionDescriptor, jvmSignature, callDefault, asmMethod)
+                node.node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false)
+                return node
+            }
+
+            return getCompiledMethodNodeInner(functionDescriptor, directMember, asmMethod, methodOwner, state, jvmSignature)
+        }
+
         internal fun createSpecialInlineMethodNodeFromBinaries(functionDescriptor: FunctionDescriptor, state: GenerationState): MethodNode {
             val directMember = getDirectMemberAndCallableFromObject(functionDescriptor)
             assert(directMember is DescriptorWithContainerSource) {
@@ -582,8 +577,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
                         doCreateMethodNodeFromCompiled(directMember, state, jvmSignature.asmMethod)
                     else
                         null
-                result ?:
-                throw IllegalStateException("Couldn't obtain compiled function body for $functionDescriptor")
+                result ?: throw IllegalStateException("Couldn't obtain compiled function body for $functionDescriptor")
             }
 
             return SMAPAndMethodNode(cloneMethodNode(resultInCache.node), resultInCache.classSMAP)

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
@@ -15,6 +16,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 
 class InlineCodegenForDefaultBody(
@@ -39,10 +41,8 @@ class InlineCodegenForDefaultBody(
     }
 
     override fun genCallInner(callableMethod: Callable, resolvedCall: ResolvedCall<*>?, callDefault: Boolean, codegen: ExpressionCodegen) {
-        val nodeAndSmap = PsiInlineCodegen(
-            codegen, state, function, methodOwner, jvmSignature, TypeParameterMappings(), sourceCompilerForInline
-        ).createInlineMethodNode(
-            callDefault, null, codegen.typeSystem
+        val nodeAndSmap = InlineCodegen.createInlineMethodNode(
+            function, methodOwner, jvmSignature, callDefault, null, codegen.typeSystem, state, sourceCompilerForInline
         )
         val childSourceMapper = SourceMapCopier(sourceMapper, nodeAndSmap.classSMAP)
 

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

@@ -137,8 +137,7 @@ abstract class DefaultLambda(
     override val isSuspend = parameterDescriptor.isSuspendLambda
 
     override fun generateLambdaBody(sourceCompiler: SourceCompilerForInline, reifiedTypeInliner: ReifiedTypeInliner<*>) {
-        val classBytes = loadClassBytesByInternalName(sourceCompiler.state, lambdaClassType.internalName)
-        val classReader = ClassReader(classBytes)
+        val classReader = buildClassReaderByInternalName(sourceCompiler.state, lambdaClassType.internalName)
         var isPropertyReference = false
         var isFunctionReference = false
         classReader.accept(object : ClassVisitor(Opcodes.API_VERSION) {
@@ -163,7 +162,12 @@ abstract class DefaultLambda(
         }
 
         val descriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
-        val constructor = getMethodNode(classBytes, "<init>", descriptor, lambdaClassType)?.node
+        val constructor = getMethodNode(
+            classReader.b,
+            "<init>",
+            descriptor,
+            lambdaClassType
+        )?.node
 
         assert(constructor != null || capturedArgs.isEmpty()) {
             "Can't find non-default constructor <init>$descriptor for default lambda $lambdaClassType"
@@ -186,8 +190,13 @@ abstract class DefaultLambda(
 
         val signature = mapAsmSignature(sourceCompiler)
 
-        node = getMethodNode(classBytes, methodName, signature.descriptor, lambdaClassType, signatureAmbiguity = true)
-            ?: error("Can't find method '$methodName$signature' in '${classReader.className}'")
+        node = getMethodNode(
+            classReader.b,
+            methodName,
+            signature.descriptor,
+            lambdaClassType,
+            signatureAmbiguity = true
+        ) ?: error("Can't find method '$methodName$signature' in '${classReader.className}'")
 
         invokeMethod = Method(node.node.name, node.node.desc)
 

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

@@ -46,8 +46,9 @@ abstract class ObjectTransformer<out T : TransformationInfo>(@JvmField val trans
         )
     }
 
-    fun createClassReader(): ClassReader =
-        ClassReader(loadClassBytesByInternalName(state, transformationInfo.oldClassName))
+    fun createClassReader(): ClassReader {
+        return buildClassReaderByInternalName(state, transformationInfo.oldClassName)
+    }
 }
 
 class WhenMappingTransformer(

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

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getMethodAsmFlags
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
@@ -26,7 +25,6 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil.isInlinableParameterExpres
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
@@ -210,7 +208,4 @@ class PsiInlineCodegen(
             ::PsiDefaultLambda
         )
     }
-
-    override fun descriptorIsDeserialized(memberDescriptor: CallableMemberDescriptor): Boolean =
-        memberDescriptor is DescriptorWithContainerSource
 }

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

@@ -130,9 +130,7 @@ fun <T, R : DefaultLambda> expandMaskConditionsAndUpdateVariableNodes(
         node.instructions.insert(position, newInsn)
     }
 
-    node.localVariables.removeIf {
-        (it.start in toDelete && it.end in toDelete) || defaultLambdas.contains(it.index)
-    }
+    node.localVariables.removeIf { it.start in toDelete && it.end in toDelete }
 
     node.remove(toDelete)
 

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

@@ -346,16 +346,16 @@ internal val AbstractInsnNode?.insnText: String
 internal val AbstractInsnNode?.insnOpcodeText: String
     get() = if (this == null) "null" else Printer.OPCODES[opcode]
 
-internal fun loadClassBytesByInternalName(state: GenerationState, internalName: String): ByteArray {
+internal fun buildClassReaderByInternalName(state: GenerationState, internalName: String): ClassReader {
     //try to find just compiled classes then in dependencies
-    val outputFile = state.factory.get("$internalName.class")
+    val outputFile = state.factory.get(internalName + ".class")
     if (outputFile != null) {
-        return outputFile.asByteArray()
+        return ClassReader(outputFile.asByteArray())
     }
 
-    val file = findVirtualFileImprecise(state, internalName) ?: throw RuntimeException("Couldn't find virtual file for $internalName")
+    val file = findVirtualFileImprecise(state, internalName) ?: throw RuntimeException("Couldn't find virtual file for " + internalName)
 
-    return file.contentsToByteArray()
+    return ClassReader(file.contentsToByteArray())
 }
 
 fun generateFinallyMarker(v: InstructionAdapter, depth: Int, start: Boolean) {

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

@@ -6,7 +6,10 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
@@ -41,10 +44,6 @@ fun CallableDescriptor.isGenericParameter(): Boolean {
 fun classFileContainsMethod(descriptor: FunctionDescriptor, state: GenerationState, method: Method): Boolean? {
     if (descriptor !is DeserializedSimpleFunctionDescriptor) return null
 
-    if (descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-        return descriptor.overriddenDescriptors.any { classFileContainsMethod(it, state, method) == true }
-    }
-
     val classId: ClassId = when {
         descriptor.containingDeclaration is DeserializedClassDescriptor -> {
             (descriptor.containingDeclaration as DeserializedClassDescriptor).classId ?: return null

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java

@@ -17,10 +17,11 @@
 package org.jetbrains.kotlin.codegen.intrinsics;
 
 import com.google.common.collect.ImmutableList;
+import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.PrimitiveType;
 import org.jetbrains.kotlin.builtins.StandardNames;
+import org.jetbrains.kotlin.builtins.PrimitiveType;
 import org.jetbrains.kotlin.codegen.AsmUtil;
 import org.jetbrains.kotlin.config.JvmTarget;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
@@ -29,7 +30,6 @@ import org.jetbrains.kotlin.name.FqNameUnsafe;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.types.expressions.OperatorConventions;
-import org.jetbrains.kotlin.util.capitalizeDecapitalize.CapitalizeDecapitalizeKt;
 import org.jetbrains.org.objectweb.asm.Type;
 
 import static org.jetbrains.kotlin.builtins.StandardNames.*;
@@ -122,9 +122,7 @@ public class IntrinsicMethods {
             declareIntrinsicFunction(typeFqName, "toString", 0, TO_STRING);
 
             intrinsicsMap.registerIntrinsic(
-                    BUILT_INS_PACKAGE_FQ_NAME, null,
-                    CapitalizeDecapitalizeKt.decapitalizeAsciiOnly(type.getArrayTypeName().asString()) + "Of",
-                    1, new ArrayOf()
+                    BUILT_INS_PACKAGE_FQ_NAME, null, StringsKt.decapitalize(type.getArrayTypeName().asString()) + "Of", 1, new ArrayOf()
             );
         }
 

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

@@ -8,4 +8,4 @@ package org.jetbrains.kotlin.codegen.optimization.common
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 
-typealias TypeAnnotatedFrames = Array<Frame<BasicValue>>
+typealias TypeAnnotatedFrames = Array<Frame<BasicValue>?>

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

@@ -8,4 +8,4 @@ package org.jetbrains.kotlin.codegen.optimization.common
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 
-typealias TypeAnnotatedFrames = Array<Frame<BasicValue>?>
+typealias TypeAnnotatedFrames = Array<Frame<BasicValue>>

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

@@ -119,20 +119,6 @@ fun MethodNode.removeEmptyCatchBlocks() {
 
 fun MethodNode.removeUnusedLocalVariables() {
     val used = BooleanArray(maxLocals) { false }
-
-    // Arguments are always used whether or not they are in the local variable table
-    // or used by instructions.
-    var argumentIndex = 0
-    val isStatic = (access and Opcodes.ACC_STATIC) != 0
-    if (!isStatic) {
-        used[argumentIndex++] = true
-    }
-    for (argumentType in Type.getArgumentTypes(desc)) {
-        for (i in 0 until argumentType.size) {
-            used[argumentIndex++] = true
-        }
-    }
-
     for (insn in instructions) {
         when (insn) {
             is VarInsnNode -> {

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

@@ -108,7 +108,7 @@ class GenerationState private constructor(
         fun wantsDiagnostics(v: Boolean) =
             apply { wantsDiagnostics = v }
 
-        private var jvmBackendClassResolver: JvmBackendClassResolver = JvmBackendClassResolverForModuleWithDependencies(module)
+        var jvmBackendClassResolver: JvmBackendClassResolver = JvmBackendClassResolverForModuleWithDependencies(module); private set
         fun jvmBackendClassResolver(v: JvmBackendClassResolver) =
             apply { jvmBackendClassResolver = v }
 
@@ -153,10 +153,8 @@ class GenerationState private constructor(
     val deserializationConfiguration: DeserializationConfiguration =
         CompilerDeserializationConfiguration(configuration.languageVersionSettings)
 
-    val deprecationProvider = DeprecationResolver(
-        LockBasedStorageManager.NO_LOCKS, configuration.languageVersionSettings, CoroutineCompatibilitySupport.ENABLED,
-        JavaDeprecationSettings
-    )
+    val deprecationProvider =
+        DeprecationResolver(LockBasedStorageManager.NO_LOCKS, configuration.languageVersionSettings, CoroutineCompatibilitySupport.ENABLED, JavaDeprecationSettings)
 
     init {
         val icComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
@@ -203,7 +201,7 @@ class GenerationState private constructor(
 
     val target = configuration.get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT
     val runtimeStringConcat =
-        if (target.majorVersion >= JvmTarget.JVM_9.majorVersion)
+        if (target.bytecodeVersion >= JvmTarget.JVM_9.bytecodeVersion)
             configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INLINE
         else JvmStringConcat.INLINE
 
@@ -252,7 +250,6 @@ class GenerationState private constructor(
     class ForScript {
         // quite a mess, this one is an input from repl interpreter
         var earlierScriptsForReplInterpreter: List<ScriptDescriptor>? = null
-
         // and the rest is an output from the codegen
         var resultFieldName: String? = null
         var resultTypeString: String? = null
@@ -275,10 +272,7 @@ class GenerationState private constructor(
 
     val rootContext: CodegenContext<*> = RootContext(this)
 
-    val classFileVersion: Int = run {
-        val minorVersion = if (configuration.getBoolean(JVMConfigurationKeys.ENABLE_JVM_PREVIEW)) 0xffff else 0
-        (minorVersion shl 16) + target.majorVersion
-    }
+    val classFileVersion: Int = target.bytecodeVersion
 
     val generateParametersMetadata: Boolean = configuration.getBoolean(JVMConfigurationKeys.PARAMETERS_METADATA)
 
@@ -301,7 +295,7 @@ class GenerationState private constructor(
             ?: if (languageVersionSettings.languageVersion >= LanguageVersion.LATEST_STABLE) JvmMetadataVersion.INSTANCE
             else JvmMetadataVersion(1, 1, 18)
 
-    val abiStability = configuration.get(JVMConfigurationKeys.ABI_STABILITY)
+    val isIrWithStableAbi = configuration.getBoolean(JVMConfigurationKeys.IS_IR_WITH_STABLE_ABI)
 
     val globalSerializationBindings = JvmSerializationBindings()
     var mapInlineClass: (ClassDescriptor) -> Type = { descriptor -> typeMapper.mapType(descriptor.defaultType) }
@@ -349,7 +343,7 @@ class GenerationState private constructor(
     fun beforeCompile() {
         markUsed()
 
-        if (!isIrBackend) {
+        if (!isIrBackend || languageVersionSettings.getFlag(JvmAnalysisFlags.irCheckLocalNames)) {
             CodegenBinding.initTrace(this)
         }
     }

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

@@ -5,4 +5,4 @@
 
 package org.jetbrains.kotlin.codegen.state
 
-typealias JvmMethodExceptionTypes = Array<out String?>?
+typealias JvmMethodExceptionTypes = Array<out String>?

compiler/backend/src/org/jetbrains/kotlin/codegen/state/JvmMethodExceptionTypes.kt.202

@@ -5,4 +5,4 @@
 
 package org.jetbrains.kotlin.codegen.state
 
-typealias JvmMethodExceptionTypes = Array<out String>?
+typealias JvmMethodExceptionTypes = Array<out String?>?

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

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
-import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.getImplClassNameForDeserialized
 import org.jetbrains.kotlin.load.java.getJvmMethodNameIfSpecial
 import org.jetbrains.kotlin.load.java.getOverriddenBuiltinReflectingJvmDescriptor
@@ -51,7 +50,6 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.BindingContextUtils.getDelegationConstructorCall
 import org.jetbrains.kotlin.resolve.BindingContextUtils.isBoxedLocalCapturedInClosure
 import org.jetbrains.kotlin.resolve.DescriptorUtils.*
-import org.jetbrains.kotlin.resolve.annotations.hasJvmStaticAnnotation
 import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -62,7 +60,6 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isPublishedApi
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.DEFAULT_CONSTRUCTOR_MARKER
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
-import org.jetbrains.kotlin.resolve.jvm.JAVA_LANG_RECORD_FQ_NAME
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefault
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature
@@ -382,8 +379,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
             val originalDescriptor = descriptor.original
             return CallableMethod(
                 owner, owner, { mapDefaultMethod(originalDescriptor, OwnerKind.IMPLEMENTATION) }, method, INVOKESPECIAL,
-                null, null, null, null, null, originalDescriptor.returnType, isInterfaceMethod = false, isDefaultMethodInInterface = false,
-                boxInlineClassBeforeInvoke = false
+                null, null, null, null, null, originalDescriptor.returnType, isInterfaceMethod = false, isDefaultMethodInInterface = false
             )
         }
 
@@ -406,7 +402,6 @@ class KotlinTypeMapper @JvmOverloads constructor(
         val dispatchReceiverKotlinType: KotlinType?
         var isInterfaceMember = false
         var isDefaultMethodInInterface = false
-        var boxInlineClassBeforeInvoke = false
 
         if (functionParent is ClassDescriptor) {
             val declarationFunctionDescriptor = findAnyDeclaration(functionDescriptor)
@@ -457,15 +452,11 @@ class KotlinTypeMapper @JvmOverloads constructor(
                     functionDescriptor = descriptor
                 }
 
-                val isFakeOverrideOfJvmDefault = toInlinedErasedClass &&
-                        functionDescriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE &&
-                        functionDescriptor.overridesJvmDefault()
-
-                val isStaticInvocation = !isFakeOverrideOfJvmDefault &&
-                        (isStaticDeclaration(functionDescriptor) && functionDescriptor !is ImportedFromObjectCallableDescriptor<*> ||
-                                isStaticAccessor(functionDescriptor) ||
-                                functionDescriptor.isJvmStaticInObjectOrClassOrInterface() ||
-                                toInlinedErasedClass)
+                val isStaticInvocation =
+                    isStaticDeclaration(functionDescriptor) && functionDescriptor !is ImportedFromObjectCallableDescriptor<*> ||
+                            isStaticAccessor(functionDescriptor) ||
+                            functionDescriptor.isJvmStaticInObjectOrClassOrInterface() ||
+                            toInlinedErasedClass
                 when {
                     isStaticInvocation -> {
                         invokeOpcode = INVOKESTATIC
@@ -475,13 +466,8 @@ class KotlinTypeMapper @JvmOverloads constructor(
                         invokeOpcode = INVOKEINTERFACE
                         isInterfaceMember = true
                     }
-                    isFakeOverrideOfJvmDefault -> {
-                        invokeOpcode = INVOKEVIRTUAL
-                        boxInlineClassBeforeInvoke = true
-                    }
                     else -> {
-                        val isPrivateFunInvocation =
-                            DescriptorVisibilities.isPrivate(functionDescriptor.visibility) && !functionDescriptor.isSuspend
+                        val isPrivateFunInvocation = DescriptorVisibilities.isPrivate(functionDescriptor.visibility) && !functionDescriptor.isSuspend
                         invokeOpcode = if (superCall || isPrivateFunInvocation) INVOKESPECIAL else INVOKEVIRTUAL
                         isInterfaceMember = false
                     }
@@ -493,7 +479,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
                 else
                     functionDescriptor.original
 
-                signature = if (toInlinedErasedClass && !isFakeOverrideOfJvmDefault)
+                signature = if (toInlinedErasedClass)
                     mapSignatureForInlineErasedClassSkipGeneric(functionToCall)
                 else
                     mapSignature(
@@ -561,18 +547,10 @@ class KotlinTypeMapper @JvmOverloads constructor(
             signature, invokeOpcode, thisClass, dispatchReceiverKotlinType, receiverParameterType, extensionReceiverKotlinType,
             calleeType, returnKotlinType,
             if (jvmTarget >= JvmTarget.JVM_1_8) isInterfaceMember else invokeOpcode == INVOKEINTERFACE,
-            isDefaultMethodInInterface, boxInlineClassBeforeInvoke
+            isDefaultMethodInInterface
         )
     }
 
-    private fun CallableMemberDescriptor.overridesJvmDefault(): Boolean {
-        if (kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-            return overriddenDescriptors.any { it.overridesJvmDefault() }
-        }
-        if (isCompiledToJvmDefault(jvmDefaultMode)) return true
-        return (containingDeclaration as? JavaClassDescriptor)?.kind == ClassKind.INTERFACE && modality != Modality.ABSTRACT
-    }
-
     fun mapFunctionName(descriptor: FunctionDescriptor, kind: OwnerKind?): String {
         if (descriptor !is JavaCallableMemberDescriptor) {
             val platformName = getJvmName(descriptor)
@@ -585,16 +563,10 @@ class KotlinTypeMapper @JvmOverloads constructor(
         return when {
             descriptor is PropertyAccessorDescriptor -> {
                 val property = descriptor.correspondingProperty
-                val containingDeclaration = property.containingDeclaration
-
-                if (isAnnotationClass(containingDeclaration) &&
-                    (!property.hasJvmStaticAnnotation() && !descriptor.hasJvmStaticAnnotation())
-                ) {
+                if (isAnnotationClass(property.containingDeclaration)) {
                     return property.name.asString()
                 }
 
-                if ((containingDeclaration as? ClassDescriptor)?.hasJavaLangRecordSupertype() == true) return property.name.asString()
-
                 val isAccessor = property is AccessorForPropertyDescriptor
                 val propertyName = if (isAccessor)
                     (property as AccessorForPropertyDescriptor).accessorSuffix
@@ -629,9 +601,6 @@ class KotlinTypeMapper @JvmOverloads constructor(
         }
     }
 
-    private fun ClassDescriptor.hasJavaLangRecordSupertype() =
-        typeConstructor.supertypes.any { KotlinBuiltIns.isConstructedFromGivenClass(it, JAVA_LANG_RECORD_FQ_NAME) }
-
     private val shouldMangleByReturnType =
         languageVersionSettings.supportsFeature(LanguageFeature.MangleClassMembersReturningInlineClasses)
 
@@ -996,8 +965,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
         if ((isFunctionExpression(descriptor) || isFunctionLiteral(descriptor)) && returnType.isInlineClassType()) return true
 
         return isJvmPrimitive(returnType) &&
-                getAllOverriddenDescriptors(descriptor).any { !isJvmPrimitive(it.returnType!!) } ||
-                returnType.isInlineClassType() && descriptor is JavaMethodDescriptor
+                getAllOverriddenDescriptors(descriptor).any { !isJvmPrimitive(it.returnType!!) }
     }
 
     private fun isJvmPrimitive(kotlinType: KotlinType) =
@@ -1063,11 +1031,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
 
     fun writeParameterType(sw: JvmSignatureWriter, type: KotlinType, callableDescriptor: CallableDescriptor?) {
         if (sw.skipGenericSignature()) {
-            if (type.isInlineClassType() && callableDescriptor is JavaMethodDescriptor) {
-                mapType(type, sw, TypeMappingMode.GENERIC_ARGUMENT)
-            } else {
-                mapType(type, sw, TypeMappingMode.DEFAULT)
-            }
+            mapType(type, sw, TypeMappingMode.DEFAULT)
             return
         }
 

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.codegen.state
 
 import org.jetbrains.kotlin.codegen.coroutines.unwrapInitialDescriptorForSuspendFunction
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver
@@ -85,7 +84,6 @@ fun getManglingSuffixBasedOnKotlinSignature(
 ): String? {
     if (descriptor !is FunctionDescriptor) return null
     if (descriptor is ConstructorDescriptor) return null
-    if (descriptor is JavaMethodDescriptor) return null
     if (InlineClassDescriptorResolver.isSynthesizedBoxOrUnboxMethod(descriptor)) return null
 
     // Don't mangle functions with '@JvmName' annotation.

compiler/build.gradle.kts

@@ -10,8 +10,6 @@ plugins {
 val compilerModules: Array<String> by rootProject.extra
 val otherCompilerModules = compilerModules.filter { it != path }
 
-val tasksWithWarnings: List<String> by rootProject.extra
-
 val effectSystemEnabled: Boolean by rootProject.extra
 val newInferenceEnabled: Boolean by rootProject.extra
 
@@ -48,7 +46,7 @@ dependencies {
     testCompile(projectTests(":compiler:fir:raw-fir:psi2fir"))
     testCompile(projectTests(":compiler:fir:raw-fir:light-tree2fir"))
     testCompile(projectTests(":compiler:fir:fir2ir"))
-    testCompile(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testCompile(projectTests(":compiler:fir:analysis-tests"))
     testCompile(projectTests(":compiler:visualizer"))
     testCompile(projectTests(":generators:test-generator"))
     testCompile(project(":compiler:ir.ir2cfg"))
@@ -87,16 +85,6 @@ if (kotlinBuildProperties.isInJpsBuildIdeaSync) {
     idea {
         this.module.generatedSourceDirs.add(generationRoot)
     }
-} else {
-    allprojects {
-        tasks.withType<KotlinCompile<*>> {
-            if (path !in tasksWithWarnings) {
-                kotlinOptions {
-                    allWarningsAsErrors = true
-                }
-            }
-        }
-    }
 }
 
 projectTest(parallel = true) {
@@ -110,6 +98,6 @@ projectTest(parallel = true) {
     }
 }
 
-val generateTestData by generator("org.jetbrains.kotlin.generators.tests.GenerateCompilerTestDataKt")
+val generateTests by generator("org.jetbrains.kotlin.generators.tests.GenerateCompilerTestsKt")
 
 testsJar()

compiler/cli/bin/kotlinc.bat

@@ -49,7 +49,6 @@ if "%_KOTLIN_RUNNER%"=="1" (
   "%_JAVACMD%" %JAVA_OPTS% "-Dkotlin.home=%_KOTLIN_HOME%" -cp "%_KOTLIN_HOME%\lib\kotlin-runner.jar" ^
     org.jetbrains.kotlin.runner.Main %KOTLIN_OPTS%
 ) else (
-  setlocal EnableDelayedExpansion
   SET _ADDITIONAL_CLASSPATH=
 
   if not "%_KOTLIN_TOOL%"=="" (
@@ -57,7 +56,7 @@ if "%_KOTLIN_RUNNER%"=="1" (
   )
 
   "%_JAVACMD%" %JAVA_OPTS% -noverify -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^
-    org.jetbrains.kotlin.preloading.Preloader -cp "%_KOTLIN_HOME%\lib\kotlin-compiler.jar!_ADDITIONAL_CLASSPATH!" ^
+    org.jetbrains.kotlin.preloading.Preloader -cp "%_KOTLIN_HOME%\lib\kotlin-compiler.jar%_ADDITIONAL_CLASSPATH%" ^
     %_KOTLIN_COMPILER% %KOTLIN_OPTS%
 )
 

compiler/cli/build.gradle.kts

@@ -57,7 +57,7 @@ tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinCompile<*>> {
     kotlinOptions {
         languageVersion = "1.3"
         apiVersion = "1.3"
-        freeCompilerArgs = freeCompilerArgs - "-progressive" + "-Xskip-prerelease-check"
+        freeCompilerArgs += "-Xskip-prerelease-check"
     }
 }
 

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

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

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

@@ -121,6 +121,13 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var intellijPluginRoot: String? by NullableStringFreezableVar(null)
 
+    @Argument(
+        value = "-Xcoroutines",
+        valueDescription = "{enable|warn|error}",
+        description = "Enable coroutines or report warnings or errors on declarations and use sites of 'suspend' modifier"
+    )
+    var coroutinesState: String? by NullableStringFreezableVar(DEFAULT)
+
     @Argument(
         value = "-Xnew-inference",
         description = "Enable new experimental generic type inference algorithm"
@@ -378,6 +385,17 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
                 put(LanguageFeature.MultiPlatformProjects, LanguageFeature.State.ENABLED)
             }
 
+            when (coroutinesState) {
+                CommonCompilerArguments.ERROR -> put(LanguageFeature.Coroutines, LanguageFeature.State.ENABLED_WITH_ERROR)
+                CommonCompilerArguments.ENABLE -> put(LanguageFeature.Coroutines, LanguageFeature.State.ENABLED)
+                CommonCompilerArguments.WARN, CommonCompilerArguments.DEFAULT -> {
+                }
+                else -> {
+                    val message = "Invalid value of -Xcoroutines (should be: enable, warn or error): " + coroutinesState
+                    collector.report(CompilerMessageSeverity.ERROR, message, null)
+                }
+            }
+
             if (newInference) {
                 put(LanguageFeature.NewInference, LanguageFeature.State.ENABLED)
                 put(LanguageFeature.SamConversionPerArgument, LanguageFeature.State.ENABLED)
@@ -507,6 +525,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
             configureLanguageFeatures(collector)
         )
 
+        checkCoroutines(languageVersionSettings, collector)
         checkIrSupport(languageVersionSettings, collector)
 
         return languageVersionSettings
@@ -577,6 +596,17 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
         }
     }
 
+    private fun checkCoroutines(languageVersionSettings: LanguageVersionSettings, collector: MessageCollector) {
+        if (languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)) {
+            if (coroutinesState != DEFAULT) {
+                collector.report(
+                    CompilerMessageSeverity.STRONG_WARNING,
+                    "-Xcoroutines has no effect: coroutines are enabled anyway in 1.3 and beyond"
+                )
+            }
+        }
+    }
+
     protected open fun checkIrSupport(languageVersionSettings: LanguageVersionSettings, collector: MessageCollector) {
         // backend-specific
     }

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

@@ -85,25 +85,28 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xuse-ir", description = "Use the IR backend")
     var useIR: Boolean by FreezableVar(false)
 
-    @GradleOption(DefaultValues.BooleanFalseDefault::class)
-    @Argument(value = "-Xuse-old-backend", description = "Use the old JVM backend")
-    var useOldBackend: Boolean by FreezableVar(false)
+    @Argument(value = "-Xno-use-ir", description = "Do not use the IR backend. Useful for a custom-built compiler where IR backend is enabled by default")
+    var noUseIR: Boolean by FreezableVar(false)
 
     @Argument(
-        value = "-Xallow-unstable-dependencies",
-        description = "Do not report errors on classes in dependencies, which were compiled by an unstable version of the Kotlin compiler"
+        value = "-Xir-check-local-names",
+        description = "Check that names of local classes and anonymous objects are the same in the IR backend as in the old backend"
     )
-    var allowUnstableDependencies: Boolean by FreezableVar(false)
+    var irCheckLocalNames: Boolean by FreezableVar(false)
 
     @Argument(
-        value = "-Xabi-stability",
-        valueDescription = "{stable|unstable}",
-        description = "When using unstable compiler features such as FIR, use 'stable' to mark generated class files as stable\n" +
-                "to prevent diagnostics from stable compilers at the call site.\n" +
-                "When using the JVM IR backend, conversely, use 'unstable' to mark generated class files as unstable\n" +
-                "to force diagnostics to be reported."
+        value = "-Xallow-jvm-ir-dependencies",
+        description = "When not using the IR backend, do not report errors on those classes in dependencies, " +
+                "which were compiled by the IR backend"
     )
-    var abiStability: String? by FreezableVar(null)
+    var allowJvmIrDependencies: Boolean by FreezableVar(false)
+
+    @Argument(
+        value = "-Xir-binary-with-stable-abi",
+        description = "When using the IR backend, produce binaries which can be read by non-IR backend.\n" +
+                "The author is responsible for verifying that the resulting binaries do indeed have the correct ABI"
+    )
+    var isIrWithStableAbi: Boolean by FreezableVar(false)
 
     @Argument(
         value = "-Xir-do-not-clear-binding-context",
@@ -309,13 +312,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var jvmDefault: String by FreezableVar(JvmDefaultMode.DEFAULT.description)
 
-    @Argument(
-        value = "-Xdefault-script-extension",
-        valueDescription = "<script filename extension>",
-        description = "Compile expressions and unrecognized scripts passed with the -script argument as scripts with given filename extension"
-    )
-    var defaultScriptExtension: String? by FreezableVar(null)
-
     @Argument(value = "-Xdisable-standard-script", description = "Disable standard kotlin script support")
     var disableStandardScript: Boolean by FreezableVar(false)
 
@@ -422,13 +418,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var useOldInlineClassesManglingScheme: Boolean by FreezableVar(false)
 
-    @Argument(
-        value = "-Xjvm-enable-preview",
-        description = "Allow using features from Java language that are in preview phase.\n" +
-                "Works as `--enable-preview` in Java. All class files are marked as preview-generated thus it won't be possible to use them in release environment"
-    )
-    var enableJvmPreview: Boolean by FreezableVar(false)
-
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics
@@ -448,8 +437,8 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
         result[JvmAnalysisFlags.inheritMultifileParts] = inheritMultifileParts
         result[JvmAnalysisFlags.sanitizeParentheses] = sanitizeParentheses
         result[JvmAnalysisFlags.suppressMissingBuiltinsError] = suppressMissingBuiltinsError
-        result[JvmAnalysisFlags.enableJvmPreview] = enableJvmPreview
-        result[AnalysisFlags.allowUnstableDependencies] = allowUnstableDependencies || useFir
+        result[JvmAnalysisFlags.irCheckLocalNames] = irCheckLocalNames
+        result[AnalysisFlags.reportErrorsOnIrDependencies] = !useIR && !useFir && !allowJvmIrDependencies
         result[JvmAnalysisFlags.disableUltraLightClasses] = disableUltraLightClasses
         return result
     }
@@ -463,7 +452,7 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     }
 
     override fun checkIrSupport(languageVersionSettings: LanguageVersionSettings, collector: MessageCollector) {
-        if (!useIR || useOldBackend) return
+        if (!useIR) return
 
         if (languageVersionSettings.languageVersion < LanguageVersion.KOTLIN_1_3
             || languageVersionSettings.apiVersion < ApiVersion.KOTLIN_1_3

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/Main.kt

@@ -34,36 +34,22 @@ object Main {
         KOTLIN_HOME = File(home)
     }
 
-    enum class HowToRun(val argName: String) {
-        GUESS("guess"),
-        CLASSFILE("classfile"),
-        JAR("jar"),
-        SCRIPT("script");
-        // TODO: consider implementing REPL as well
-
-        companion object {
-            val validValues = "${GUESS.argName} (default), ${CLASSFILE.argName}, ${JAR.argName}, ${SCRIPT.argName} (or .<script filename extension>)"
-
-            fun fromArg(name: String): HowToRun? =
-                HowToRun.values().find { it.argName == name }
-        }
-    }
-
     private fun run(args: Array<String>) {
         val classpath = arrayListOf<URL>()
         val compilerClasspath = arrayListOf<URL>()
         var runner: Runner? = null
+        var collectingArguments = false
+        var collectingExpressions = false
+        var needsCompiler = false
         val arguments = arrayListOf<String>()
-        val compilerArguments = arrayListOf<String>()
-        var noStdLib = false
+        var expression: String? = null
         var noReflect = false
-        var howtorun = HowToRun.GUESS
 
-        fun setRunner(newRunner: Runner) {
-            if (runner == null) {
-                runner = newRunner
+        fun setExpression(expr: String) {
+            if (expression == null) {
+                expression = expr
             } else {
-                throw AssertionError("conflicting runner settings")
+                throw RunnerException("Only single -e/-expression argument supported")
             }
         }
 
@@ -78,8 +64,20 @@ object Main {
                 return args[i]
             }
 
-            fun restAsArguments() {
-                arguments.addAll(args.copyOfRange(i+1, args.size))
+            if (collectingExpressions) {
+                if ("-expression" == arg || "-e" == arg) {
+                    setExpression(next())
+                    i++
+                    continue
+                } else {
+                    collectingArguments = true
+                }
+            }
+
+            if (collectingArguments) {
+                arguments.add(arg)
+                i++
+                continue
             }
 
             if ("-help" == arg || "-h" == arg) {
@@ -98,55 +96,29 @@ object Main {
                     compilerClasspath.addPath(path)
                 }
             }
-            else if ("-howtorun" == arg) {
-                if (howtorun != HowToRun.GUESS) {
-                    throw RunnerException("-howtorun is already set to ${howtorun.argName}")
-                }
-                val howToRunArg = next()
-                if (howToRunArg.startsWith(".")) {
-                    howtorun = HowToRun.SCRIPT
-                    compilerArguments.add("-Xdefault-script-extension=$howToRunArg")
-                } else {
-                    howtorun = HowToRun.fromArg(howToRunArg)
-                        ?: throw RunnerException("invalid argument to the option -howtorun $howToRunArg, valid arguments are: ${HowToRun.validValues}")
-                }
-            }
             else if ("-expression" == arg || "-e" == arg) {
-                if (howtorun != HowToRun.GUESS && howtorun != HowToRun.SCRIPT) {
-                    throw RunnerException("expression evaluation is not compatible with -howtorun argument ${howtorun.argName}")
-                }
-                setRunner(ExpressionRunner(next()))
-                restAsArguments()
-                break
-            }
-            else if ("-no-stdlib" == arg) {
-                noStdLib = true
-                compilerArguments.add(arg)
+                setExpression(next())
+                collectingExpressions = true
+                needsCompiler = true
             }
             else if ("-no-reflect" == arg) {
                 noReflect = true
-                compilerArguments.add(arg)
-            }
-            else if (arg.startsWith("-X")) {
-                compilerArguments.add(arg)
             }
             else if (arg.startsWith("-")) {
-                throw RunnerException("unknown option: $arg")
+                throw RunnerException("unsupported argument: $arg")
             }
-            else if (howtorun == HowToRun.JAR || (howtorun == HowToRun.GUESS && arg.endsWith(".jar"))) {
-                setRunner(JarRunner(arg))
-                restAsArguments()
-                break
+            else if (arg.endsWith(".jar")) {
+                runner = JarRunner(arg)
+                collectingArguments = true
             }
-            else if (howtorun == HowToRun.SCRIPT || (howtorun == HowToRun.GUESS && arg.endsWith(".kts"))) {
-                setRunner(ScriptRunner(arg))
-                restAsArguments()
-                break
+            else if (arg.endsWith(".kts")) {
+                runner = ScriptRunner(arg)
+                collectingArguments = true
+                needsCompiler = true
             }
             else {
-                setRunner(MainClassRunner(arg))
-                restAsArguments()
-                break
+                runner = MainClassRunner(arg)
+                collectingArguments = true
             }
             i++
         }
@@ -155,25 +127,26 @@ object Main {
             classpath.addPath(".")
         }
 
-        if (!noStdLib) {
-            classpath.addPath("$KOTLIN_HOME/lib/kotlin-stdlib.jar")
-        }
+        classpath.addPath("$KOTLIN_HOME/lib/kotlin-stdlib.jar")
 
         if (!noReflect) {
             classpath.addPath("$KOTLIN_HOME/lib/kotlin-reflect.jar")
         }
 
-        if (runner == null) {
-            setRunner(ReplRunner())
+        if (expression != null) {
+            runner = ExpressionRunner(expression!!)
+        } else if (runner == null) {
+            runner = ReplRunner()
+            needsCompiler = true
         }
 
-        if (runner is RunnerWithCompiler && compilerClasspath.isEmpty()) {
+        if (needsCompiler && compilerClasspath.isEmpty()) {
             findCompilerJar(this::class.java, KOTLIN_HOME.resolve("lib")).forEach {
                 compilerClasspath.add(it.absoluteFile.toURI().toURL())
             }
         }
 
-        runner!!.run(classpath, compilerArguments, arguments, compilerClasspath)
+        runner.run(classpath, arguments, compilerClasspath)
     }
 
     private fun MutableList<URL>.addPath(path: String) {
@@ -194,31 +167,21 @@ object Main {
     private fun printUsageAndExit() {
         println("""kotlin: run Kotlin programs, scripts or REPL.
 
-Usage: kotlin <options> <command> [<arguments>]
-where possible options include:
-  -howtorun <value>          How to run the supplied command with arguments, 
-                             valid values: ${HowToRun.validValues}
+Usage: kotlin <options> <command> <arguments>
+where command may be one of:
+  foo.Bar                    Runs the 'main' function from the class with the given qualified name
+  app.jar                    Runs the given JAR file as 'java -jar' would do
+                             (-classpath argument is ignored and no Kotlin runtime is added to the classpath)
+""" +
+//  script.kts                 Compiles and runs the given script
+//  -expression (-e) '2+2'     Evaluates the expression and prints the result
+"""and possible options include:
   -classpath (-cp) <path>    Paths where to find user class files
   -Dname=value               Set a system JVM property
   -J<option>                 Pass an option directly to JVM
-  -no-stdlib                 Don't include Kotlin standard library into classpath
   -no-reflect                Don't include Kotlin reflection implementation into classpath
-  -compiler-path             Kotlin compiler classpath for compiling script or expression or running REPL 
-                             If not specified, try to find the compiler in the environment
-  -X<flag>[=value]           Pass -X argument to the compiler
   -version                   Display Kotlin version
   -help (-h)                 Print a synopsis of options
-and command is interpreted according to the -howtorun option argument 
-or, in case of guess, according to the following rules:
-  foo.Bar                    Runs the 'main' function from the class with the given qualified name
-                             (compiler arguments are ignored) 
-  app.jar                    Runs the given JAR file as 'java -jar' would do
-                             (compiler arguments are ignored and no Kotlin stdlib is added to the classpath)
-  script.kts                 Compiles and runs the given script, passing <arguments> to it
-  -expression (-e) '2+2'     Evaluates the expression and prints the result, passing <arguments> to it
-  <no command>               Runs Kotlin REPL
-arguments are passed to the main function when running class or jar file, and for standard script definitions
-as the 'args' parameter when running script or expression
 """)
         exitProcess(0)
     }

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/Runner.kt

@@ -21,7 +21,6 @@ import java.net.URL
 interface Runner {
     fun run(
         classpath: List<URL>,
-        compilerArguments: List<String>,
         arguments: List<String>,
         compilerClasspath: List<URL>
     )

compiler/cli/cli-runner/src/org/jetbrains/kotlin/runner/runners.kt

@@ -32,7 +32,7 @@ abstract class AbstractRunner : Runner {
 
     protected abstract fun createClassLoader(classpath: List<URL>): ClassLoader
 
-    override fun run(classpath: List<URL>, compilerArguments: List<String>, arguments: List<String>, compilerClasspath: List<URL>) {
+    override fun run(classpath: List<URL>, arguments: List<String>, compilerClasspath: List<URL>) {
         val classLoader = createClassLoader(classpath)
 
         val mainClass = try {
@@ -127,45 +127,39 @@ private fun MutableList<String>.addClasspathArgIfNeeded(classpath: List<URL>) {
     }
 }
 
-private fun ArrayList<String>.addScriptArguments(arguments: List<String>) {
-    if (arguments.isNotEmpty() && arguments.first() != "--") {
-        add("--")
-    }
-    addAll(arguments)
-}
-
 class ReplRunner : RunnerWithCompiler() {
-    override fun run(classpath: List<URL>, compilerArguments: List<String>, arguments: List<String>, compilerClasspath: List<URL>) {
-        val compilerArgs = ArrayList<String>().apply {
-            addClasspathArgIfNeeded(classpath)
-            addAll(compilerArguments)
-            addScriptArguments(arguments)
-        }
+    override fun run(classpath: List<URL>, arguments: List<String>, compilerClasspath: List<URL>) {
+        val compilerArgs = ArrayList<String>()
+        compilerArgs.addClasspathArgIfNeeded(classpath)
         runCompiler(compilerClasspath, compilerArgs)
     }
 }
 
 class ScriptRunner(private val path: String) : RunnerWithCompiler() {
-    override fun run(classpath: List<URL>, compilerArguments: List<String>, arguments: List<String>, compilerClasspath: List<URL>) {
+    override fun run(classpath: List<URL>, arguments: List<String>, compilerClasspath: List<URL>) {
         val compilerArgs = ArrayList<String>().apply {
             addClasspathArgIfNeeded(classpath)
-            addAll(compilerArguments)
             add("-script")
             add(path)
-            addScriptArguments(arguments)
+            if (arguments.isNotEmpty() && arguments.first() != "--") {
+                add("--")
+            }
+            addAll(arguments)
         }
         runCompiler(compilerClasspath, compilerArgs)
     }
 }
 
 class ExpressionRunner(private val code: String) : RunnerWithCompiler() {
-    override fun run(classpath: List<URL>, compilerArguments: List<String>, arguments: List<String>, compilerClasspath: List<URL>) {
+    override fun run(classpath: List<URL>, arguments: List<String>, compilerClasspath: List<URL>) {
         val compilerArgs = ArrayList<String>().apply {
             addClasspathArgIfNeeded(classpath)
-            addAll(compilerArguments)
             add("-expression")
             add(code)
-            addScriptArguments(arguments)
+            if (arguments.isNotEmpty() && arguments.first() != "--") {
+                add("--")
+            }
+            addAll(arguments)
         }
         runCompiler(compilerClasspath, compilerArgs)
     }

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.kt

@@ -182,19 +182,11 @@ class AnalyzerWithCompilerReport(
                 )
             }
 
-            if (diagnostics.any { it.factory == Errors.IR_WITH_UNSTABLE_ABI_COMPILED_CLASS }) {
+            if (diagnostics.any { it.factory == Errors.IR_COMPILED_CLASS }) {
                 messageCollector.report(
                     ERROR,
-                    "Classes compiled by an unstable version of the Kotlin compiler were found in dependencies. " +
-                            "Remove them from the classpath or use '-Xallow-unstable-dependencies' to suppress errors"
-                )
-            }
-
-            if (diagnostics.any { it.factory == Errors.FIR_COMPILED_CLASS }) {
-                messageCollector.report(
-                    ERROR,
-                    "Classes compiled by the new Kotlin compiler frontend were found in dependencies. " +
-                            "Remove them from the classpath or use '-Xallow-unstable-dependencies' to suppress errors"
+                    "Classes compiled by a new Kotlin compiler backend were found in dependencies. " +
+                            "Remove them from the classpath or use '-Xallow-jvm-ir-dependencies' to suppress errors"
                 )
             }
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/DefaultDiagnosticReporter.kt.202

@@ -0,0 +1,36 @@
+/*
+ * 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.cli.common.messages
+
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
+
+/**
+ * This class behaviour is the same as [MessageCollector.report] in [AnalyzerWithCompilerReport.reportDiagnostic].
+ */
+class DefaultDiagnosticReporter(override val messageCollector: MessageCollector) : MessageCollectorBasedReporter
+
+interface MessageCollectorBasedReporter : DiagnosticMessageReporter {
+    val messageCollector: MessageCollector
+
+    override fun report(diagnostic: Diagnostic, file: PsiFile, render: String) = messageCollector.report(
+        AnalyzerWithCompilerReport.convertSeverity(diagnostic.severity),
+        render,
+        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumn(diagnostic))
+    )
+}

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/MessageUtil.java

@@ -17,6 +17,8 @@
 package org.jetbrains.kotlin.cli.common.messages;
 
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.impl.jar.CoreJarVirtualFile;
+import com.intellij.openapi.vfs.local.CoreLocalVirtualFile;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
@@ -51,6 +53,10 @@ public class MessageUtil {
 
     @NotNull
     public static String virtualFileToPath(@NotNull VirtualFile virtualFile) {
-        return toSystemDependentName(virtualFile.getPath());
+        // Convert path to platform-dependent format when virtualFile is local file.
+        if (virtualFile instanceof CoreLocalVirtualFile || virtualFile instanceof CoreJarVirtualFile) {
+            return toSystemDependentName(virtualFile.getPath());
+        }
+        return virtualFile.getPath();
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/MessageUtil.java.202

@@ -0,0 +1,54 @@
+/*
+ * 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.cli.common.messages;
+
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
+import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils;
+
+import static com.intellij.openapi.util.io.FileUtil.toSystemDependentName;
+
+public class MessageUtil {
+    private MessageUtil() {}
+
+    @Nullable
+    public static CompilerMessageLocation psiElementToMessageLocation(@Nullable PsiElement element) {
+        if (element == null) return null;
+        PsiFile file = element.getContainingFile();
+        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnInPsiFile(file, element.getTextRange()));
+    }
+
+    @Nullable
+    public static CompilerMessageLocation psiFileToMessageLocation(
+            @NotNull PsiFile file,
+            @Nullable String defaultValue,
+            @NotNull PsiDiagnosticUtils.LineAndColumn lineAndColumn
+    ) {
+        VirtualFile virtualFile = file.getVirtualFile();
+        String path = virtualFile != null ? virtualFileToPath(virtualFile) : defaultValue;
+        return CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn(), lineAndColumn.getLineContent());
+    }
+
+    @NotNull
+    public static String virtualFileToPath(@NotNull VirtualFile virtualFile) {
+        return toSystemDependentName(virtualFile.getPath());
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/PlainTextMessageRenderer.java

@@ -23,7 +23,6 @@ import org.fusesource.jansi.Ansi;
 import org.fusesource.jansi.internal.CLibrary;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.util.capitalizeDecapitalize.CapitalizeDecapitalizeKt;
 
 import java.util.EnumSet;
 import java.util.Set;
@@ -131,7 +130,7 @@ public abstract class PlainTextMessageRenderer implements MessageRenderer {
             return message;
         }
 
-        return CapitalizeDecapitalizeKt.decapitalizeAsciiOnly(message);
+        return StringsKt.decapitalize(message);
     }
 
     @NotNull

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

@@ -77,23 +77,15 @@ open class CliBindingTrace @TestOnly constructor() : BindingTraceContext() {
         this.kotlinCodeAnalyzer = kotlinCodeAnalyzer
     }
 
-    @Suppress("UNCHECKED_CAST")
     override fun <K, V> get(slice: ReadOnlySlice<K, V>, key: K): V? {
         val value = super.get(slice, key)
 
         if (value == null) {
-            if (key is KtDeclaration) {
-                // NB: intentional code duplication, see https://youtrack.jetbrains.com/issue/KT-43296
-                if (BindingContext.FUNCTION === slice) {
+            if (BindingContext.FUNCTION === slice || BindingContext.VARIABLE === slice) {
+                if (key is KtDeclaration) {
                     if (!KtPsiUtil.isLocal(key)) {
                         kotlinCodeAnalyzer!!.resolveToDescriptor(key)
-                        return super.get(slice, key) as V?
-                    }
-                }
-                if (BindingContext.VARIABLE === slice) {
-                    if (!KtPsiUtil.isLocal(key)) {
-                        kotlinCodeAnalyzer!!.resolveToDescriptor(key)
-                        return super.get(slice, key) as V?
+                        return super.get(slice, key)
                     }
                 }
             }

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

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.cli.jvm.compiler;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.io.FileUtilRt;
 import kotlin.io.FilesKt;
-import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
@@ -129,17 +128,16 @@ public class CompileEnvironmentUtil {
         try (JarInputStream jis = new JarInputStream(new FileInputStream(jarPath))) {
             while (true) {
                 JarEntry e = jis.getNextJarEntry();
-                if (e == null) break;
-
-                if (!FileUtilRt.extensionEquals(e.getName(), "class") ||
-                    StringsKt.substringAfterLast(e.getName(), "/", e.getName()).equals("module-info.class")) {
-                    continue;
+                if (e == null) {
+                    break;
                 }
                 if (resetJarTimestamps) {
                     e.setTime(DOS_EPOCH);
                 }
-                stream.putNextEntry(e);
-                FileUtil.copy(jis, stream);
+                if (FileUtilRt.extensionEquals(e.getName(), "class")) {
+                    stream.putNextEntry(e);
+                    FileUtil.copy(jis, stream);
+                }
             }
         }
     }

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

@@ -1,14 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler
-
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.LanguageLevelProjectExtension
-import com.intellij.pom.java.LanguageLevel
-
-fun Project.setupHighestLanguageLevel() {
-    LanguageLevelProjectExtension.getInstance(this).languageLevel = LanguageLevel.JDK_15_PREVIEW
-}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JavaLanguageLevel.kt.201

@@ -1,14 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler
-
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.LanguageLevelProjectExtension
-import com.intellij.pom.java.LanguageLevel
-
-fun Project.setupHighestLanguageLevel() {
-    // LanguageLevelProjectExtension.getInstance(this).languageLevel = LanguageLevel.JDK_15_PREVIEW
-}