JavaClassifierTypeImpl.resolutionResult dropped

.bunch

@@ -1,8 +1,7 @@
-201
-202
-203_202
 193
-192_193
-as36_192_193
-as40_193
-as41
+201
+202_201
+192
+as36_192
+as40
+as41_201

.gitattributes

@@ -3,6 +3,5 @@
 * text=auto
 * eol=lf
 *.png binary
-*.jar binary
 compiler/cli/bin/* eol=lf
 compiler/cli/bin/*.bat eol=crlf

.idea/codeStyles/Project.xml

@@ -13,6 +13,21 @@
       </option>
     </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
+        </value>
+      </option>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <MarkdownNavigatorCodeStyleSettings>

.idea/runConfigurations/Test__KMM.xml

@@ -1,20 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test: KMM" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="kmmTest" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <method v="2" />
-  </configuration>
-</component>

.idea/runConfigurations/Test__stdlib_js_public_kotlin_api_test__overwrite_results.xml

@@ -4,13 +4,12 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.js.test.ApiTest&quot; -Poverwrite.output=true --parallel" />
+      <option name="scriptParameters" value="--tests &quot;org.jetbrains.kotlin.js.test.ApiTest&quot; -Poverwrite.output=true" />
       <option name="taskDescriptions">
         <list />
       </option>
       <option name="taskNames">
         <list>
-          <option value=":js:js.tests:cleanTest" />
           <option value=":js:js.tests:test" />
         </list>
       </option>

.idea/scopes/Apply_copyright.xml

@@ -1,3 +1,3 @@
 <component name="DependencyValidationManager">
-  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle&amp;&amp;!file[group:kotlin-ultimate]:*/&amp;&amp;!file[kotlin.libraries]:stdlib/api//*" />
+  <scope name="Apply copyright" pattern="!file[*]:*//testData//*&amp;&amp;!file[*]:testData//*&amp;&amp;!file[*]:*.gradle.kts&amp;&amp;!file[*]:*.gradle&amp;&amp;!file[kotlin.kotlin-ultimate]:*/&amp;&amp;!file[kotlin.kotlin-ultimate.*]:*/&amp;&amp;!file[kotlin.libraries]:stdlib/api//*" />
 </component>

ChangeLog.md

@@ -1,504 +1,5 @@
 # CHANGELOG
 
-## 1.4-M3
-
-### Compiler
-
-#### New Features
-
-- [`KT-23575`](https://youtrack.jetbrains.com/issue/KT-23575) Deprecate with replacement and SinceKotlin 
-- [`KT-38652`](https://youtrack.jetbrains.com/issue/KT-38652) Do not generate optional annotations to class files on JVM
-- [`KT-38777`](https://youtrack.jetbrains.com/issue/KT-38777) Hide Throwable.addSuppressed member and prefer extension instead
-
-#### Performance Improvements
-
-- [`KT-38489`](https://youtrack.jetbrains.com/issue/KT-38489) Compilation of kotlin html DSL increasingly slow
-- [`KT-28650`](https://youtrack.jetbrains.com/issue/KT-28650) Type inference for argument type is very slow if several interfaces with a type parameter is used as an upper bound of a type parameter
-
-#### Fixes
-
-- [`KT-15971`](https://youtrack.jetbrains.com/issue/KT-15971) Incorrect bytecode generated when inheriting default arguments not from the first supertype
-- [`KT-25290`](https://youtrack.jetbrains.com/issue/KT-25290) NI: "AssertionError: If original type is SAM type, then candidate should have same type constructor" on out projection of Java class
-- [`KT-28672`](https://youtrack.jetbrains.com/issue/KT-28672) Contracts on calls with implicit receivers
-- [`KT-30279`](https://youtrack.jetbrains.com/issue/KT-30279) Support non-reified type parameters in typeOf
-- [`KT-31908`](https://youtrack.jetbrains.com/issue/KT-31908) NI: CCE on passing lambda to function which accepts vararg SAM interface
-- [`KT-32156`](https://youtrack.jetbrains.com/issue/KT-32156) New inference issue with generics
-- [`KT-32229`](https://youtrack.jetbrains.com/issue/KT-32229) New inference algorithm not taking into account the upper bound class
-- [`KT-33455`](https://youtrack.jetbrains.com/issue/KT-33455) Override equals/hashCode in functional interface wrappers
-- [`KT-34902`](https://youtrack.jetbrains.com/issue/KT-34902) AnalyzerException: Argument 1: expected I, but found R for unsigned types in generic data class
-- [`KT-35075`](https://youtrack.jetbrains.com/issue/KT-35075) AssertionError: "No resolved call for ..." with conditional function references
-- [`KT-35468`](https://youtrack.jetbrains.com/issue/KT-35468) Overcome ambiguity between typealias kotlin.Throws and the aliased type kotlin.jvm.Throws
-- [`KT-35494`](https://youtrack.jetbrains.com/issue/KT-35494) NI: Multiple duplicate error diagnostics (in IDE popup) with NULL_FOR_NONNULL_TYPE
-- [`KT-35681`](https://youtrack.jetbrains.com/issue/KT-35681) Wrong common supertype between raw and integer literal type leads to unsound code
-- [`KT-35937`](https://youtrack.jetbrains.com/issue/KT-35937) Error "Declaration has several compatible actuals" on incremental build
-- [`KT-36013`](https://youtrack.jetbrains.com/issue/KT-36013) Functional interface conversion not happens on a value of functional type with smart cast to a relevant functional type
-- [`KT-36045`](https://youtrack.jetbrains.com/issue/KT-36045) Do not depend on the order of lambda arguments to coerce result to `Unit`
-- [`KT-36448`](https://youtrack.jetbrains.com/issue/KT-36448) NI: fix tests after enabling NI in the compiler
-- [`KT-36706`](https://youtrack.jetbrains.com/issue/KT-36706) Prohibit functional interface constructor references
-- [`KT-36969`](https://youtrack.jetbrains.com/issue/KT-36969) Generate @NotNull on instance parameters of Interface$DefaultImpls methods
-- [`KT-37058`](https://youtrack.jetbrains.com/issue/KT-37058) Incorrect overload resolution ambiguity on callable reference in a conditional expression with new inference
-- [`KT-37120`](https://youtrack.jetbrains.com/issue/KT-37120) [FIR] False UNRESOLVED_REFERENCE for public and protected member functions and properties which are declared in object inner class
-- [`KT-37149`](https://youtrack.jetbrains.com/issue/KT-37149) Conversion when generic specified by type argument of SAM type
-- [`KT-37249`](https://youtrack.jetbrains.com/issue/KT-37249) false TYPE_MISMATCH when When-expression branches have try-catch blocks
-- [`KT-37341`](https://youtrack.jetbrains.com/issue/KT-37341) NI: Type mismatch with combination of lambda and function reference
-- [`KT-37436`](https://youtrack.jetbrains.com/issue/KT-37436) AME: "Receiver class does not define or inherit an implementation of the resolved method" in runtime on usage of non-abstract method of fun interface
-- [`KT-37510`](https://youtrack.jetbrains.com/issue/KT-37510) NI infers `java.lang.Void` from the expression in a lazy property delegate and throws ClassCastException at runtime
-- [`KT-37541`](https://youtrack.jetbrains.com/issue/KT-37541) SAM conversion with fun interface without a function fails on compiling and IDE analysis in SamAdapterFunctionsScope.getSamConstructor()
-- [`KT-37574`](https://youtrack.jetbrains.com/issue/KT-37574) NI: Type mismatch with Kotlin object extending functional type passed as @FunctionalInterface to Java
-- [`KT-37630`](https://youtrack.jetbrains.com/issue/KT-37630) NI: ILT suitability in a call is broken if there are CST calculation and calling function's type parameters
-- [`KT-37665`](https://youtrack.jetbrains.com/issue/KT-37665) NI: applicability error due to implicitly inferred Nothing for returning T with expected type
-- [`KT-37712`](https://youtrack.jetbrains.com/issue/KT-37712) No extension receiver in functional interface created with lambda
-- [`KT-37715`](https://youtrack.jetbrains.com/issue/KT-37715) NI: VerifyError: Bad type on operand stack with varargs generic value when type is inferred
-- [`KT-37721`](https://youtrack.jetbrains.com/issue/KT-37721) NI: Function reference with vararg parameter treated as array and missing default parameter is rejected
-- [`KT-37887`](https://youtrack.jetbrains.com/issue/KT-37887) NI: Smart casting for Map doesn't work if the variable is already  "smart casted"
-- [`KT-37914`](https://youtrack.jetbrains.com/issue/KT-37914) NI: broken inference for a casting to subtype function within the common constraint system with this subtype
-- [`KT-37952`](https://youtrack.jetbrains.com/issue/KT-37952) NI: improve lambdas completion through separation the lambdas analysis into several steps
-- [`KT-38069`](https://youtrack.jetbrains.com/issue/KT-38069) Callable reference adaptation should have dependency on API version 1.4
-- [`KT-38143`](https://youtrack.jetbrains.com/issue/KT-38143) New type inference fails when calling extension function defined on generic type with type arguments nested too deep
-- [`KT-38156`](https://youtrack.jetbrains.com/issue/KT-38156) FIR Metadata generation
-- [`KT-38197`](https://youtrack.jetbrains.com/issue/KT-38197) java.lang.OutOfMemoryError: Java heap space: failed reallocation of scalar replaced objects
-- [`KT-38259`](https://youtrack.jetbrains.com/issue/KT-38259) NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER for provideDelegate
-- [`KT-38337`](https://youtrack.jetbrains.com/issue/KT-38337) Map delegation fails for inline classes
-- [`KT-38401`](https://youtrack.jetbrains.com/issue/KT-38401) FIR: protected effective visibility is handled unprecisely
-- [`KT-38416`](https://youtrack.jetbrains.com/issue/KT-38416) FIR: infinite loop in BB coroutine test 'overrideDefaultArgument.kt'
-- [`KT-38432`](https://youtrack.jetbrains.com/issue/KT-38432) FIR: incorrect effective visibility in anonymous object
-- [`KT-38434`](https://youtrack.jetbrains.com/issue/KT-38434) Implement resolution of suspend-conversion on FE only, but give error if suspend conversion is called
-- [`KT-38437`](https://youtrack.jetbrains.com/issue/KT-38437) [FIR] String(CharArray) is resolved to java.lang.String constructor instead of kotlin.text.String pseudo-constructor
-- [`KT-38439`](https://youtrack.jetbrains.com/issue/KT-38439) NI: anonymous functions without receiver is allowed if there is an expected type with receiver
-- [`KT-38473`](https://youtrack.jetbrains.com/issue/KT-38473) FIR: ConeIntegerLiteralType in signature
-- [`KT-38537`](https://youtrack.jetbrains.com/issue/KT-38537) IllegalArgumentException: "marginPrefix must be non-blank string" with raw strings and space as margin prefix in trimMargin() call
-- [`KT-38604`](https://youtrack.jetbrains.com/issue/KT-38604) Implicit suspend conversion on call arguments doesn't work on vararg elements
-- [`KT-38680`](https://youtrack.jetbrains.com/issue/KT-38680) NSME when calling generic interface method with default parameters overriden with inline class type argument
-- [`KT-38681`](https://youtrack.jetbrains.com/issue/KT-38681) Wrong bytecode generated when calling generic interface method with default parameters overriden with primitive type argument
-- [`KT-38691`](https://youtrack.jetbrains.com/issue/KT-38691) NI: overload resolution ambiguity if take `R` and `() -> R`, and pass literal lambda, which returns `R`
-- [`KT-38799`](https://youtrack.jetbrains.com/issue/KT-38799) False positive USELESS_CAST for lambda parameter
-- [`KT-38802`](https://youtrack.jetbrains.com/issue/KT-38802) Generated code crashes by ClassCastException when delegating with inline class
-- [`KT-38853`](https://youtrack.jetbrains.com/issue/KT-38853) Backend Internal error: Error type encountered: Unresolved type for nested class used in an annotation argument on an interface method
-- [`KT-38890`](https://youtrack.jetbrains.com/issue/KT-38890) NI: false negative Type mismatch for values with fun keyword
-- [`KT-39010`](https://youtrack.jetbrains.com/issue/KT-39010) NI: Regression with false-positive smartcast on var of generic type
-- [`KT-39013`](https://youtrack.jetbrains.com/issue/KT-39013) 202, ASM 8: "AnalyzerException: Execution can fall off the end of the code"
-- [`KT-39260`](https://youtrack.jetbrains.com/issue/KT-39260) "AssertionError: Unsigned type expected: Int" in range
-- [`KT-39305`](https://youtrack.jetbrains.com/issue/KT-39305) NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER: unable to infer deeply nested type bound when class implements generic interface
-- [`KT-39408`](https://youtrack.jetbrains.com/issue/KT-39408) Using unsigned arrays as generics fails in 1.4-M2 with class cast exception
-- [`KT-39533`](https://youtrack.jetbrains.com/issue/KT-39533) NI: Wrong overload resolution for methods with SAM converted function reference arguments
-- [`KT-39535`](https://youtrack.jetbrains.com/issue/KT-39535) NI: Inference fails for the parameters of SAM converted lambdas with type parameters
-- [`KT-39603`](https://youtrack.jetbrains.com/issue/KT-39603) Require explicit override in JVM default compatibility mode on implicit generic specialization of inherited methods in classes
-- [`KT-39671`](https://youtrack.jetbrains.com/issue/KT-39671) Couldn't inline method call 'expectBody'
-- [`KT-39816`](https://youtrack.jetbrains.com/issue/KT-39816) NI:ClassCastException and no IDE error with provideDelegate when DELEGATE_SPECIAL_FUNCTION_MISSING in OI
-- [`KT-32779`](https://youtrack.jetbrains.com/issue/KT-32779) `Rewrite at slice` in array access resolution in coroutine inference
-- [`KT-39387`](https://youtrack.jetbrains.com/issue/KT-39387) Can't build Kotlin project due to overload resolution ambiguity on flatMap calls
-- [`KT-39229`](https://youtrack.jetbrains.com/issue/KT-39229) NI: resolution to wrong candidate (SAM-type against similar functional type)
-
-### Docs & Examples
-
-- [`KT-36245`](https://youtrack.jetbrains.com/issue/KT-36245) Document that @kotlin.native.ThreadLocal annotation doesn't work anywhere except in Kotlin/Native
-- [`KT-37943`](https://youtrack.jetbrains.com/issue/KT-37943) Conflicting overloads in the factory functions sample code in Coding Conventions Page
-
-### IDE
-
-#### New Features
-
-- [`KT-10974`](https://youtrack.jetbrains.com/issue/KT-10974) Add Code Style: Import Layout Configuration Table
-- [`KT-39065`](https://youtrack.jetbrains.com/issue/KT-39065) "Join lines" should remove trailing comma on call site
-
-#### Fixes
-
-- [`KT-9065`](https://youtrack.jetbrains.com/issue/KT-9065) Wrong result when move statement through if block with call with lambda
-- [`KT-14757`](https://youtrack.jetbrains.com/issue/KT-14757) Move statement up breaks code in function parameter list
-- [`KT-14946`](https://youtrack.jetbrains.com/issue/KT-14946) Move statement up/down (with Ctrl+Shift+Up/Down) messes with empty lines
-- [`KT-15143`](https://youtrack.jetbrains.com/issue/KT-15143) Kotlin: Colors&Fonts -> "Enum entry" should use Language Default -> Classes - Static field
-- [`KT-17887`](https://youtrack.jetbrains.com/issue/KT-17887) Moving statement (Ctrl/Cmd+Shift+Down) messes with use block
-- [`KT-34187`](https://youtrack.jetbrains.com/issue/KT-34187) UAST cannot get type of array access
-- [`KT-34524`](https://youtrack.jetbrains.com/issue/KT-34524) "PSI and index do not match" and IDE freeze with library import from `square/workflow`
-- [`KT-35574`](https://youtrack.jetbrains.com/issue/KT-35574) UAST: UBreakExpression in when expression should be UYieldExpression
-- [`KT-36801`](https://youtrack.jetbrains.com/issue/KT-36801) IDE: Unsupported language version value is represented with "latest stable" in GUI
-- [`KT-37378`](https://youtrack.jetbrains.com/issue/KT-37378) Remove IDE option "Enable new type inference algorithm..." in 1.4
-- [`KT-38003`](https://youtrack.jetbrains.com/issue/KT-38003) "Analyze Data Flow from Here" should work on parameter of abstract method
-- [`KT-38173`](https://youtrack.jetbrains.com/issue/KT-38173) Reified types do no have extends information
-- [`KT-38217`](https://youtrack.jetbrains.com/issue/KT-38217) Make Kotlin plugin settings searchable
-- [`KT-38247`](https://youtrack.jetbrains.com/issue/KT-38247) "IncorrectOperationException: Incorrect expression" through UltraLightUtils.kt: inlined string is not escaped before parsing
-- [`KT-38293`](https://youtrack.jetbrains.com/issue/KT-38293) Throwable: "'codestyle.name.kotlin' is not found in java.util.PropertyResourceBundle" at KotlinLanguageCodeStyleSettingsProvider.getConfigurableDisplayName()
-- [`KT-38407`](https://youtrack.jetbrains.com/issue/KT-38407) Drop components from plugin.xml
-- [`KT-38443`](https://youtrack.jetbrains.com/issue/KT-38443) No error on change in property initializer
-- [`KT-38521`](https://youtrack.jetbrains.com/issue/KT-38521) ISE: Loop in parent structure when converting a DOT_QUALIFIED_EXPRESSION with parent ANNOTATED_EXPRESSION
-- [`KT-38571`](https://youtrack.jetbrains.com/issue/KT-38571) Rework deprecated EPs
-- [`KT-38632`](https://youtrack.jetbrains.com/issue/KT-38632) Change the code style to official in tests
-
-### IDE. Code Style, Formatting
-
-#### Fixes
-
-- [`KT-24750`](https://youtrack.jetbrains.com/issue/KT-24750) Formatter: Minimum blank lines after class header does nothing
-- [`KT-31169`](https://youtrack.jetbrains.com/issue/KT-31169) IDEA settings search fails to find "Tabs and Indents" tab in Kotlin code style settings
-- [`KT-35359`](https://youtrack.jetbrains.com/issue/KT-35359) Incorrect indent for multiline expression in string template
-- [`KT-37420`](https://youtrack.jetbrains.com/issue/KT-37420) Add setting to disable inserting empty line between declaration and declaration with comment
-- [`KT-37891`](https://youtrack.jetbrains.com/issue/KT-37891) Formatter inserts empty lines between annotated properties
-- [`KT-38036`](https://youtrack.jetbrains.com/issue/KT-38036) Use trailing comma setting does not apply to code example in Settings dialog
-- [`KT-38568`](https://youtrack.jetbrains.com/issue/KT-38568) False positive: weak warning "Missing line break" on -> in when expression
-- [`KT-39024`](https://youtrack.jetbrains.com/issue/KT-39024) Add option for blank lines before declaration with comment or annotation on separate line
-- [`KT-39079`](https://youtrack.jetbrains.com/issue/KT-39079) Trailing comma: add base support for call site
-- [`KT-39123`](https://youtrack.jetbrains.com/issue/KT-39123) Option `Align 'when' branches in columns` does nothing
-- [`KT-39180`](https://youtrack.jetbrains.com/issue/KT-39180) Move trailing comma settings in Other tab
-
-### IDE. Completion
-
-- [`KT-18538`](https://youtrack.jetbrains.com/issue/KT-18538) Completion of static members of grand-super java class inserts unnecessary qualifier
-- [`KT-38445`](https://youtrack.jetbrains.com/issue/KT-38445) Fully qualified class name is used instead after insertion of `delay` method
-
-### IDE. Debugger
-
-#### Fixes
-
-- [`KT-14057`](https://youtrack.jetbrains.com/issue/KT-14057) Debugger couldn't step into Reader.read
-- [`KT-14828`](https://youtrack.jetbrains.com/issue/KT-14828) Bad step into/over behavior for functions with default parameters
-- [`KT-36403`](https://youtrack.jetbrains.com/issue/KT-36403) Method breakpoints don't work for libraries
-- [`KT-36404`](https://youtrack.jetbrains.com/issue/KT-36404) Evaluate: "AssertionError: Argument expression is not saved for a SAM constructor"
-- [`KT-37486`](https://youtrack.jetbrains.com/issue/KT-37486) Kotlin plugin keeps reference to stream debugger support classes after stream debugger plugin is disabled
-- [`KT-38484`](https://youtrack.jetbrains.com/issue/KT-38484) Coroutines Debugger: IAE “Requested element count -1 is less than zero.” is thrown by calling dumpCoroutines
-- [`KT-38606`](https://youtrack.jetbrains.com/issue/KT-38606) Coroutine Debugger: OCE from org.jetbrains.kotlin.idea.debugger.coroutine.proxy.mirror.BaseMirror.isCompatible
-- [`KT-39143`](https://youtrack.jetbrains.com/issue/KT-39143) NPE on setCurrentStackFrame to Kotlin inner compiled class content
-- [`KT-39412`](https://youtrack.jetbrains.com/issue/KT-39412) Failed to find Premain-Class manifest attribute when debugging main method with ktor
-- [`KT-39634`](https://youtrack.jetbrains.com/issue/KT-39634) (CoroutineDebugger) Agent doesn't start if using kotlinx-coroutines-core only dependency
-- [`KT-39648`](https://youtrack.jetbrains.com/issue/KT-39648) Coroutines debugger doesn't see stacktraces in case of the project has kotlinx-coroutines-debug dependency
-
-### IDE. Gradle Integration
-
-#### Performance Improvements
-
-- [`KT-39059`](https://youtrack.jetbrains.com/issue/KT-39059) Poor performance of `modifyDependenciesOnMppModules`
-
-#### Fixes
-
-- [`KT-35921`](https://youtrack.jetbrains.com/issue/KT-35921) Gradle Import fails with "Unsupported major.minor version 52.0" on pure Java project in case "Gradle JDK" is lower 1.8 and Kotlin plugin is enabled
-- [`KT-36673`](https://youtrack.jetbrains.com/issue/KT-36673) Gradle Project importing: move ModelBuilders and ModelProviders to kotlin-gradle-tooling jar
-- [`KT-36792`](https://youtrack.jetbrains.com/issue/KT-36792) IDEA 2020.1: Some module->module dependencies in HMPP project are missed after import from Gradle
-- [`KT-37125`](https://youtrack.jetbrains.com/issue/KT-37125) Imported modules structure for MPP project is displayed messy in UI in IDEA 2020.1
-- [`KT-37428`](https://youtrack.jetbrains.com/issue/KT-37428) NPE at KotlinFacetSettings.setLanguageLevel() on the first project import
-- [`KT-38706`](https://youtrack.jetbrains.com/issue/KT-38706) IDE Gradle import creates 4 JavaScript modules for MPP source sets with BOTH compiler type
-- [`KT-38767`](https://youtrack.jetbrains.com/issue/KT-38767) Published hierarchical multiplatform library symbols are unresolved in IDE (master)
-- [`KT-38842`](https://youtrack.jetbrains.com/issue/KT-38842) False positive [INVISIBLE_MEMBER] for `internal` declaration of commonMain called from commonTest
-- [`KT-39213`](https://youtrack.jetbrains.com/issue/KT-39213) IDE: references from MPP project to JavaScript library are unresolved, when project and library are compiled with "both" mode
-- [`KT-39657`](https://youtrack.jetbrains.com/issue/KT-39657) Language settings for intermediate source-sets are lost during import
-
-### IDE. Gradle. Script
-
-#### New Features
-
-- [`KT-34481`](https://youtrack.jetbrains.com/issue/KT-34481) `*.gradle.kts`: use Intellij IDEA Gradle project sync mechanics for updating script configuration
-
-#### Performance Improvements
-
-- [`KT-34138`](https://youtrack.jetbrains.com/issue/KT-34138) Deadlock in `ScriptTemplatesFromDependenciesProvider`
-- [`KT-38875`](https://youtrack.jetbrains.com/issue/KT-38875) Deadlock in ScriptClassRootsUpdater.checkInvalidSdks
-
-#### Fixes
-
-- [`KT-34265`](https://youtrack.jetbrains.com/issue/KT-34265) Bogus "build configuration failed, run 'gradle tasks' for more information" message and other issues related to "script dependencies"
-- [`KT-34444`](https://youtrack.jetbrains.com/issue/KT-34444) *.gradle.kts: special storage of all scripts configuration on one file
-- [`KT-35153`](https://youtrack.jetbrains.com/issue/KT-35153) build.gradle.kts: scripts in removed subproject remain imported, but shouldn't
-- [`KT-35573`](https://youtrack.jetbrains.com/issue/KT-35573) Request for gradle build script configuration only after explicit click on notification
-- [`KT-36675`](https://youtrack.jetbrains.com/issue/KT-36675) move .gradle.kts ModelBuilders and ModelProviders to kotlin-gradle-tooling jar
-- [`KT-37178`](https://youtrack.jetbrains.com/issue/KT-37178) build.gradle.kts: Rework the notification for scripts out of project
-- [`KT-37631`](https://youtrack.jetbrains.com/issue/KT-37631) Unnecessary loading dependencies after opening build.gradle.kts after project import with Gradle 6
-- [`KT-37863`](https://youtrack.jetbrains.com/issue/KT-37863) Scanning dependencies for script definitions takes too long or indefinitely during Gradle import
-- [`KT-38296`](https://youtrack.jetbrains.com/issue/KT-38296) MISSING_DEPENDENCY_SUPERCLASS in the build.gradle.kts editor while Gradle runs Ok
-- [`KT-38541`](https://youtrack.jetbrains.com/issue/KT-38541) "Invalid file" exception in ScriptChangeListener.getAnalyzableKtFileForScript()
-- [`KT-39104`](https://youtrack.jetbrains.com/issue/KT-39104) “Gradle Kotlin DSL script configuration is missing” after importing project in IJ201, Gradle 6.3
-- [`KT-39469`](https://youtrack.jetbrains.com/issue/KT-39469) Gradle version is not updated in script dependencies if the version of gradle was changed in gradle-wrapper.properties
-- [`KT-39771`](https://youtrack.jetbrains.com/issue/KT-39771) Freeze 30s from org.jetbrains.kotlin.scripting.resolve.ApiChangeDependencyResolverWrapper.resolve on loading script configuration with Gradle 5.6.4
-
-### IDE. Inspections and Intentions
-
-#### New Features
-
-- [`KT-14884`](https://youtrack.jetbrains.com/issue/KT-14884) Intention to add missing "class" keyword for enum and annotation top-level declarations
-- [`KT-17209`](https://youtrack.jetbrains.com/issue/KT-17209) Provide intention to fix platform declaration clash (CONFLICTING_JVM_DECLARATIONS)
-- [`KT-24522`](https://youtrack.jetbrains.com/issue/KT-24522) Suggest to move typealias outside the class
-- [`KT-30263`](https://youtrack.jetbrains.com/issue/KT-30263) Detect redundant conversions of unsigned types
-- [`KT-35893`](https://youtrack.jetbrains.com/issue/KT-35893) Support Inspection for unnecessary asSequence() call
-- [`KT-38559`](https://youtrack.jetbrains.com/issue/KT-38559) "Change JVM name" (@JvmName) quickfix: improve name suggester for generic functions
-- [`KT-38597`](https://youtrack.jetbrains.com/issue/KT-38597) Expand Boolean intention
-- [`KT-38982`](https://youtrack.jetbrains.com/issue/KT-38982) Add "Logger initialized with foreign class" inspection
-- [`KT-39131`](https://youtrack.jetbrains.com/issue/KT-39131) TrailingCommaInspection: should suggest fixes for call-site without warnings
-
-#### Fixes
-
-- [`KT-5271`](https://youtrack.jetbrains.com/issue/KT-5271) Missing QuickFix for Multiple supertypes available
-- [`KT-11865`](https://youtrack.jetbrains.com/issue/KT-11865) "Create secondary constructor" quick fix always inserts parameter-less call to `this()`
-- [`KT-14021`](https://youtrack.jetbrains.com/issue/KT-14021) Quickfix to add parameter to function gives strange name to parameter
-- [`KT-17121`](https://youtrack.jetbrains.com/issue/KT-17121) "Implement members" quick fix is not suggested
-- [`KT-17368`](https://youtrack.jetbrains.com/issue/KT-17368) Don't highlight members annotated with @JsName as unused
-- [`KT-20795`](https://youtrack.jetbrains.com/issue/KT-20795) "replace explicit parameter with it" creates invalid code in case of overload ambiguities
-- [`KT-22014`](https://youtrack.jetbrains.com/issue/KT-22014) Intention "convert lambda to reference" should be available for implicit 'this'
-- [`KT-22015`](https://youtrack.jetbrains.com/issue/KT-22015) Intention "Convert lambda to reference" should be available in spite of the lambda in or out of parentheses
-- [`KT-22142`](https://youtrack.jetbrains.com/issue/KT-22142) Intentions: "Convert to primary constructor" changes semantics for property with custom setter
-- [`KT-22878`](https://youtrack.jetbrains.com/issue/KT-22878) Empty argument list at the call site of custom function named "suspend" shouldn't be reported as unnecessary
-- [`KT-24281`](https://youtrack.jetbrains.com/issue/KT-24281) Importing of invoke() from the same file is reported as unused even if it isn't
-- [`KT-25050`](https://youtrack.jetbrains.com/issue/KT-25050) False-positive inspection "Call replaceable with binary operator" for 'equals'
-- [`KT-26361`](https://youtrack.jetbrains.com/issue/KT-26361) @Deprecated "ReplaceWith" quickfix inserts 'this' incorrectly when using function imports
-- [`KT-27651`](https://youtrack.jetbrains.com/issue/KT-27651) 'Condition is always true' inspection should not be triggered when the condition has references to a named constant
-- [`KT-29934`](https://youtrack.jetbrains.com/issue/KT-29934) False negative `Change type` quickfix on primary constructor override val parameter when it has wrong type
-- [`KT-31682`](https://youtrack.jetbrains.com/issue/KT-31682) 'Convert lambda to reference' intention inside class with function which return object produces uncompilable code
-- [`KT-31760`](https://youtrack.jetbrains.com/issue/KT-31760) Implement Abstract Function/Property intentions position generated member improperly
-- [`KT-32511`](https://youtrack.jetbrains.com/issue/KT-32511) Create class quick fix is not suggested in super type list in case of missing primary constructor
-- [`KT-32565`](https://youtrack.jetbrains.com/issue/KT-32565) False positive "Variable is the same as 'credentials' and should be inlined" with object declared and returned from lambda
-- [`KT-32801`](https://youtrack.jetbrains.com/issue/KT-32801) False positive "Call on collection type may be reduced" with mapNotNull, generic lambda block and new inference
-- [`KT-33951`](https://youtrack.jetbrains.com/issue/KT-33951) ReplaceWith quickfix with unqualified object member call doesn't substitute argument for parameter
-- [`KT-34378`](https://youtrack.jetbrains.com/issue/KT-34378) "Convert lambda to reference" refactoring does not work for suspend functions
-- [`KT-34677`](https://youtrack.jetbrains.com/issue/KT-34677) False positive "Collection count can be converted to size" with `Iterable`
-- [`KT-34696`](https://youtrack.jetbrains.com/issue/KT-34696) Wrong 'Redundant qualifier name' for 'MyEnum.values' usage
-- [`KT-34713`](https://youtrack.jetbrains.com/issue/KT-34713) "Condition is always 'false'": quickfix "Delete expression" doesn't remove `else` keyword (may break control flow)
-- [`KT-35015`](https://youtrack.jetbrains.com/issue/KT-35015) ReplaceWith doesn't substitute parameters with argument expressions
-- [`KT-35329`](https://youtrack.jetbrains.com/issue/KT-35329) Replace 'when' with 'if' intention: do not suggest if 'when' is used as expression and it has no 'else' branch
-- [`KT-36194`](https://youtrack.jetbrains.com/issue/KT-36194) "Add braces to 'for' statement" inserts extra line break and moves the following single-line comment
-- [`KT-36406`](https://youtrack.jetbrains.com/issue/KT-36406) "To ordinary string literal" intention adds unnecessary escapes to characters in template expression
-- [`KT-36461`](https://youtrack.jetbrains.com/issue/KT-36461) "Create enum constant" quick fix adds after semicolon, if the last entry has a comma
-- [`KT-36462`](https://youtrack.jetbrains.com/issue/KT-36462) "Create enum constant" quick fix doesn't add trailing comma
-- [`KT-36508`](https://youtrack.jetbrains.com/issue/KT-36508) False positive "Replace 'to' with infix form" when 'to' lambda generic type argument is specified explicitly
-- [`KT-36930`](https://youtrack.jetbrains.com/issue/KT-36930) Intention "Specify type explicitly" adds NotNull annotation when calling java method with the annotation
-- [`KT-37148`](https://youtrack.jetbrains.com/issue/KT-37148) "Remove redundant `.let` call doesn't remove extra calls
-- [`KT-37156`](https://youtrack.jetbrains.com/issue/KT-37156) "Unused unary operator" inspection highlighting is hard to see
-- [`KT-37173`](https://youtrack.jetbrains.com/issue/KT-37173) "Replace with string templates" intention for String.format produces uncompilable string template
-- [`KT-37181`](https://youtrack.jetbrains.com/issue/KT-37181) Don't show "Remove redundant qualifier name" inspection on qualified Companion imported with star import
-- [`KT-37214`](https://youtrack.jetbrains.com/issue/KT-37214) "Convert lambda to reference" with a labeled "this" receiver fails
-- [`KT-37256`](https://youtrack.jetbrains.com/issue/KT-37256) False positive `PlatformExtensionReceiverOfInline` inspection if a platform type value is passed to a nullable receiver
-- [`KT-37744`](https://youtrack.jetbrains.com/issue/KT-37744) "Convert lambda to reference" inspection quick fix create incompilable code when type is inferred from lambda parameter
-- [`KT-37746`](https://youtrack.jetbrains.com/issue/KT-37746) "Redundant suspend modifier" should not be reported for functions with actual keyword
-- [`KT-37842`](https://youtrack.jetbrains.com/issue/KT-37842) "Convert to anonymous function" creates broken code with suspend functions
-- [`KT-37908`](https://youtrack.jetbrains.com/issue/KT-37908) "Convert to anonymous object" quickfix: false negative when interface has concrete functions
-- [`KT-37967`](https://youtrack.jetbrains.com/issue/KT-37967) Replace 'invoke' with direct call intention adds unnecessary parenthesis
-- [`KT-37977`](https://youtrack.jetbrains.com/issue/KT-37977) "Replace 'invoke' with direct call" intention: false positive when function is not operator
-- [`KT-38062`](https://youtrack.jetbrains.com/issue/KT-38062) Reactor Quickfix throws `NotImplementedError` for Kotlin
-- [`KT-38240`](https://youtrack.jetbrains.com/issue/KT-38240) False positive redundant semicolon with `as` cast and `not` unary operator on next line
-- [`KT-38261`](https://youtrack.jetbrains.com/issue/KT-38261) Redundant 'let' call removal leaves ?. operator and makes code uncompilable
-- [`KT-38310`](https://youtrack.jetbrains.com/issue/KT-38310) Remove explicit type annotation intention drops 'suspend'
-- [`KT-38492`](https://youtrack.jetbrains.com/issue/KT-38492) False positive "Add import" intention for already imported class
-- [`KT-38520`](https://youtrack.jetbrains.com/issue/KT-38520) SetterBackingFieldAssignmentInspection throws exception
-- [`KT-38649`](https://youtrack.jetbrains.com/issue/KT-38649) False positive quickfix "Assignment should be lifted out of when" in presence of smartcasts
-- [`KT-38677`](https://youtrack.jetbrains.com/issue/KT-38677) Invalid psi tree after `Lift assigment out of...`
-- [`KT-38790`](https://youtrack.jetbrains.com/issue/KT-38790) "Convert sealed subclass to object" for data classes doesn't remove 'data' keyword
-- [`KT-38829`](https://youtrack.jetbrains.com/issue/KT-38829) 'Remove redundant backticks' can be broken with @ in name
-- [`KT-38831`](https://youtrack.jetbrains.com/issue/KT-38831) 'Replace with assignment' can be broken with fast code change
-- [`KT-38832`](https://youtrack.jetbrains.com/issue/KT-38832) "Remove curly braces" intention may produce CCE
-- [`KT-38948`](https://youtrack.jetbrains.com/issue/KT-38948) False positive quickfix "Make containing function suspend" for anonymous function
-- [`KT-38961`](https://youtrack.jetbrains.com/issue/KT-38961) "Useless call on collection type" for filterNotNull on non-null array where list return type is expected
-- [`KT-39069`](https://youtrack.jetbrains.com/issue/KT-39069) Improve TrailingCommaInspection
-- [`KT-39151`](https://youtrack.jetbrains.com/issue/KT-39151) False positive inspection to replace Java forEach with Kotlin forEach when using ConcurrentHashMap
-
-### IDE. JS
-
-- [`KT-39275`](https://youtrack.jetbrains.com/issue/KT-39275) Kotlin JS Browser template for kotlin dsl doesn't include index.html
-
-### IDE. KDoc
-
-- [`KT-32163`](https://youtrack.jetbrains.com/issue/KT-32163) Open Quick Documentation when cursor inside function / constructor brackets
-
-### IDE. Navigation
-
-- [`KT-32245`](https://youtrack.jetbrains.com/issue/KT-32245) Method in Kotlin class is not listed among implementing methods
-- [`KT-33510`](https://youtrack.jetbrains.com/issue/KT-33510) There is no gutter icon to navigate from `actual` to `expect` if `expect` and the corresponding `actual` declarations are in the same file
-- [`KT-38260`](https://youtrack.jetbrains.com/issue/KT-38260) Navigation bar doesn't show directories of files with a single top level Kotlin class
-- [`KT-38466`](https://youtrack.jetbrains.com/issue/KT-38466) Top level functions/properties aren't shown in navigation panel
-
-### IDE. Project View
-
-- [`KT-36444`](https://youtrack.jetbrains.com/issue/KT-36444) Structure view: add ability to sort by visibility
-- [`KT-38276`](https://youtrack.jetbrains.com/issue/KT-38276) Structure view: support visibility filter for class properties
-
-### IDE. REPL
-
-- [`KT-38454`](https://youtrack.jetbrains.com/issue/KT-38454) Kotlin REPL in IntelliJ doesn't take module's JVM target setting into account
-
-### IDE. Refactorings
-
-- [`KT-12878`](https://youtrack.jetbrains.com/issue/KT-12878) "Change signature" forces line breaks after every parameter declaration
-- [`KT-30128`](https://youtrack.jetbrains.com/issue/KT-30128) Change Signature should move lambda outside of parentheses if the arguments are reordered so that the lambda goes last
-- [`KT-35338`](https://youtrack.jetbrains.com/issue/KT-35338) Move/rename refactorings mess up code formatting by wrapping lines
-- [`KT-38449`](https://youtrack.jetbrains.com/issue/KT-38449) Extract variable refactoring is broken by NPE
-- [`KT-38543`](https://youtrack.jetbrains.com/issue/KT-38543) Copy can't work to package with escaped package
-- [`KT-38627`](https://youtrack.jetbrains.com/issue/KT-38627) Rename package refactorings mess up code formatting by wrapping lines
-
-### IDE. Run Configurations
-
-- [`KT-34516`](https://youtrack.jetbrains.com/issue/KT-34516) Don't suggest incompatible targets in a drop-down list for run test gutter icon in multiplatform projects
-- [`KT-38102`](https://youtrack.jetbrains.com/issue/KT-38102) DeprecatedMethodException ConfigurationFactory.getId
-
-### IDE. Scratch
-
-- [`KT-38455`](https://youtrack.jetbrains.com/issue/KT-38455) Kotlin scratch files don't take module's JVM target setting into account
-
-### IDE. Script
-
-- [`KT-39791`](https://youtrack.jetbrains.com/issue/KT-39791) Kotlin plugin loads VFS in the output directories
-
-### IDE. Structural Search
-
-- [`KT-39721`](https://youtrack.jetbrains.com/issue/KT-39721) Optimize Kotlin SSR by using the index
-- [`KT-39733`](https://youtrack.jetbrains.com/issue/KT-39733) Augmented assignment matching
-- [`KT-39769`](https://youtrack.jetbrains.com/issue/KT-39769) "When expressions" predefined template doesn't match all when expressions
-
-### IDE. Wizards
-
-- [`KT-38673`](https://youtrack.jetbrains.com/issue/KT-38673) New Project Wizard: multiplatform templates are generated having unsupported Gradle version in a wrapper
-- [`KT-38810`](https://youtrack.jetbrains.com/issue/KT-38810) Incorrect order of build phases in Xcode project from new wizard
-- [`KT-38952`](https://youtrack.jetbrains.com/issue/KT-38952) Remove old new_project_wizards
-- [`KT-39503`](https://youtrack.jetbrains.com/issue/KT-39503) New Project wizard 1.4+: release kotlinx.html version is added to dependencies with milestone IDE plugin
-- [`KT-39700`](https://youtrack.jetbrains.com/issue/KT-39700) Wizard: group project templates on the first step by the project type
-- [`KT-39770`](https://youtrack.jetbrains.com/issue/KT-39770) CSS Support in Kotlin wizards
-- [`KT-39826`](https://youtrack.jetbrains.com/issue/KT-39826) Fix Android app in New Template Wizard
-- [`KT-39843`](https://youtrack.jetbrains.com/issue/KT-39843) Change imports in JS/browser wizard
-
-### JS. Tools
-
-- [`KT-32273`](https://youtrack.jetbrains.com/issue/KT-32273) Kotlin/JS console error on hot reload
-- [`KT-39498`](https://youtrack.jetbrains.com/issue/KT-39498) Update dukat version in toolchain near to release of 1.4-M3
-
-### JavaScript
-
-- [`KT-29916`](https://youtrack.jetbrains.com/issue/KT-29916) Implement `typeOf` on JS
-- [`KT-35857`](https://youtrack.jetbrains.com/issue/KT-35857) Kotlin/JS CLI bundled to IDEA plugin can't compile using IR back-end out of the box
-- [`KT-36798`](https://youtrack.jetbrains.com/issue/KT-36798) KJS: prohibit using @JsExport on a non-top-level declaration
-- [`KT-37771`](https://youtrack.jetbrains.com/issue/KT-37771) KJS: Generated TypeScript does not recursively export base classes (can fail with generics)
-- [`KT-38113`](https://youtrack.jetbrains.com/issue/KT-38113) Review public API of JS stdlib for IR BE
-- [`KT-38765`](https://youtrack.jetbrains.com/issue/KT-38765) [JS / IR] AssertionError: class EventEmitter: Super class should be any: with nested class extending parent class
-- [`KT-38768`](https://youtrack.jetbrains.com/issue/KT-38768) KJS IR: generate ES2015 (aka ES6) classes
-
-### Libraries
-
-#### New Features
-
-- [`KT-11253`](https://youtrack.jetbrains.com/issue/KT-11253) Function to sum long or other numeric property of items in a collection
-- [`KT-28933`](https://youtrack.jetbrains.com/issue/KT-28933) capitalize() with Locale argument in the JDK stdlib
-- [`KT-34142`](https://youtrack.jetbrains.com/issue/KT-34142) Create SortedMap with Comparator and items
-- [`KT-34506`](https://youtrack.jetbrains.com/issue/KT-34506) Add Sequence.flatMap overload that works on Iterable
-- [`KT-36894`](https://youtrack.jetbrains.com/issue/KT-36894) Support flatMapIndexed in the Collections API
-- [`KT-38480`](https://youtrack.jetbrains.com/issue/KT-38480) Introduce experimental annotation for enabling overload resolution by lambda result
-- [`KT-38708`](https://youtrack.jetbrains.com/issue/KT-38708) minOf/maxOf functions to return min/max value provided by selector
-- [`KT-39707`](https://youtrack.jetbrains.com/issue/KT-39707) Make some interfaces in stdlib functional
-
-#### Performance Improvements
-
-- [`KT-23142`](https://youtrack.jetbrains.com/issue/KT-23142) toHashSet is suboptimal for inputs with a lot of duplicates
-
-#### Fixes
-
-- [`KT-21266`](https://youtrack.jetbrains.com/issue/KT-21266) Add module-info for standard library artifacts
-- [`KT-23322`](https://youtrack.jetbrains.com/issue/KT-23322) Document 'reduce' operation behavior on empty collections
-- [`KT-28753`](https://youtrack.jetbrains.com/issue/KT-28753) Comparing floating point values in array/list operations 'contains', 'indexOf', 'lastIndexOf': IEEE 754 or total order
-- [`KT-30083`](https://youtrack.jetbrains.com/issue/KT-30083) Annotate KTypeProjection.STAR with JvmField in a compatible way
-- [`KT-30084`](https://youtrack.jetbrains.com/issue/KT-30084) Annotate functions in KTypeProjection.Companion with JvmStatic
-- [`KT-31343`](https://youtrack.jetbrains.com/issue/KT-31343) Deprecate old String <-> CharArray, ByteArray conversion api
-- [`KT-34596`](https://youtrack.jetbrains.com/issue/KT-34596) Add some validation to KTypeProjection constructor
-- [`KT-35978`](https://youtrack.jetbrains.com/issue/KT-35978) Review and remove experimental stdlib API status for 1.4
-- [`KT-38388`](https://youtrack.jetbrains.com/issue/KT-38388) Document `fromIndex` and `toIndex` parameters
-- [`KT-38854`](https://youtrack.jetbrains.com/issue/KT-38854) Gradually change the return type of collection min/max functions to non-nullable
-- [`KT-39023`](https://youtrack.jetbrains.com/issue/KT-39023) Document split(Pattern) extension differences from Pattern.split
-- [`KT-39064`](https://youtrack.jetbrains.com/issue/KT-39064) Introduce minOrNull and maxOrNull extension functions on collections
-- [`KT-39235`](https://youtrack.jetbrains.com/issue/KT-39235) Lift experimental annotation from bit operations
-- [`KT-39237`](https://youtrack.jetbrains.com/issue/KT-39237) Lift experimental annotation from common StringBuilder
-- [`KT-39238`](https://youtrack.jetbrains.com/issue/KT-39238) Appendable.appendRange - remove nullability
-- [`KT-39239`](https://youtrack.jetbrains.com/issue/KT-39239) Lift experimental annotation from String <-> utf8 conversion api
-- [`KT-39244`](https://youtrack.jetbrains.com/issue/KT-39244) KJS: update polyfills, all or most of them must not be enumerable
-- [`KT-39330`](https://youtrack.jetbrains.com/issue/KT-39330) Migrate declarations from kotlin.dom and kotlin.browser packages to kotlinx.*
-
-### Middle-end. IR
-
-- [`KT-31088`](https://youtrack.jetbrains.com/issue/KT-31088) need a way to compute fake overrides for pure IR
-- [`KT-33207`](https://youtrack.jetbrains.com/issue/KT-33207) Kotlin/Native: KNPE during deserialization of an inner class
-- [`KT-33267`](https://youtrack.jetbrains.com/issue/KT-33267) Kotlin/Native: Deserialization error for an "inner" extension property imported from a class
-- [`KT-37255`](https://youtrack.jetbrains.com/issue/KT-37255) Make psi2ir aware of declarations provided by compiler plugins
-
-### Reflection
-
-- [`KT-22936`](https://youtrack.jetbrains.com/issue/KT-22936) Not all things can be changed to `createType` yet, and now `defaultType` methods are starting to fail
-- [`KT-32241`](https://youtrack.jetbrains.com/issue/KT-32241) Move KType.javaType into stdlib from reflect
-- [`KT-34344`](https://youtrack.jetbrains.com/issue/KT-34344) KType.javaType implementation throws when invoked with a typeOf<T>()
-- [`KT-38491`](https://youtrack.jetbrains.com/issue/KT-38491) IllegalArgumentException when using callBy on function with inline class parameters and default arguments
-- [`KT-38881`](https://youtrack.jetbrains.com/issue/KT-38881) Add KClass.isFun modifier of functional interfaces to reflection
-
-### Tools. Android Extensions
-
-- [`KT-25807`](https://youtrack.jetbrains.com/issue/KT-25807) Kotlin extension annotation @Parcelize in AIDL returns Object instead of original T
-
-### Tools. CLI
-
-- [`KT-30211`](https://youtrack.jetbrains.com/issue/KT-30211) Support a way to pass arguments to the underlying JVM in kotlinc batch scripts on Windows
-- [`KT-30778`](https://youtrack.jetbrains.com/issue/KT-30778) kotlin-compiler.jar contains shaded but not relocated kotlinx.coroutines
-- [`KT-38070`](https://youtrack.jetbrains.com/issue/KT-38070) Compiler option to bypass prerelease metadata incompatibility error
-- [`KT-38413`](https://youtrack.jetbrains.com/issue/KT-38413) Add JVM target bytecode version 14
-
-### Tools. Compiler Plugins
-
-- [`KT-39274`](https://youtrack.jetbrains.com/issue/KT-39274) [KJS / IR] Custom serializer for class without zero argument constructor doesn't compile
-
-### Tools. Gradle
-
-- [`KT-25428`](https://youtrack.jetbrains.com/issue/KT-25428) Kotlin Gradle Plugin: Use new Gradle API for Lazy tasks
-- [`KT-34487`](https://youtrack.jetbrains.com/issue/KT-34487) Gradle build fails with "Cannot run program "java": error=7, Argument list too long
-- [`KT-35957`](https://youtrack.jetbrains.com/issue/KT-35957) MPP IC fails with "X has several compatible actual declarations" error
-- [`KT-38250`](https://youtrack.jetbrains.com/issue/KT-38250) Drop support for Gradle versions older than 5.3 in the Kotlin Gradle plugin
-
-### Tools. Gradle. JS
-
-#### New Features
-
-- [`KT-30619`](https://youtrack.jetbrains.com/issue/KT-30619) Support NPM transitive dependencies in multi-platform JS target
-- [`KT-38286`](https://youtrack.jetbrains.com/issue/KT-38286) [Gradle, JS] Error handling on Webpack problems
-
-#### Fixes
-
-- [`KT-31669`](https://youtrack.jetbrains.com/issue/KT-31669) Gradle/JS: rise error when plugin loaded more than once
-- [`KT-32531`](https://youtrack.jetbrains.com/issue/KT-32531) [Gradle/JS] Add scoped NPM dependencies
-- [`KT-34832`](https://youtrack.jetbrains.com/issue/KT-34832) [Kotlin/JS] Failed build after webpack run (Karma not found)
-- [`KT-35194`](https://youtrack.jetbrains.com/issue/KT-35194) Kotlin/JS: browserRun fails with "address already in use" when trying to connect to local server
-- [`KT-35611`](https://youtrack.jetbrains.com/issue/KT-35611) Kotlin Gradle plugin should report `kotlin2js` plugin ID as deprecated
-- [`KT-35641`](https://youtrack.jetbrains.com/issue/KT-35641) Kotlin Gradle plugin should report `kotlin-dce-js` plugin ID as deprecated
-- [`KT-36410`](https://youtrack.jetbrains.com/issue/KT-36410) JS: Collect stats about IR backend usage
-- [`KT-36451`](https://youtrack.jetbrains.com/issue/KT-36451) KJS Adding npm dependency breaks Webpack devserver reloading
-- [`KT-37258`](https://youtrack.jetbrains.com/issue/KT-37258) Kotlin/JS + Gradle: in continuous mode kotlinNpmInstall time to time outputs "ENOENT: no such file or directory" error
-- [`KT-38109`](https://youtrack.jetbrains.com/issue/KT-38109) [Gradle, JS] Error handling on Karma launcher problems
-- [`KT-38331`](https://youtrack.jetbrains.com/issue/KT-38331) Add an ability to control generating externals for npm deps individually
-- [`KT-38485`](https://youtrack.jetbrains.com/issue/KT-38485) [Gradle, JS] Unable to configure JS compiler with string
-- [`KT-38683`](https://youtrack.jetbrains.com/issue/KT-38683) Remove possibility to set NPM dependency without version
-- [`KT-38990`](https://youtrack.jetbrains.com/issue/KT-38990) Support multiple range versions for NPM dependencies
-- [`KT-38994`](https://youtrack.jetbrains.com/issue/KT-38994) Remove possibility to set NPM dependency with npm(org, name, version)
-- [`KT-39109`](https://youtrack.jetbrains.com/issue/KT-39109) ArithmeticException: "/ by zero" caused by kotlinNodeJsSetup task with enabled gradle caching on Windows
-- [`KT-39210`](https://youtrack.jetbrains.com/issue/KT-39210) Kotlin/JS: with both JS and MPP modules in the same project Gradle configuration fails on `nodejs {}` and `browser {}`
-- [`KT-39377`](https://youtrack.jetbrains.com/issue/KT-39377) Use standard source-map-loader instead of custom one
-
-### Tools. Gradle. Multiplatform
-
-- [`KT-39184`](https://youtrack.jetbrains.com/issue/KT-39184) Support publication of Kotlin-distributed libraries with Gradle Metadata
-- [`KT-39304`](https://youtrack.jetbrains.com/issue/KT-39304) Gradle import error `java.util.NoSuchElementException: Key source set foo is missing in the map` on unused source set
-
-### Tools. Gradle. Native
-
-- [`KT-37514`](https://youtrack.jetbrains.com/issue/KT-37514) CocoaPods Gradle plugin: Support building from terminal projects for several platforms
-- [`KT-38440`](https://youtrack.jetbrains.com/issue/KT-38440) Make error message about missing Podfile path for cocoapods integration actionable for a user
-- [`KT-38991`](https://youtrack.jetbrains.com/issue/KT-38991) Gradle MPP plugin: Enable parallel in-process execution for K/N compiler
-- [`KT-39935`](https://youtrack.jetbrains.com/issue/KT-39935) Support overriding the `KotlinNativeCompile` task sources
-- [`KT-37512`](https://youtrack.jetbrains.com/issue/KT-37512) Cocoapods Gradle plugin: Improve error logging for external tools
-
-### Tools. J2K
-
-- [`KT-35169`](https://youtrack.jetbrains.com/issue/KT-35169) Do not show "Inline local variable" popup during "Cleaning up code" phase of J2K
-- [`KT-38004`](https://youtrack.jetbrains.com/issue/KT-38004) J2K breaks java getter call in java code
-- [`KT-38450`](https://youtrack.jetbrains.com/issue/KT-38450) J2K should convert Java SAM interfaces to Kotlin fun interfaces
-
-### Tools. JPS
-
-- [`KT-27458`](https://youtrack.jetbrains.com/issue/KT-27458) The Kotlin standard library is not found in the module graph ... in a non-Kotlin project.
-- [`KT-29552`](https://youtrack.jetbrains.com/issue/KT-29552) Project is completely rebuilt after each gradle sync.
-
-### Tools. Scripts
-
-- [`KT-37766`](https://youtrack.jetbrains.com/issue/KT-37766) Impossible to apply compiler plugins onto scripts with the new scripting API
-
-### Tools. kapt
-
-- [`KT-29355`](https://youtrack.jetbrains.com/issue/KT-29355) Provide access to default values for primary constructor properties
-
-
 ## 1.4-M2
 
 ### Compiler
@@ -599,8 +100,6 @@
 - [`KT-38668`](https://youtrack.jetbrains.com/issue/KT-38668) Project with module dependency in KN, build fails with Kotlin 1.3.71 and associated libs but passes with 1.3.61.
 - [`KT-38857`](https://youtrack.jetbrains.com/issue/KT-38857) Class versions V1_5 or less must use F_NEW frames.
 - [`KT-39113`](https://youtrack.jetbrains.com/issue/KT-39113) "AssertionError: Uninitialized value on stack" with EXACTLY_ONCE contract in non-inline function and lambda destructuring
-- [`KT-28483`](https://youtrack.jetbrains.com/issue/KT-28483) Override of generic-return-typed function with inline class should lead to a boxing
-- [`KT-37963`](https://youtrack.jetbrains.com/issue/KT-37963) ClassCastException: Value of inline class represented as 'java.lang.Object' is not boxed properly on return from lambda
 
 ### Docs & Examples
 
@@ -826,7 +325,6 @@
 - [`KT-38579`](https://youtrack.jetbrains.com/issue/KT-38579) New Project wizard 1.4+: multiplatform mobile application: build fails on lint task: Configuration with name 'compileClasspath' not found
 - [`KT-38929`](https://youtrack.jetbrains.com/issue/KT-38929) New project wizard: update libraries in project template according to kotlin IDE plugin version
 - [`KT-38417`](https://youtrack.jetbrains.com/issue/KT-38417) Enable new project wizard by-default
-- [`KT-38158`](https://youtrack.jetbrains.com/issue/KT-38158) java.lang.NullPointerException when try to create new project via standard wizard on Mac os
 
 ### JS. Tools
 
@@ -879,7 +377,6 @@
 - [`KT-16529`](https://youtrack.jetbrains.com/issue/KT-16529) Names of KProperty's type parameters are inconsistent with ReadOnlyProperty/ReadWriteProperty
 - [`KT-36356`](https://youtrack.jetbrains.com/issue/KT-36356) Specify which element Iterable.distinctBy(selector) retains
 - [`KT-38060`](https://youtrack.jetbrains.com/issue/KT-38060) runningFold and runningReduce instead of scanReduce
-- [`KT-38566`](https://youtrack.jetbrains.com/issue/KT-38566) Kotlin/JS IR: kx.serialization & ktor+JsonFeature: SerializationException: Can't locate argument-less serializer for class
 
 ### Reflection
 
@@ -1509,33 +1006,6 @@
 - [`KT-35414`](https://youtrack.jetbrains.com/issue/KT-35414) Switch for `-Xexpression` to `-expression`/`-e` cli argument syntax for JVM cli compiler in 1.4
 
 
-## 1.3.72 - IDE plugins update
-
-### Backend. JVM
-
-- [`KT-39013`](https://youtrack.jetbrains.com/issue/KT-39013) 202, ASM 8: "AnalyzerException: Execution can fall off the end of the code"
-
-### IDE. Decompiler, Indexing, Stubs
-
-- [`KT-37896`](https://youtrack.jetbrains.com/issue/KT-37896) IAE: "Argument for @NotNull parameter 'file' of IndexTodoCacheManagerImpl.getTodoCount must not be null" through KotlinTodoSearcher.processQuery()
-
-### IDE. Gradle Integration 
-
-- [`KT-38037`](https://youtrack.jetbrains.com/issue/KT-38037) UnsupportedOperationException on sync gradle Kotlin project with at least two multiplatform modules
-
-### IDE. Highlighting 
-
-- [`KT-39590`](https://youtrack.jetbrains.com/issue/KT-39590) Turn new inference in IDE for 1.3.70 version off
-
-### IDE. Refactorings 
-
-- [`KT-38527`](https://youtrack.jetbrains.com/issue/KT-38527) Move nested class to upper level fails silently: MissingResourceException
-
-### Tools.JPS
-
-- [`KT-27458`](https://youtrack.jetbrains.com/issue/KT-27458) The Kotlin standard library is not found in the module graph ... in a non-Kotlin project.
-
-
 ## 1.3.72
 
 ### Compiler

ReadMe.md

@@ -41,12 +41,7 @@ For local development, if you're not working on bytecode generation or the stand
 
 You also can use [Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties) to setup `JDK_*` variables.
 
-Note: The JDK 6 for MacOS is not available on Oracle's site. You can install it by
-
-```bash
-$ brew tap caskroom/versions
-$ brew cask install java6
-```
+> Note: The JDK 6 for MacOS is not available on Oracle's site. You can [download it here](https://support.apple.com/kb/DL1572).
 
 On Windows you might need to add long paths setting to the repo:
 
@@ -86,8 +81,6 @@ command line parameters on the first run:
 - `compilerTest` - build and run all compiler tests
 - `ideaPluginTest` - build and run all IDEA plugin tests
 
-To reproduce TeamCity build use `-Pteamcity=true` flag. Local builds don't run proguard and have jar compression disabled by default.
-
 **OPTIONAL:** Some artifacts, mainly Maven plugin ones, are built separately with Maven.
 Refer to [libraries/ReadMe.md](libraries/ReadMe.md) for details.
 

benchmarks/build.gradle.kts

@@ -40,7 +40,6 @@ repositories {
 dependencies {
     compile(kotlinStdlib())
     compile(project(":compiler:frontend"))
-    compile(projectTests(":compiler:tests-common"))
     compile(project(":compiler:cli"))
     compile(intellijCoreDep()) { includeJars("intellij-core") }
     compile(jpsStandalone()) { includeJars("jps-model") }
@@ -74,7 +73,6 @@ benchmark {
             param("size", 1000)
 
             include("CommonCallsBenchmark")
-            include("ControlFlowAnalysisBenchmark")
             //include("InferenceBaselineCallsBenchmark")
         }
 
@@ -97,52 +95,3 @@ benchmark {
         register("main")
     }
 }
-
-tasks.named("classes") {
-    doLast {
-        tasks.named("mainBenchmarkJar", Zip::class.java) {
-            isZip64 = true
-            archiveName = "benchmarks.jar"
-        }
-        listOf("mainBenchmark", "mainFirBenchmark", "mainNiBenchmark").forEach {
-            tasks.named(it, JavaExec::class.java) {
-                systemProperty("idea.home.path", intellijRootDir().canonicalPath)
-            }
-        }
-    }
-}
-
-tasks.register<JavaExec>("runBenchmark") {
-    // jmhArgs example: -PjmhArgs='CommonCalls -p size=500 -p isIR=true -p useNI=true -f 1'
-    val jmhArgs = if (project.hasProperty("jmhArgs")) project.property("jmhArgs").toString() else ""
-    val resultFilePath = "$buildDir/benchmarks/jmh-result.json"
-    val ideaHome = intellijRootDir().canonicalPath
-
-    val benchmarkJarPath = "$buildDir/benchmarks/main/jars/benchmarks.jar"
-    args = mutableListOf("-Didea.home.path=$ideaHome", benchmarkJarPath, "-rf", "json", "-rff", resultFilePath) + jmhArgs.split("\\s".toRegex())
-    main = "-jar"
-
-    doLast {
-        if (project.kotlinBuildProperties.isTeamcityBuild) {
-            val jsonArray = com.google.gson.JsonParser.parseString(File(resultFilePath).readText()).asJsonArray
-            jsonArray.forEach {
-                val benchmark = it.asJsonObject
-                // remove unnecessary name parts from string like this "org.jetbrains.kotlin.benchmarks.CommonCallsBenchmark.benchmark"
-                val name = benchmark["benchmark"].asString.removeSuffix(".benchmark").let {
-                    val indexOfLastDot = it.indexOfLast { it == '.' }
-                    it.removeRange(0..indexOfLastDot)
-                }
-                val params = benchmark["params"].asJsonObject
-                val isIR = if (params.has("isIR")) params["isIR"].asString else "false"
-                val useNI = if (params.has("useNI")) params["useNI"].asString else "false"
-                val size = params["size"].asString
-                val score = "%.3f".format(benchmark["primaryMetric"].asJsonObject["score"].asString.toFloat())
-
-                val irPostfix = if (isIR.toBoolean()) " isIR=true" else ""
-                val niPostfix = if (useNI.toBoolean() && !isIR.toBoolean()) " isNI=true" else ""
-
-                println("""##teamcity[buildStatisticValue key='$name size=$size${irPostfix}$niPostfix' value='$score']""")
-            }
-        }
-    }
-}

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

@@ -13,6 +13,7 @@ import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.impl.PsiFileFactoryImpl
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.LightVirtualFile
+import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
@@ -25,15 +26,21 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
-import org.jetbrains.kotlin.fir.createSession
-import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
+import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
+import org.jetbrains.kotlin.fir.java.FirLibrarySession
+import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
@@ -163,10 +170,43 @@ abstract class AbstractSimpleFileBenchmark {
         totalTransformer.process(listOf(firFile))
 
         bh.consume(firFile.hashCode())
-        Extensions.getArea(env.project)
-            .getExtensionPoint(PsiElementFinder.EP_NAME)
-            .unregisterExtension(FirJavaElementFinder::class.java)
     }
 
     protected abstract fun buildText(): String
 }
+
+fun createSession(
+    environment: KotlinCoreEnvironment,
+    sourceScope: GlobalSearchScope,
+    librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope)
+): FirSession {
+    val moduleInfo = FirTestModuleInfo()
+    val project = environment.project
+    val provider = FirProjectSessionProvider(project)
+    return FirJavaModuleBasedSession.create(moduleInfo, provider, sourceScope).also {
+        createSessionForDependencies(provider, moduleInfo, librariesScope, environment)
+    }
+}
+
+private fun createSessionForDependencies(
+    provider: FirProjectSessionProvider,
+    moduleInfo: FirTestModuleInfo,
+    librariesScope: GlobalSearchScope,
+    environment: KotlinCoreEnvironment
+) {
+    val dependenciesInfo = FirTestModuleInfo()
+    moduleInfo.dependencies.add(dependenciesInfo)
+    FirLibrarySession.create(
+        dependenciesInfo, provider, librariesScope, environment.project,
+        environment.createPackagePartProvider(librariesScope)
+    )
+}
+
+class FirTestModuleInfo(
+    override val name: Name = Name.identifier("TestModule"),
+    val dependencies: MutableList<ModuleInfo> = mutableListOf(),
+    override val platform: TargetPlatform = JvmPlatforms.unspecifiedJvmPlatform,
+    override val analyzerServices: PlatformDependentAnalyzerServices = JvmPlatformAnalyzerServices
+) : ModuleInfo {
+    override fun dependencies(): List<ModuleInfo> = dependencies
+}

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

@@ -1,35 +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.benchmarks
-
-import org.openjdk.jmh.annotations.*
-import org.openjdk.jmh.infra.Blackhole
-import java.util.concurrent.TimeUnit
-
-@BenchmarkMode(Mode.AverageTime)
-@OutputTimeUnit(TimeUnit.MILLISECONDS)
-@State(Scope.Benchmark)
-open class ControlFlowAnalysisBenchmark : AbstractSimpleFileBenchmark() {
-    @Param("1000")
-    private var size: Int = 0
-
-    @Benchmark
-    fun benchmark(bh: Blackhole) {
-        analyzeGreenFile(bh)
-    }
-
-    override fun buildText() =
-        buildString {
-            appendLine("fun test() {")
-            for (i in 0 until size) {
-                appendLine("for (i$i in 0..10) { ")
-            }
-            for (i in 0 until size) {
-                appendLine("}")
-            }
-            appendLine("}")
-        }
-}

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.PersistentHashMap
+import com.intellij.util.io.JpsPersistentHashMap
 import java.io.File
 
 
@@ -28,10 +28,10 @@ class NonCachingLazyStorage<K, V>(
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
     @Volatile
-    private var storage: PersistentHashMap<K, V>? = null
+    private var storage: JpsPersistentHashMap<K, V>? = null
 
     @Synchronized
-    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
         if (storage != null) return storage
 
         if (storageFile.exists()) {
@@ -43,7 +43,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     @Synchronized
-    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
         if (storage == null) {
             storage = createMap()
         }
@@ -69,7 +69,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
+        getStorageOrCreateNew().appendDataWithoutCache(key, value)
     }
 
     @Synchronized
@@ -79,7 +79,7 @@ class NonCachingLazyStorage<K, V>(
         } catch (ignored: Throwable) {
         }
 
-        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
         storage = null
     }
 
@@ -101,6 +101,6 @@ class NonCachingLazyStorage<K, V>(
         storage?.close()
     }
 
-    private fun createMap(): PersistentHashMap<K, V> =
-        PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+    private fun createMap(): JpsPersistentHashMap<K, V> =
+        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
 }

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.incremental.storage
 
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.JpsPersistentHashMap
+import com.intellij.util.io.PersistentHashMap
 import java.io.File
 
 
@@ -28,10 +28,10 @@ class NonCachingLazyStorage<K, V>(
     private val valueExternalizer: DataExternalizer<V>
 ) : LazyStorage<K, V> {
     @Volatile
-    private var storage: JpsPersistentHashMap<K, V>? = null
+    private var storage: PersistentHashMap<K, V>? = null
 
     @Synchronized
-    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
         if (storage != null) return storage
 
         if (storageFile.exists()) {
@@ -43,7 +43,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     @Synchronized
-    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
         if (storage == null) {
             storage = createMap()
         }
@@ -69,7 +69,7 @@ class NonCachingLazyStorage<K, V>(
     }
 
     override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendDataWithoutCache(key, value)
+        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
     }
 
     @Synchronized
@@ -79,7 +79,7 @@ class NonCachingLazyStorage<K, V>(
         } catch (ignored: Throwable) {
         }
 
-        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
         storage = null
     }
 
@@ -101,6 +101,6 @@ class NonCachingLazyStorage<K, V>(
         storage?.close()
     }
 
-    private fun createMap(): JpsPersistentHashMap<K, V> =
-        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
+    private fun createMap(): PersistentHashMap<K, V> =
+        PersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
 }

build.gradle.kts

@@ -27,7 +27,7 @@ buildscript {
     dependencies {
         bootstrapCompilerClasspath(kotlin("compiler-embeddable", bootstrapKotlinVersion))
 
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
         classpath(kotlin("gradle-plugin", bootstrapKotlinVersion))
         classpath("org.jetbrains.dokka:dokka-gradle-plugin:0.9.17")
     }
@@ -152,7 +152,6 @@ rootProject.apply {
     from(rootProject.file("gradle/jps.gradle.kts"))
     from(rootProject.file("gradle/checkArtifacts.gradle.kts"))
     from(rootProject.file("gradle/checkCacheability.gradle.kts"))
-    from(rootProject.file("gradle/retryPublishing.gradle.kts"))
 }
 
 IdeVersionConfigurator.setCurrentIde(project)
@@ -178,7 +177,7 @@ extra["versions.jflex"] = "1.7.0"
 extra["versions.markdown"] = "0.1.25"
 extra["versions.trove4j"] = "1.0.20181211"
 extra["versions.completion-ranking-kotlin"] = "0.1.2"
-extra["versions.r8"] = "2.0.88"
+extra["versions.r8"] = "1.5.70"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -193,7 +192,6 @@ if (!project.hasProperty("versions.kotlin-native")) {
 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.getBooleanProperty("kotlin.build.useIR") ?: false)
 
 val intellijSeparateSdks = project.getBooleanProperty("intellijSeparateSdks") ?: false
 
@@ -229,8 +227,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:frontend.java",
     ":compiler:cli-common",
     ":compiler:ir.tree",
-    ":compiler:ir.tree.impl",
-    ":compiler:ir.tree.persistent",
     ":compiler:ir.psi2ir",
     ":compiler:ir.backend.common",
     ":compiler:backend.jvm",
@@ -239,7 +235,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:ir.serialization.common",
     ":compiler:ir.serialization.js",
     ":compiler:ir.serialization.jvm",
-    ":compiler:ir.interpreter",
     ":kotlin-util-io",
     ":kotlin-util-klib",
     ":kotlin-util-klib-metadata",
@@ -312,6 +307,7 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-stdlib",
     ":kotlin-stdlib-common",
     ":kotlin-stdlib-js",
+    ":kotlin-stdlib-js-ir",
     ":kotlin-stdlib-jdk7",
     ":kotlin-stdlib-jdk8",
     ":kotlin-test:kotlin-test-annotations-common",
@@ -321,6 +317,7 @@ val coreLibProjects = listOfNotNull(
     ":kotlin-test:kotlin-test-junit5",
     ":kotlin-test:kotlin-test-testng",
     ":kotlin-test:kotlin-test-js".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
+    ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
     ":kotlin-reflect",
     ":kotlin-coroutines-experimental-compat"
 )
@@ -369,15 +366,6 @@ allprojects {
         }
     }
 
-    configurations.maybeCreate("embeddedElements").apply {
-        extendsFrom(configurations["embedded"])
-        isCanBeConsumed = true
-        isCanBeResolved = false
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, objects.named("embedded-java-runtime"))
-        }
-    }
-
     jvmTarget = defaultJvmTarget
     javaHome = defaultJavaHome
 
@@ -408,6 +396,9 @@ allprojects {
     val commonCompilerArgs = listOfNotNull(
         "-Xopt-in=kotlin.RequiresOptIn",
         "-Xread-deserialized-contracts",
+        "-Xjvm-default=compatibility",
+        "-Xno-optimized-callable-references",
+        "-Xno-kotlin-nothing-value-exception",
         "-progressive".takeIf { hasProperty("test.progressive.mode") }
     )
 
@@ -419,20 +410,9 @@ allprojects {
         }
     }
 
-    val jvmCompilerArgs = listOf(
-        "-Xjvm-default=compatibility",
-        "-Xno-optimized-callable-references",
-        "-Xno-kotlin-nothing-value-exception",
-        "-Xnormalize-constructor-calls=enable"
-    )
-
     tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
         kotlinOptions {
-            freeCompilerArgs = commonCompilerArgs + jvmCompilerArgs
-
-            if (useJvmIrBackend) {
-                useIR = true
-            }
+            freeCompilerArgs = commonCompilerArgs + listOf("-Xnormalize-constructor-calls=enable")
         }
     }
 
@@ -462,7 +442,6 @@ allprojects {
             ignore("META-INF/MANIFEST.MF")
             ignore("META-INF/compiler.version")
             ignore("META-INF/plugin.xml")
-            ignore("kotlin/KotlinVersionCurrentValue.class")
         }
     }
 
@@ -519,12 +498,9 @@ gradle.taskGraph.whenReady {
     fun Boolean.toOnOff(): String = if (this) "on" else "off"
     val profile = if (isTeamcityBuild) "CI" else "Local"
 
-    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("\n\n$profileMessage")
+    logger.warn("$profile build profile is active (proguard is ${kotlinBuildProperties.proguard.toOnOff()}" +
+                            ", jar compression is ${kotlinBuildProperties.jarCompression.toOnOff()})." +
+                            " Use -Pteamcity=<true|false> to reproduce CI/local build")
 
     allTasks.filterIsInstance<org.gradle.jvm.tasks.Jar>().forEach { task ->
         task.entryCompression = if (kotlinBuildProperties.jarCompression)
@@ -538,10 +514,6 @@ val dist = tasks.register("dist") {
     dependsOn(":kotlin-compiler:dist")
 }
 
-val syncMutedTests = tasks.register("syncMutedTests") {
-    dependsOn(":compiler:tests-mutes:run")
-}
-
 val copyCompilerToIdeaPlugin by task<Copy> {
     dependsOn(dist)
     into(ideaPluginDir)
@@ -567,7 +539,7 @@ tasks {
         }
     }
 
-    listOf("clean", "assemble", "install").forEach { taskName ->
+    listOf("clean", "assemble", "install", "dist").forEach { taskName ->
         register("coreLibs${taskName.capitalize()}") {
             coreLibProjects.forEach { projectName -> dependsOn("$projectName:$taskName") }
         }
@@ -576,8 +548,6 @@ tasks {
     register("coreLibsTest") {
         (coreLibProjects + listOf(
             ":kotlin-stdlib:samples",
-            ":kotlin-stdlib-js-ir",
-            ":kotlin-test:kotlin-test-js-ir".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlin-test:kotlin-test-js:kotlin-test-js-it".takeIf { !kotlinBuildProperties.isInJpsBuildIdeaSync },
             ":kotlinx-metadata-jvm",
             ":tools:binary-compatibility-validator"
@@ -666,7 +636,6 @@ tasks {
         dependsOn(":kotlin-scripting-jsr223-test:embeddableTest")
         dependsOn(":kotlin-main-kts-test:test")
         dependsOn(":kotlin-scripting-ide-services-test:test")
-        dependsOn(":kotlin-scripting-ide-services-test:embeddableTest")
         dependsOn(":kotlin-scripting-js-test:test")
     }
 
@@ -723,9 +692,16 @@ tasks {
         dependsOn(":jps-plugin:test")
     }
 
+    register("idea-plugin-main-tests") {
+        dependsOn("dist")
+        dependsOn(":idea:test")
+    }
+
     register("idea-plugin-additional-tests") {
         dependsOn("dist")
         dependsOn(
+            ":idea:idea-gradle:test",
+            ":idea:idea-gradle-native:test",
             ":idea:idea-maven:test",
             ":j2k:test",
             ":nj2k:test",
@@ -748,6 +724,17 @@ tasks {
         }
     }
 
+    register("idea-plugin-tests") {
+        dependsOn("dist")
+        dependsOn(
+            "idea-plugin-main-tests",
+            "idea-plugin-additional-tests"
+        )
+        if (Ide.IJ()) {
+            dependsOn("idea-new-project-wizard-tests")
+        }
+    }
+
     register("idea-plugin-performance-tests") {
         dependsOn("dist")
         dependsOn(
@@ -764,21 +751,10 @@ tasks {
         )
     }
 
-    register("ideaPluginTest") {
-        dependsOn(
-            "mainIdeTests",
-            "gradleIdeTest",
-            "kaptIdeTest",
-            "miscIdeTests"
-        )
-    }
-
-    register("mainIdeTests") {
-        dependsOn(":idea:test")
-    }
-
-    register("miscIdeTests") {
+    register("plugins-tests") {
+        dependsOn("dist")
         dependsOn(
+            ":kotlin-annotation-processing:test",
             ":kotlin-allopen-compiler-plugin:test",
             ":kotlin-noarg-compiler-plugin:test",
             ":kotlin-sam-with-receiver-compiler-plugin:test",
@@ -786,58 +762,19 @@ tasks {
             ":kotlin-annotation-processing-gradle:test",
             ":kotlinx-serialization-compiler-plugin:test",
             ":kotlinx-serialization-ide-plugin:test",
-            ":idea:jvm-debugger:jvm-debugger-test:test",
-            "idea-plugin-additional-tests",
+            ":idea:jvm-debugger:jvm-debugger-test:test"
+        )
+    }
+
+
+    register("ideaPluginTest") {
+        dependsOn(
+            "idea-plugin-tests",
             "jps-tests",
+            "plugins-tests",
+            "android-ide-tests",
             ":generators:test"
         )
-        if (Ide.IJ()) {
-            dependsOn("idea-new-project-wizard-tests")
-        }
-    }
-
-    register("kaptIdeTest") {
-        dependsOn(":kotlin-annotation-processing:test")
-    }
-
-    register("gradleIdeTest") {
-        dependsOn(
-            ":idea:idea-gradle:test",
-            ":idea:idea-gradle-native:test"
-        )
-    }
-
-    register("kmmTest", AggregateTest::class) {
-        dependsOn(
-            ":idea:idea-gradle:test",
-            ":idea:test",
-            ":compiler:test",
-            ":js:js.tests:test"
-        )
-        if (Ide.IJ193.orHigher())
-            dependsOn(":kotlin-gradle-plugin-integration-tests:test")
-        if (Ide.AS40.orHigher())
-            dependsOn(":kotlin-ultimate:ide:android-studio-native:test")
-
-        testPatternFile = file("tests/mpp/kmm-patterns.csv")
-    }
-
-    register("test") {
-        doLast {
-            throw GradleException("Don't use directly, use aggregate tasks *-check instead")
-        }
-    }
-
-    named("check") {
-        dependsOn("test")
-    }
-
-    named("checkBuild") {
-        if (kotlinBuildProperties.isTeamcityBuild) {
-            doFirst {
-                println("##teamcity[setParameter name='bootstrap.kotlin.version' value='$bootstrapKotlinVersion']")
-            }
-        }
     }
 
     register("publishIdeArtifacts") {
@@ -867,12 +804,28 @@ tasks {
                 ":kotlin-stdlib-jdk7:publish",
                 ":kotlin-stdlib-jdk8:publish",
                 ":kotlin-reflect:publish",
-                ":kotlin-main-kts:publish",
-                ":kotlin-stdlib-js:publish",
-                ":kotlin-test:kotlin-test-js:publish"
+                ":kotlin-main-kts:publish"
             )
         }
     }
+
+    register("test") {
+        doLast {
+            throw GradleException("Don't use directly, use aggregate tasks *-check instead")
+        }
+    }
+
+    named("check") {
+        dependsOn("test")
+    }
+
+    named("checkBuild") {
+        if (kotlinBuildProperties.isTeamcityBuild) {
+            doFirst {
+                println("##teamcity[setParameter name='bootstrap.kotlin.version' value='$bootstrapKotlinVersion']")
+            }
+        }
+    }
 }
 
 fun CopySpec.setExecutablePermissions() {
@@ -1105,4 +1058,4 @@ if (disableVerificationTasks) {
             }
         }
     }
-}
+}

buildSrc/build.gradle.kts

@@ -22,7 +22,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
         classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
@@ -96,8 +96,7 @@ repositories {
 
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
     implementation("com.gradle.publish:plugin-publish-plugin:0.11.0")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")

buildSrc/prepare-deps/build.gradle.kts

@@ -1,16 +1,17 @@
 @file:Suppress("PropertyName", "HasPlatformType", "UnstableApiUsage")
 
 import org.gradle.internal.os.OperatingSystem
-import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
 import java.io.Closeable
 import java.io.OutputStreamWriter
 import java.net.URI
 import java.text.SimpleDateFormat
-import java.time.Duration
-import java.time.Instant
 import java.util.*
 import javax.xml.stream.XMLOutputFactory
 
+import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
+import java.time.Duration
+import java.time.Instant
+
 plugins {
     base
 }
@@ -179,7 +180,6 @@ val mergeSources by tasks.creating(Jar::class.java) {
     dependsOn(sources)
     isPreserveFileTimestamps = false
     isReproducibleFileOrder = true
-    isZip64 = true
     if (!kotlinBuildProperties.isTeamcityBuild) {
         from(provider { sources.map(::zipTree) })
     }

buildSrc/settings.gradle

@@ -20,7 +20,7 @@ buildscript {
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.19")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.17")
     }
 }
 

buildSrc/src/main/kotlin/AggregateTest.kt

@@ -1,72 +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 org.gradle.api.GradleException
-import org.gradle.api.tasks.*
-import org.gradle.api.tasks.testing.Test
-import java.io.File
-
-// You can see "How To" via link: https://jetbrains.quip.com/xQ2WAUy9bZmy/How-to-use-AggregateTest-task
-open class AggregateTest : Test() { // Inherit from Test to see test results in IDEA Test viewer
-    private var patterns: MutableMap<String, MutableList<String>> = mutableMapOf()
-
-    @InputFile
-    lateinit var testPatternFile: File
-
-    init {
-        // Set empty FileCollection to avoid NPE when initializing a base 'Test' class
-        classpath = project.objects.fileCollection()
-        testClassesDirs = project.objects.fileCollection()
-
-        project.gradle.taskGraph.whenReady {
-            if (allTasks.filterIsInstance<AggregateTest>().isNotEmpty()) {
-                initPatterns()
-                allTasks.filterIsInstance<Test>().forEach { testTask -> subTaskConfigure(testTask) }
-
-                if (!project.gradle.startParameter.taskNames.all { project.tasks.findByPath(it) is AggregateTest }) {
-                    logger.warn("Please, don't use AggregateTest and non-AggregateTest test tasks together. You can get incorrect results.")
-                }
-            }
-        }
-    }
-
-    private fun initPatterns() {
-        if (!testPatternFile.exists())
-            throw GradleException("File with test patterns is not found")
-        testPatternFile
-            .readLines()
-            .asSequence()
-            .filter { it.isNotEmpty() }
-            .forEach { line ->
-                // patternType is exclude or include value
-                val (pattern, patternType) = line.split(',').map { it.trim() }
-                patterns.getOrPut(patternType) { mutableListOf() }.add(pattern)
-            }
-    }
-
-    private fun subTaskConfigure(testTask: Test) {
-        testTask.outputs.upToDateWhen { false }
-        testTask.ignoreFailures = true
-        testTask.filter {
-            isFailOnNoMatchingTests = false
-            patterns["include"]?.let {
-                it.forEach { pattern ->
-                    includeTestsMatching(pattern)
-                }
-            }
-            patterns["exclude"]?.let {
-                it.forEach { pattern ->
-                    excludeTestsMatching(pattern)
-                }
-            }
-        }
-    }
-
-    @Override
-    @TaskAction
-    override fun executeTests() {
-        // Do nothing
-    }
-}

buildSrc/src/main/kotlin/CommonUtil.kt

@@ -56,7 +56,7 @@ var Project.javaHome: String?
 
 fun Project.generator(fqName: String, sourceSet: SourceSet? = null) = smartJavaExec {
     classpath = (sourceSet ?: testSourceSet).runtimeClasspath
-    mainClass.set(fqName)
+    main = fqName
     workingDir = rootDir
     systemProperty("line.separator", "\n")
 }

buildSrc/src/main/kotlin/IdeCompatibilityDsl.kt

@@ -26,7 +26,7 @@ fun CompatibilityPredicate.or(other: CompatibilityPredicate): CompatibilityPredi
 }
 
 enum class Platform : CompatibilityPredicate {
-    P183, P191, P192, P193, P201, P202, P203;
+    P183, P191, P192, P193, P201, P202;
 
     val version: Int = name.drop(1).toInt()
 
@@ -48,7 +48,6 @@ enum class Ide(val platform: Platform) : CompatibilityPredicate {
     IJ193(Platform.P193),
     IJ201(Platform.P201),
     IJ202(Platform.P202),
-    IJ203(Platform.P203),
 
     AS35(Platform.P183),
     AS36(Platform.P192),

buildSrc/src/main/kotlin/SmartJavaExec.kt

@@ -23,10 +23,6 @@ fun JavaExec.passClasspathInJar() {
         dependsOn(classpath)
         inputs.files(classpath)
         inputs.property("main", main)
-
-        archiveFileName.set("$main.${this@passClasspathInJar.name}.classpath.container.jar")
-        destinationDirectory.set(temporaryDir)
-
         doFirst {
             val classPathString = classpath.joinToString(" ") { project.file(it).toURI().toString() }
             manifest {
@@ -38,11 +34,16 @@ fun JavaExec.passClasspathInJar() {
                 )
             }
         }
+        archiveName = "$main.${this@passClasspathInJar.name}.classpath.container.$extension"
+        destinationDir = temporaryDir
     }
 
     dependsOn(jarTask)
 
-    main = "-jar"
-    classpath = project.files()
-    args = listOf(jarTask.outputs.files.singleFile.path) + args.orEmpty()
+    doFirst {
+        main = "-jar"
+
+        classpath = project.files()
+        args = listOf(jarTask.outputs.files.singleFile.path) + args.orEmpty()
+    }
 }

buildSrc/src/main/kotlin/artifacts.kt

@@ -27,7 +27,6 @@ import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.tasks.Jar
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import plugins.KotlinBuildPublishingPlugin
 
 
@@ -130,16 +129,10 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
     }
 
     val sourcesJar = getOrCreateTask<Jar>("sourcesJar") {
-        fun Project.mainJavaPluginSourceSet() = findJavaPluginConvention()?.sourceSets?.findByName("main")
-        fun Project.mainKotlinSourceSet() =
-            (extensions.findByName("kotlin") as? KotlinSourceSetContainer)?.sourceSets?.findByName("main")
-
-        fun Project.sources() = mainJavaPluginSourceSet()?.allSource ?: mainKotlinSourceSet()?.kotlin
-
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         archiveClassifier.set("sources")
 
-        from(project.sources())
+        from(project.mainSourceSet.allSource)
 
         project.configurations.findByName("embedded")?.let { embedded ->
             from(provider {
@@ -148,7 +141,10 @@ fun Project.sourcesJar(body: Jar.() -> Unit = {}): TaskProvider<Jar> {
                     .map { it.id.componentIdentifier }
                     .filterIsInstance<ProjectComponentIdentifier>()
                     .mapNotNull {
-                        project(it.projectPath).sources()
+                        project(it.projectPath)
+                            .findJavaPluginConvention()
+                            ?.mainSourceSet
+                            ?.allSource
                     }
             })
         }

buildSrc/src/main/kotlin/dependencies.kt

@@ -1,8 +1,3 @@
-/*
- * 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.
- */
-
 @file:Suppress("unused")
 
 // usages in build scripts are not tracked properly
@@ -102,11 +97,9 @@ fun Project.kotlinStdlib(suffix: String? = null, classifier: String? = null): An
         dependencies.project(listOfNotNull(":kotlin-stdlib", suffix).joinToString("-"), classifier)
 }
 
-fun Project.kotlinBuiltins(): Any = kotlinBuiltins(forJvm = false)
-
-fun Project.kotlinBuiltins(forJvm: Boolean): Any =
+fun Project.kotlinBuiltins(): Any =
     if (kotlinBuildProperties.useBootstrapStdlib) "org.jetbrains.kotlin:builtins:$bootstrapKotlinVersion"
-    else dependencies.project(":core:builtins", configuration = "runtimeElementsJvm".takeIf { forJvm })
+    else dependencies.project(":core:builtins")
 
 fun DependencyHandler.projectTests(name: String): ProjectDependency = project(name, configuration = "tests-jar")
 fun DependencyHandler.projectRuntimeJar(name: String): ProjectDependency = project(name, configuration = "runtimeJar")

buildSrc/src/main/kotlin/localDependencies.kt

@@ -165,7 +165,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
 
         classpath = mainSourceSet.runtimeClasspath
 
-        mainClass.set("com.intellij.idea.Main")
+        main = "com.intellij.idea.Main"
 
         workingDir = File(intellijRootDir(), "bin")
 
@@ -184,7 +184,7 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-Dplugin.path=${ideaPluginDir.absolutePath}"
         )
 
-        if (Platform[201].orHigher() && !isIntellijUltimateSdkAvailable()) {
+        if (Platform[201].orHigher()) {
             jvmArgs("-Didea.platform.prefix=Idea")
         }
 

buildSrc/src/main/kotlin/pluginMarkers.kt

@@ -9,16 +9,12 @@ import org.gradle.api.Project
 import org.gradle.api.publish.PublicationContainer
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.kotlin.dsl.*
 import plugins.KotlinBuildPublishingPlugin
-import plugins.configureRepository
-import java.util.*
 
 internal const val PLUGIN_MARKER_SUFFIX = ".gradle.plugin"
 
-@UseExperimental(ExperimentalStdlibApi::class)
 fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
     val pluginDevelopment = extensions.getByType<PluginBundleExtension>()
     val publishingExtension = extensions.getByType<PublishingExtension>()
@@ -29,10 +25,6 @@ fun Project.publishPluginMarkers(withEmptyJars: Boolean = true) {
         if (withEmptyJars) {
             addEmptyJarArtifacts(markerPublication)
         }
-
-        tasks.named<PublishToMavenRepository>(
-            "publish${markerPublication.name.capitalize(Locale.ROOT)}PublicationTo${KotlinBuildPublishingPlugin.REPOSITORY_NAME}Repository"
-        ).configureRepository()
     }
 }
 

buildSrc/src/main/kotlin/plugins/KotlinBuildPublishingPlugin.kt

@@ -15,11 +15,9 @@ import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.maven.plugins.MavenPublishPlugin
 import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
-import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.*
 import org.gradle.plugins.signing.SigningExtension
 import org.gradle.plugins.signing.SigningPlugin
-import java.net.URI
 import java.util.*
 import javax.inject.Inject
 
@@ -121,8 +119,25 @@ class KotlinBuildPublishingPlugin @Inject constructor(
             dependsOn(tasks.named("publishToMavenLocal"))
         }
 
-        tasks.named<PublishToMavenRepository>("publish${PUBLICATION_NAME}PublicationTo${REPOSITORY_NAME}Repository")
-            .configureRepository()
+        tasks.named<PublishToMavenRepository>("publish${PUBLICATION_NAME}PublicationTo${REPOSITORY_NAME}Repository") {
+            dependsOn(project.rootProject.tasks.named("preparePublication"))
+            doFirst {
+                val preparePublication = project.rootProject.tasks.named("preparePublication").get()
+                val username: String? by preparePublication.extra
+                val password: String? by preparePublication.extra
+                val repoUrl: String by preparePublication.extra
+
+                repository.apply {
+                    url = uri(repoUrl)
+                    if (url.scheme != "file" && username != null && password != null) {
+                        credentials {
+                            this.username = username
+                            this.password = password
+                        }
+                    }
+                }
+            }
+        }
     }
 
     companion object {
@@ -137,24 +152,4 @@ class KotlinBuildPublishingPlugin @Inject constructor(
         fun humanReadableName(project: Project) =
             project.name.split("-").joinToString(separator = " ") { it.capitalize(Locale.ROOT) }
     }
-}
-
-fun TaskProvider<PublishToMavenRepository>.configureRepository() = configure {
-    dependsOn(project.rootProject.tasks.named("preparePublication"))
-    doFirst {
-        val preparePublication = project.rootProject.tasks.named("preparePublication").get()
-        val username: String? by preparePublication.extra
-        val password: String? by preparePublication.extra
-        val repoUrl: String by preparePublication.extra
-
-        repository.apply {
-            url = project.uri(repoUrl)
-            if (url.scheme != "file" && username != null && password != null) {
-                credentials {
-                    this.username = username
-                    this.password = password
-                }
-            }
-        }
-    }
 }

buildSrc/src/main/kotlin/tasks.kt

@@ -31,45 +31,6 @@ import java.lang.Character.isUpperCase
 import java.nio.file.Files
 import java.nio.file.Path
 
-fun Task.dependsOnKotlinPluginInstall() {
-    dependsOn(
-        ":kotlin-allopen:install",
-        ":kotlin-noarg:install",
-        ":kotlin-sam-with-receiver:install",
-        ":kotlin-android-extensions:install",
-        ":kotlin-build-common:install",
-        ":kotlin-compiler-embeddable:install",
-        ":native:kotlin-native-utils:install",
-        ":kotlin-util-klib:install",
-        ":kotlin-util-io:install",
-        ":kotlin-compiler-runner:install",
-        ":kotlin-daemon-embeddable:install",
-        ":kotlin-daemon-client:install",
-        ":kotlin-gradle-plugin-api:install",
-        ":kotlin-gradle-plugin:install",
-        ":kotlin-gradle-plugin-model:install",
-        ":kotlin-reflect:install",
-        ":kotlin-annotation-processing-gradle:install",
-        ":kotlin-test:kotlin-test-common:install",
-        ":kotlin-test:kotlin-test-annotations-common:install",
-        ":kotlin-test:kotlin-test-jvm:install",
-        ":kotlin-test:kotlin-test-js:install",
-        ":kotlin-test:kotlin-test-junit:install",
-        ":kotlin-gradle-subplugin-example:install",
-        ":kotlin-stdlib-common:install",
-        ":kotlin-stdlib:install",
-        ":kotlin-stdlib-jdk8:install",
-        ":kotlin-stdlib-js:install",
-        ":examples:annotation-processor-example:install",
-        ":kotlin-script-runtime:install",
-        ":kotlin-scripting-common:install",
-        ":kotlin-scripting-jvm:install",
-        ":kotlin-scripting-compiler-embeddable:install",
-        ":kotlin-scripting-compiler-impl-embeddable:install",
-        ":kotlin-test-js-runner:install"
-    )
-}
-
 fun Project.projectTest(
     taskName: String = "test",
     parallel: Boolean = false,

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

@@ -294,7 +294,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val kind = KotlinBaseTest.extractConfigurationKind(testFiles)
                     val jdkKind = KotlinBaseTest.getTestJdkKind(testFiles)
                     val keyConfiguration = CompilerConfiguration()
-                    KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
+                    CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, keyConfiguration)
 
                     val key = ConfigurationKey(kind, jdkKind, keyConfiguration.toString())
                     val compiler = if (isJvm8Target) {
@@ -303,7 +303,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
                     val filesHolder = holders.getOrPut(key) {
                         FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply {
                             println("Creating new configuration by $key")
-                            KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this)
+                            CodegenTestCase.updateConfigurationByDirectivesInTestFiles(testFiles, this)
                         })
                     }
 

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.backend.common
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.common.bridges.findInterfaceImplementation
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.diagnostics.Errors
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.util.getExceptionMessage
-import org.jetbrains.kotlin.util.getNonPrivateTraitMembersForDelegation
 import org.jetbrains.kotlin.utils.DFS
 import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
 
@@ -55,8 +55,14 @@ object CodegenUtil {
     @JvmOverloads
     fun getNonPrivateTraitMethods(descriptor: ClassDescriptor, copy: Boolean = true): Map<FunctionDescriptor, FunctionDescriptor> {
         val result = linkedMapOf<FunctionDescriptor, FunctionDescriptor>()
+        for (declaration in DescriptorUtils.getAllDescriptors(descriptor.defaultType.memberScope)) {
+            if (declaration !is CallableMemberDescriptor) continue
+
+            val traitMember = findInterfaceImplementation(declaration)
+            if (traitMember == null ||
+                    Visibilities.isPrivate(traitMember.visibility) ||
+                    traitMember.visibility == Visibilities.INVISIBLE_FAKE) continue
 
-        for ((declaration, traitMember) in getNonPrivateTraitMembersForDelegation(descriptor)) {
             assert(traitMember.modality !== Modality.ABSTRACT) { "Cannot delegate to abstract trait method: $declaration" }
 
             // inheritedMember can be abstract here. In order for FunctionCodegen to generate the method body, we're creating a copy here

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt

@@ -24,8 +24,6 @@ import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized
 import org.jetbrains.kotlin.resolve.descriptorUtil.isTypeRefinementEnabled
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.util.findImplementationFromInterface
-import org.jetbrains.kotlin.util.findInterfaceImplementation
 
 fun <Signature> generateBridgesForFunctionDescriptor(
     descriptor: FunctionDescriptor,
@@ -83,4 +81,60 @@ open class DescriptorBasedFunctionHandle(val descriptor: FunctionDescriptor) : F
     override fun toString(): String {
         return descriptor.toString()
     }
-}
+}
+
+
+/**
+ * Given a fake override in a class, returns an overridden declaration with implementation in trait, such that a method delegating to that
+ * trait implementation should be generated into the class containing the fake override; or null if the given function is not a fake
+ * override of any trait implementation or such method was already generated into the superclass or is a method from Any.
+ */
+fun findInterfaceImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
+    if (descriptor.kind.isReal) return null
+    if (isOrOverridesSynthesized(descriptor)) return null
+
+    val implementation = findImplementationFromInterface(descriptor) ?: return null
+    val immediateConcreteSuper = firstSuperMethodFromKotlin(descriptor, implementation) ?: return null
+
+    if (!DescriptorUtils.isInterface(immediateConcreteSuper.containingDeclaration)) {
+        // If this implementation is already generated into the superclass, we need not generate it again, it'll be inherited
+        return null
+    }
+
+    return immediateConcreteSuper
+}
+
+/**
+ * Given a fake override, returns an overridden non-abstract function from an interface which is the actual implementation of this function
+ * that should be called when the given fake override is called.
+ */
+fun findImplementationFromInterface(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
+    val overridden = OverridingUtil.getOverriddenDeclarations(descriptor)
+    val filtered = OverridingUtil.filterOutOverridden(overridden)
+
+    val result = filtered.firstOrNull { it.modality != Modality.ABSTRACT } ?: return null
+
+    if (DescriptorUtils.isClassOrEnumClass(result.containingDeclaration)) return null
+
+    return result
+}
+
+/**
+ * Given a fake override and its implementation (non-abstract declaration) somewhere in supertypes,
+ * returns the first immediate super function of the given fake override which overrides that implementation.
+ * The returned function should be called from TImpl-bridges generated for the given fake override.
+ */
+fun firstSuperMethodFromKotlin(
+    descriptor: CallableMemberDescriptor,
+    implementation: CallableMemberDescriptor
+): CallableMemberDescriptor? {
+    return descriptor.overriddenDescriptors.firstOrNull { overridden ->
+        overridden.modality != Modality.ABSTRACT &&
+                (overridden == implementation || OverridingUtil.overrides(
+                    overridden,
+                    implementation,
+                    overridden.module.isTypeRefinementEnabled(),
+                    true
+                ))
+    }
+}

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

@@ -90,18 +90,12 @@ public abstract class AnnotationCodegen {
     private final KotlinTypeMapper typeMapper;
     private final ModuleDescriptor module;
     private final GenerationState state;
-    private final boolean skipNullabilityAnnotations;
 
     private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state) {
-        this(innerClassConsumer, state, false);
-    }
-
-    private AnnotationCodegen(@NotNull InnerClassConsumer innerClassConsumer, @NotNull GenerationState state, boolean skipNullabilityAnnotations) {
         this.innerClassConsumer = innerClassConsumer;
         this.typeMapper = state.getTypeMapper();
         this.module = state.getModule();
         this.state = state;
-        this.skipNullabilityAnnotations = skipNullabilityAnnotations;
     }
 
     /**
@@ -111,16 +105,6 @@ public abstract class AnnotationCodegen {
             @Nullable Annotated annotated,
             @Nullable Type returnType,
             @Nullable KotlinType typeForTypeAnnotations
-    ) {
-        genAnnotations(annotated, returnType, typeForTypeAnnotations, null, Collections.emptyList());
-    }
-
-    public void genAnnotations(
-            @Nullable Annotated annotated,
-            @Nullable Type returnType,
-            @Nullable KotlinType typeForTypeAnnotations,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer,
-            @NotNull List<String> additionalVisibleAnnotations
     ) {
         if (annotated == null) return;
 
@@ -155,28 +139,22 @@ public abstract class AnnotationCodegen {
             }
         }
 
-        for (String annotation : additionalVisibleAnnotations) {
-            generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotation, true);
-            annotationDescriptorsAlreadyPresent.add(annotation);
-        }
-
-        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
+        generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent);
         generateTypeAnnotations(annotated, typeForTypeAnnotations);
     }
 
     private void generateAdditionalAnnotations(
             @NotNull Annotated annotated,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent
     ) {
         if (annotated instanceof CallableDescriptor) {
-            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent, parameterContainer);
+            generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent);
         }
         else if (annotated instanceof FieldDescriptor) {
             generateAdditionalCallableAnnotations(
-                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent,
-                    parameterContainer);
+                    ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent
+            );
         }
         else if (annotated instanceof ClassDescriptor) {
             generateAdditionalClassAnnotations(annotationDescriptorsAlreadyPresent, (ClassDescriptor) annotated);
@@ -186,15 +164,11 @@ public abstract class AnnotationCodegen {
     private void generateAdditionalCallableAnnotations(
             @NotNull CallableDescriptor descriptor,
             @Nullable Type returnType,
-            @NotNull Set<String> annotationDescriptorsAlreadyPresent,
-            @Nullable DeclarationDescriptorWithVisibility parameterContainer
+            @NotNull Set<String> annotationDescriptorsAlreadyPresent
     ) {
         // No need to annotate privates, synthetic accessors and their parameters
         if (isInvisibleFromTheOutside(descriptor)) return;
-        if (descriptor instanceof ParameterDescriptor &&
-            isInvisibleFromTheOutside(parameterContainer != null ? parameterContainer : descriptor.getContainingDeclaration())) {
-            return;
-        }
+        if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return;
 
         // No need to annotate annotation methods since they're always non-null
         if (descriptor instanceof PropertyGetterDescriptor &&
@@ -202,7 +176,7 @@ public abstract class AnnotationCodegen {
             return;
         }
 
-        if (returnType != null && !AsmUtil.isPrimitive(returnType) && !skipNullabilityAnnotations) {
+        if (returnType != null && !AsmUtil.isPrimitive(returnType)) {
             generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent);
         }
     }
@@ -248,17 +222,17 @@ public abstract class AnnotationCodegen {
             if (!TypeUtils.isNullableType(flexibleType.getLowerBound()) && TypeUtils.isNullableType(flexibleType.getUpperBound())) {
                 AnnotationDescriptor notNull = type.getAnnotations().findAnnotation(JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION);
                 if (notNull != null) {
-                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, Type.getType(NotNull.class).getDescriptor(), false);
+                    generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, NotNull.class);
                 }
                 return;
             }
         }
 
-        generateAnnotationIfNotPresent(
-                annotationDescriptorsAlreadyPresent,
-                TypeUtils.isNullableType(type) ? Type.getType(Nullable.class).getDescriptor() : Type.getType(NotNull.class).getDescriptor(),
-                false
-        );
+        boolean isNullableType = TypeUtils.isNullableType(type);
+
+        Class<?> annotationClass = isNullableType ? Nullable.class : NotNull.class;
+
+        generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
     }
 
     private static final Map<JvmTarget, Map<KotlinTarget, ElementType>> annotationTargetMaps = new EnumMap<>(JvmTarget.class);
@@ -338,13 +312,10 @@ public abstract class AnnotationCodegen {
         visitor.visitEnd();
     }
 
-    private void generateAnnotationIfNotPresent(
-            Set<String> annotationDescriptorsAlreadyPresent,
-            String annotationDescriptor,
-            boolean visible
-    ) {
-        if (!annotationDescriptorsAlreadyPresent.contains(annotationDescriptor)) {
-            visitAnnotation(annotationDescriptor, visible).visitEnd();
+    private void generateAnnotationIfNotPresent(Set<String> annotationDescriptorsAlreadyPresent, Class<?> annotationClass) {
+        String descriptor = Type.getType(annotationClass).getDescriptor();
+        if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) {
+            visitAnnotation(descriptor, false).visitEnd();
         }
     }
 
@@ -629,16 +600,7 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return forMethod(mv, innerClassConsumer, state, false);
-    }
-
-    public static AnnotationCodegen forMethod(
-            @NotNull MethodVisitor mv,
-            @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
-    ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -658,16 +620,7 @@ public abstract class AnnotationCodegen {
             @NotNull InnerClassConsumer innerClassConsumer,
             @NotNull GenerationState state
     ) {
-        return forField(fv, innerClassConsumer, state, false);
-    }
-
-    public static AnnotationCodegen forField(
-            @NotNull FieldVisitor fv,
-            @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
-    ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {
@@ -686,10 +639,9 @@ public abstract class AnnotationCodegen {
             int parameter,
             @NotNull MethodVisitor mv,
             @NotNull InnerClassConsumer innerClassConsumer,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
+            @NotNull GenerationState state
     ) {
-        return new AnnotationCodegen(innerClassConsumer, state, skipNullabilityAnnotations) {
+        return new AnnotationCodegen(innerClassConsumer, state) {
             @NotNull
             @Override
             AnnotationVisitor visitAnnotation(String descr, boolean visible) {

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

@@ -10,6 +10,7 @@ import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
+import org.jetbrains.kotlin.backend.common.bridges.ImplKt;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.codegen.context.ClassContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -38,7 +39,6 @@ import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedS
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL;
-import static org.jetbrains.kotlin.util.DeclarationUtilKt.findInterfaceImplementation;
 
 public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject> {
     @NotNull
@@ -125,7 +125,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
         for (DeclarationDescriptor memberDescriptor : DescriptorUtils.getAllDescriptors(descriptor.getDefaultType().getMemberScope())) {
             if (memberDescriptor instanceof CallableMemberDescriptor) {
                 CallableMemberDescriptor member = (CallableMemberDescriptor) memberDescriptor;
-                if (!member.getKind().isReal() && findInterfaceImplementation(member) == null) {
+                if (!member.getKind().isReal() && ImplKt.findInterfaceImplementation(member) == null) {
                     if (member instanceof FunctionDescriptor) {
                         functionCodegen.generateBridges((FunctionDescriptor) member);
                     }
@@ -238,7 +238,10 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
     ) {
         // Skip Java 8 default methods
         if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) ||
-            JvmAnnotationUtilKt.checkIsImplementationCompiledToJvmDefault(interfaceFun, state.getJvmDefaultMode())) {
+            JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(
+                    DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(interfaceFun), state.getJvmDefaultMode()
+            )
+        ) {
             return;
         }
 

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

@@ -153,18 +153,18 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             signature.genericsSignature,
             FunctionCodegen.getThrownExceptions(functionDescriptor, typeMapper)
         )
-        val skipNullabilityAnnotations = flags and Opcodes.ACC_PRIVATE != 0 || flags and Opcodes.ACC_SYNTHETIC != 0
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
-            .genAnnotations(functionDescriptor, signature.returnType, functionDescriptor.returnType)
+        AnnotationCodegen.forMethod(mv, memberCodegen, state).genAnnotations(
+            functionDescriptor,
+            signature.returnType,
+            functionDescriptor.returnType
+        )
 
         if (state.classBuilderMode == ClassBuilderMode.KAPT3) {
             mv.visitAnnotation(ANNOTATION_TYPE_DESCRIPTOR_FOR_JVM_OVERLOADS_GENERATED_METHODS, false)
         }
 
-        FunctionCodegen.generateParameterAnnotations(
-            functionDescriptor, mv, signature, remainingParameters, memberCodegen, state, skipNullabilityAnnotations
-        )
+        FunctionCodegen.generateParameterAnnotations(functionDescriptor, mv, signature, remainingParameters, memberCodegen, state)
 
         if (!state.classBuilderMode.generateBodies) {
             FunctionCodegen.generateLocalVariablesForParameters(

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

@@ -2835,7 +2835,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             TypeApproximator approximator = new TypeApproximator(state.getModule().getBuiltIns());
 
             KotlinType approximatedType =
-                    TypeUtils.contains(type, (containedType) -> CapturedTypeConstructorKt.isCaptured(containedType)) ?
+                    CapturedTypeConstructorKt.isCaptured(type) ?
                     (KotlinType) approximator.approximateToSuperType(
                             type, TypeApproximatorConfiguration.InternalTypesApproximation.INSTANCE
                     ) : null;

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

@@ -33,7 +33,10 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.SpecialBuiltinMembers;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
+import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.calls.util.UnderscoreUtilKt;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
@@ -83,8 +86,6 @@ import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class FunctionCodegen {
-    private static final String JAVA_LANG_DEPRECATED = Type.getType(Deprecated.class).getDescriptor();
-
     public final GenerationState state;
     private final KotlinTypeMapper typeMapper;
     private final BindingContext bindingContext;
@@ -192,10 +193,6 @@ public class FunctionCodegen {
         if (origin.getOriginKind() == JvmDeclarationOriginKind.SAM_DELEGATION) {
             flags |= ACC_SYNTHETIC;
         }
-        boolean isCompatibilityStubInDefaultImpls = isCompatibilityStubInDefaultImpls(functionDescriptor, methodContext, state.getJvmDefaultMode());
-        if (isCompatibilityStubInDefaultImpls) {
-            flags |= ACC_DEPRECATED;
-        }
 
         if (functionDescriptor.isExternal() && owner instanceof MultifileClassFacadeContext) {
             // Native methods are only defined in facades and do not need package part implementations
@@ -204,13 +201,12 @@ public class FunctionCodegen {
 
         MethodVisitor mv =
                 strategy.wrapMethodVisitor(
-                        newMethod(
-                                origin,
-                                flags,
-                                asmMethod.getName(),
-                                asmMethod.getDescriptor(),
-                                strategy.skipGenericSignature() ? null : jvmSignature.getGenericsSignature(),
-                                getThrownExceptions(functionDescriptor, typeMapper)
+                        newMethod(origin,
+                                  flags,
+                                  asmMethod.getName(),
+                                  asmMethod.getDescriptor(),
+                                  strategy.skipGenericSignature() ? null : jvmSignature.getGenericsSignature(),
+                                  getThrownExceptions(functionDescriptor, typeMapper)
                         ),
                         flags, asmMethod.getName(),
                         asmMethod.getDescriptor()
@@ -218,14 +214,8 @@ public class FunctionCodegen {
 
         recordMethodForFunctionIfAppropriate(functionDescriptor, asmMethod);
 
-        boolean skipNullabilityAnnotations =
-                (flags & ACC_PRIVATE) != 0 || (flags & ACC_SYNTHETIC) != 0 ||
-                InlineClassDescriptorResolver.isSpecializedEqualsMethod(functionDescriptor);
-        generateMethodAnnotationsIfRequired(
-                functionDescriptor, asmMethod, jvmSignature, mv,
-                isCompatibilityStubInDefaultImpls ? Collections.singletonList(JAVA_LANG_DEPRECATED) : Collections.emptyList(),
-                skipNullabilityAnnotations
-        );
+        generateMethodAnnotationsIfRequired(functionDescriptor, asmMethod, jvmSignature, mv);
+
         GenerateJava8ParameterNamesKt.generateParameterNames(functionDescriptor, mv, jvmSignature, state, (flags & ACC_SYNTHETIC) != 0);
 
         if (contextKind != OwnerKind.ERASED_INLINE_CLASS) {
@@ -286,9 +276,7 @@ public class FunctionCodegen {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull Method asmMethod,
             @NotNull JvmMethodGenericSignature jvmSignature,
-            @NotNull MethodVisitor mv,
-            @NotNull List<String> additionalVisibleAnnotations,
-            boolean skipNullabilityAnnotations
+            @NotNull MethodVisitor mv
     ) {
         FunctionDescriptor annotationsOwner;
         if (shouldHideConstructorDueToInlineClassTypeValueParameters(functionDescriptor)) {
@@ -303,14 +291,10 @@ public class FunctionCodegen {
             annotationsOwner = functionDescriptor;
         }
 
-        AnnotationCodegen.forMethod(mv, memberCodegen, state, skipNullabilityAnnotations)
-                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType(), null, additionalVisibleAnnotations);
+        AnnotationCodegen.forMethod(mv, memberCodegen, state)
+                .genAnnotations(annotationsOwner, asmMethod.getReturnType(), functionDescriptor.getReturnType());
 
-        generateParameterAnnotations(
-                annotationsOwner, mv, jvmSignature,
-                annotationsOwner.getValueParameters(),
-                memberCodegen, state, skipNullabilityAnnotations
-        );
+        generateParameterAnnotations(annotationsOwner, mv, jvmSignature, memberCodegen, state);
     }
 
     @NotNull
@@ -504,14 +488,25 @@ public class FunctionCodegen {
         return descriptor != null && !InlineUtil.isInlineOrContainingInline(descriptor);
     }
 
+    public static void generateParameterAnnotations(
+            @NotNull FunctionDescriptor functionDescriptor,
+            @NotNull MethodVisitor mv,
+            @NotNull JvmMethodSignature jvmSignature,
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state
+    ) {
+        generateParameterAnnotations(
+                functionDescriptor, mv, jvmSignature, functionDescriptor.getValueParameters(), innerClassConsumer, state
+        );
+    }
+
     public static void generateParameterAnnotations(
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull MethodVisitor mv,
             @NotNull JvmMethodSignature jvmSignature,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull MemberCodegen<?> memberCodegen,
-            @NotNull GenerationState state,
-            boolean skipNullabilityAnnotations
+            @NotNull InnerClassConsumer innerClassConsumer,
+            @NotNull GenerationState state
     ) {
         if (isAccessor(functionDescriptor)) return;
 
@@ -521,7 +516,6 @@ public class FunctionCodegen {
 
         Asm7UtilKt.visitAnnotableParameterCount(mv, kotlinParameterTypes.size() - syntheticParameterCount);
 
-        boolean isDefaultImpl = OwnerKind.DEFAULT_IMPLS == memberCodegen.context.getContextKind();
         for (int i = 0; i < kotlinParameterTypes.size(); i++) {
             JvmMethodParameterSignature parameterSignature = kotlinParameterTypes.get(i);
             JvmMethodParameterKind kind = parameterSignature.getKind();
@@ -534,18 +528,13 @@ public class FunctionCodegen {
                     ? iterator.next()
                     : kind == JvmMethodParameterKind.RECEIVER
                       ? JvmCodegenUtil.getDirectMember(functionDescriptor).getExtensionReceiverParameter()
-                      : kind == JvmMethodParameterKind.THIS && isDefaultImpl
-                        ? JvmCodegenUtil.getDirectMember(functionDescriptor).getDispatchReceiverParameter()
-                        : null;
+                      : null;
 
             if (annotated != null) {
+                //noinspection ConstantConditions
                 int parameterIndex = i - syntheticParameterCount;
-                AnnotationCodegen
-                        .forParameter(parameterIndex, mv, memberCodegen, state, skipNullabilityAnnotations)
-                        .genAnnotations(
-                                annotated, parameterSignature.getAsmType(), annotated.getReturnType(), functionDescriptor,
-                                Collections.emptyList()
-                        );
+                AnnotationCodegen.forParameter(parameterIndex, mv, innerClassConsumer, state)
+                        .genAnnotations(annotated, parameterSignature.getAsmType(), annotated.getReturnType());
             }
         }
     }
@@ -617,7 +606,7 @@ public class FunctionCodegen {
                     true, mv,
                     method.getAsmMethod(),
                     method.getOwner().getInternalName(),
-                    true, signature.getReturnType());
+                    true);
             methodEnd = new Label();
         }
         else {
@@ -721,8 +710,10 @@ public class FunctionCodegen {
             @NotNull JvmDefaultMode jvmDefaultMode
     ) {
         return OwnerKind.DEFAULT_IMPLS == context.getContextKind() &&
-            jvmDefaultMode.isCompatibility() &&
-            JvmAnnotationUtilKt.checkIsImplementationCompiledToJvmDefault(functionDescriptor, jvmDefaultMode);
+               JvmAnnotationUtilKt
+                       .isCompiledToJvmDefault(DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(functionDescriptor),
+                                               jvmDefaultMode) &&
+               jvmDefaultMode.isCompatibility();
     }
 
     private static void generateLocalVariableTable(
@@ -858,8 +849,7 @@ public class FunctionCodegen {
             @NotNull Method asmMethod,
             @NotNull String classToDelegateTo,
             int opcode,
-            boolean isInterface,
-            @NotNull Type returnType
+            boolean isInterface
     ) {
         InstructionAdapter iv = new InstructionAdapter(mv);
         Type[] argTypes = asmMethod.getArgumentTypes();
@@ -881,8 +871,7 @@ public class FunctionCodegen {
             paramIndex += argType.getSize();
         }
         iv.visitMethodInsn(opcode, classToDelegateTo, asmMethod.getName(), asmMethod.getDescriptor(), isInterface);
-        StackValue.onStack(asmMethod.getReturnType()).coerceTo(returnType, null, iv);
-        iv.areturn(returnType);
+        iv.areturn(asmMethod.getReturnType());
     }
 
     private static void generateDelegateToStaticErasedVersion(
@@ -921,19 +910,7 @@ public class FunctionCodegen {
             @NotNull String classToDelegateTo,
             boolean isInterfaceMethodCall
     ) {
-        generateDelegateToStaticMethodBody(isStatic, mv, asmMethod, classToDelegateTo, isInterfaceMethodCall, asmMethod.getReturnType());
-    }
-
-
-    private static void generateDelegateToStaticMethodBody(
-            boolean isStatic,
-            @NotNull MethodVisitor mv,
-            @NotNull Method asmMethod,
-            @NotNull String classToDelegateTo,
-            boolean isInterfaceMethodCall,
-            @NotNull Type returnType
-    ) {
-        generateDelegateToMethodBody(isStatic ? 0 : 1, mv, asmMethod, classToDelegateTo, Opcodes.INVOKESTATIC, isInterfaceMethodCall, returnType);
+        generateDelegateToMethodBody(isStatic ? 0 : 1, mv, asmMethod, classToDelegateTo, Opcodes.INVOKESTATIC, isInterfaceMethodCall);
     }
 
     private static boolean needIndexForVar(JvmMethodParameterKind kind) {
@@ -1679,9 +1656,7 @@ public class FunctionCodegen {
 
         if (JvmAnnotationUtilKt.isCompiledToJvmDefault(memberDescriptor, mode)) {
             return (kind != OwnerKind.DEFAULT_IMPLS && !isSynthetic) ||
-                   (kind == OwnerKind.DEFAULT_IMPLS &&
-                    (isSynthetic || //TODO: move synthetic method generation into interface
-                     (mode.isCompatibility() && !JvmAnnotationUtilKt.hasJvmDefaultNoCompatibilityAnnotation(containingDeclaration))));
+                   (kind == OwnerKind.DEFAULT_IMPLS && (isSynthetic || mode.isCompatibility()));
         } else {
             switch (kind) {
                 case DEFAULT_IMPLS: return true;

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

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.KtClassOrObject;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
@@ -45,7 +46,6 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
     private final GenerationState generationState;
     private final KotlinTypeMapper typeMapper;
     private final JvmKotlinType underlyingType;
-    private final boolean isInErasedInlineClass;
 
     public FunctionsFromAnyGeneratorImpl(
             @NotNull KtClassOrObject declaration,
@@ -67,27 +67,23 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
                 typeMapper.mapType(descriptor),
                 InlineClassesUtilsKt.substitutedUnderlyingType(descriptor.getDefaultType())
         );
-        this.isInErasedInlineClass = fieldOwnerContext.getContextKind() == OwnerKind.ERASED_INLINE_CLASS;
     }
 
     @Override
     protected void generateToStringMethod(
-            @NotNull FunctionDescriptor function,
-            @NotNull List<? extends PropertyDescriptor> properties
+            @NotNull FunctionDescriptor function, @NotNull List<? extends PropertyDescriptor> properties
     ) {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String toStringMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, getToStringDesc(), null, null);
 
-        if (!isInErasedInlineClass && classDescriptor.isInline()) {
+        if (fieldOwnerContext.getContextKind() != OwnerKind.ERASED_INLINE_CLASS && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
 
-        if (!isInErasedInlineClass) {
-            visitEndForAnnotationVisitor(mv.visitAnnotation(Type.getDescriptor(NotNull.class), false));
-        }
+        visitEndForAnnotationVisitor(mv.visitAnnotation(Type.getDescriptor(NotNull.class), false));
 
         if (!generationState.getClassBuilderMode().generateBodies) {
             FunctionCodegen.endVisit(mv, toStringMethodName, getDeclaration());
@@ -148,7 +144,7 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         String hashCodeMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, getHashCodeDesc(), null, null);
 
-        if (!isInErasedInlineClass && classDescriptor.isInline()) {
+        if (fieldOwnerContext.getContextKind() != OwnerKind.ERASED_INLINE_CLASS && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
@@ -217,14 +213,15 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         String equalsMethodName = mapFunctionName(function);
         MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, getEqualsDesc(), null, null);
 
-        if (!isInErasedInlineClass && classDescriptor.isInline()) {
+        boolean isErasedInlineClassKind = fieldOwnerContext.getContextKind() == OwnerKind.ERASED_INLINE_CLASS;
+        if (!isErasedInlineClassKind && classDescriptor.isInline()) {
             FunctionCodegen.generateMethodInsideInlineClassWrapper(methodOrigin, function, classDescriptor, mv, typeMapper);
             return;
         }
 
-        if (!isInErasedInlineClass) {
-            visitEndForAnnotationVisitor(mv.visitParameterAnnotation(0, Type.getDescriptor(Nullable.class), false));
-        }
+        visitEndForAnnotationVisitor(
+                mv.visitParameterAnnotation(isErasedInlineClassKind ? 1 : 0, Type.getDescriptor(Nullable.class), false)
+        );
 
         if (!generationState.getClassBuilderMode().generateBodies) {
             FunctionCodegen.endVisit(mv, equalsMethodName, getDeclaration());

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

@@ -771,12 +771,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         if (isNonCompanionObject(descriptor)) {
             StackValue.Field field = StackValue.createSingletonViaInstance(descriptor, typeMapper, INSTANCE_FIELD);
-            FieldVisitor fv = v.newField(
-                    JvmDeclarationOriginKt.OtherOriginFromPure(myClass),
-                    ACC_PUBLIC | ACC_STATIC | ACC_FINAL,
-                    field.name, field.type.getDescriptor(), null, null
-            );
-            AnnotationCodegen.forField(fv, this, state).visitAnnotation(Type.getDescriptor(NotNull.class), false).visitEnd();
+            v.newField(JvmDeclarationOriginKt.OtherOriginFromPure(myClass),
+                       ACC_PUBLIC | ACC_STATIC | ACC_FINAL,
+                       field.name, field.type.getDescriptor(), null, null);
+
             return;
         }
 
@@ -818,13 +816,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             fieldAccessFlags |= ACC_SYNTHETIC;
         }
         StackValue.Field field = StackValue.singleton(companionObjectDescriptor, typeMapper);
-        FieldVisitor fv = v.newField(
-                JvmDeclarationOriginKt.OtherOrigin(companionObject == null ? myClass.getPsiOrParent() : companionObject),
-                fieldAccessFlags, field.name, field.type.getDescriptor(), null, null
-        );
-        AnnotationCodegen.forField(fv, this, state).visitAnnotation(Type.getDescriptor(NotNull.class), false).visitEnd();
+        FieldVisitor fv = v.newField(JvmDeclarationOriginKt.OtherOrigin(companionObject == null ? myClass.getPsiOrParent() : companionObject),
+                                     fieldAccessFlags, field.name, field.type.getDescriptor(), null, null);
         if (fieldShouldBeDeprecated) {
-            AnnotationCodegen.forField(fv, this, state).visitAnnotation(Type.getDescriptor(Deprecated.class), true).visitEnd();
+            AnnotationCodegen.forField(fv, this, state).visitAnnotation("Ljava/lang/Deprecated;", true).visitEnd();
         }
     }
 

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

@@ -17,7 +17,8 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.util.ArrayUtil
-import org.jetbrains.kotlin.util.findImplementationFromInterface
+import org.jetbrains.kotlin.backend.common.bridges.findImplementationFromInterface
+import org.jetbrains.kotlin.backend.common.bridges.firstSuperMethodFromKotlin
 import org.jetbrains.kotlin.codegen.context.ClassContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.JvmMethodExceptionTypes
@@ -28,7 +29,6 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.util.firstSuperMethodFromKotlin
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 

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

@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyD
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.jvm.annotations.isCompiledToJvmDefault
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasPlatformDependentAnnotation
-import org.jetbrains.kotlin.util.findImplementationFromInterface
-import org.jetbrains.kotlin.util.findInterfaceImplementation
 
 class DescriptorBasedFunctionHandleForJvm(
     descriptor: FunctionDescriptor,

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

@@ -24,8 +24,6 @@ import org.jetbrains.kotlin.resolve.calls.checkers.isRestrictsSuspensionReceiver
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
-
 
 class JvmRuntimeTypes(
     module: ModuleDescriptor,
@@ -98,14 +96,6 @@ class JvmRuntimeTypes(
             else
                 descriptor
 
-        if (actualFunctionDescriptor.returnType == null)
-            throw KotlinExceptionWithAttachments(
-                "Return type for function description is null. Super type cannot be calculated." +
-                        "initDesc=${descriptor}, actDesc=${actualFunctionDescriptor}, isReleaseCoroutines=${
-                            languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)
-                        }"
-            )
-
         val functionType = createFunctionType(
             descriptor.builtIns,
             Annotations.EMPTY,

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

@@ -726,7 +726,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
     public SourceMapper getOrCreateSourceMapper() {
         if (sourceMapper == null) {
             // note: this is used in InlineCodegen and the element is always physical (KtElement) there
-            sourceMapper = new SourceMapper(SourceInfo.Companion.createFromPsi((KtElement)element, getClassName()));
+            sourceMapper = new SourceMapper(SourceInfo.Companion.createInfo((KtElement)element, getClassName()));
         }
         return sourceMapper;
     }

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

@@ -210,6 +210,7 @@ public class PropertyCodegen {
         if (kind == OwnerKind.DEFAULT_IMPLS && isDefaultAccessor) return false;
 
         // Delegated or extension properties can only be referenced via accessors
+        //noinspection deprecation
         if (descriptor.isDelegated() || descriptor.getExtensionReceiverParameter() != null) return true;
 
         // Companion object properties should have accessors for non-private properties because these properties can be referenced
@@ -336,8 +337,11 @@ public class PropertyCodegen {
             return;
         }
 
+        @SuppressWarnings("deprecation")
+        boolean isDelegate = descriptor.isDelegated();
+
         Object defaultValue;
-        if (descriptor.isDelegated()) {
+        if (isDelegate) {
             defaultValue = null;
         }
         else if (Boolean.TRUE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor))) {
@@ -353,7 +357,7 @@ public class PropertyCodegen {
             return;
         }
 
-        generateBackingField(descriptor, descriptor.isDelegated(), defaultValue, isBackingFieldOwner);
+        generateBackingField(descriptor, isDelegate, defaultValue, isBackingFieldOwner);
     }
 
     // Annotations on properties are stored in bytecode on an empty synthetic method. This way they're still
@@ -434,13 +438,7 @@ public class PropertyCodegen {
             );
 
             if (annotatedField != null) {
-                // Don't emit nullability annotations for backing field if:
-                // - backing field is synthetic;
-                // - property is lateinit (since corresponding field is actually nullable).
-                boolean skipNullabilityAnnotations =
-                        (modifiers & ACC_SYNTHETIC) != 0 ||
-                        propertyDescriptor.isLateInit();
-                AnnotationCodegen.forField(fv, memberCodegen, state, skipNullabilityAnnotations)
+                AnnotationCodegen.forField(fv, memberCodegen, state)
                         .genAnnotations(annotatedField, type, propertyDescriptor.getType());
             }
         }
@@ -518,7 +516,9 @@ public class PropertyCodegen {
 
         FunctionGenerationStrategy strategy;
         if (accessor == null || !accessor.hasBody()) {
-            if (descriptor.getCorrespondingProperty().isDelegated()) {
+            @SuppressWarnings("deprecation")
+            boolean isDelegated = descriptor.getCorrespondingProperty().isDelegated();
+            if (isDelegated) {
                 strategy = new DelegatedPropertyAccessorStrategy(state, descriptor);
             }
             else {

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

@@ -21,26 +21,28 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 
-data class SourceInfo(
-    val sourceFileName: String?,
-    val pathOrCleanFQN: String,
-    val linesInFile: Int
-) {
+data class SourceInfo(val source: String, val pathOrCleanFQN: String, val linesInFile: Int) {
 
     companion object {
-        fun createFromPsi(element: KtElement?, internalClassName: String): SourceInfo {
+        fun createInfo(element: KtElement?, internalClassName: String): SourceInfo {
             assert(element != null) { "Couldn't create source mapper for null element $internalClassName" }
             val lineNumbers = CodegenUtil.getLineNumberForElement(element!!.containingFile, true)
-                ?: error("Couldn't extract line count in ${element.containingFile}")
+                    ?: error("Couldn't extract line count in ${element.containingFile}")
 
             //TODO hack condition for package parts cleaning
             val isTopLevel = element is KtFile || (element is KtNamedFunction && element.getParent() is KtFile)
             val cleanedClassFqName = if (!isTopLevel) internalClassName else internalClassName.substringBefore('$')
 
-            val fileName = element.containingKtFile.name
-            return SourceInfo(fileName, cleanedClassFqName, lineNumbers)
+            return SourceInfo(element.containingKtFile.name, cleanedClassFqName, lineNumbers)
         }
 
+        fun createInfoForIr(lineNumbers: Int, internalClassName: String, containingFileName: String): SourceInfo {
+            //TODO cut topLevel names
+//            val isTopLevel = element is KtFile || (element is KtNamedFunction && element.getParent() is KtFile)
+//            val cleanedClassFqName = if (!isTopLevel) internalClassName else internalClassName.substringBefore('$')
+
+            return SourceInfo(containingFileName, internalClassName, lineNumbers)
+        }
     }
 }
 

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

@@ -590,7 +590,7 @@ private fun generateLambdaForRunSuspend(
 
     lambdaBuilder.newField(
         JvmDeclarationOrigin.NO_ORIGIN,
-        ACC_PRIVATE or ACC_FINAL or ACC_SYNTHETIC,
+        ACC_PRIVATE or ACC_FINAL,
         "args",
         ARRAY_OF_STRINGS_TYPE.descriptor, null, null
     )

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
@@ -236,7 +235,7 @@ class CoroutineCodegenForLambda private constructor(
             val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
             v.newField(
                 OtherOrigin(parameter),
-                Opcodes.ACC_PRIVATE + Opcodes.ACC_SYNTHETIC,
+                Opcodes.ACC_PRIVATE,
                 fieldInfo.fieldName,
                 fieldInfo.fieldType.descriptor, null, null
             )
@@ -513,8 +512,7 @@ class CoroutineCodegenForLambda private constructor(
                         containingClassInternalName = v.thisName,
                         isForNamedFunction = false,
                         languageVersionSettings = languageVersionSettings,
-                        disableTailCallOptimizationForFunctionReturningUnit = false,
-                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                        disableTailCallOptimizationForFunctionReturningUnit = false
                     )
                     val maybeWithForInline = if (forInline)
                         SuspendForInlineCopyingMethodVisitor(stateMachineBuilder, access, name, desc, functionCodegen::newMethod)

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

@@ -5,10 +5,14 @@
 
 package org.jetbrains.kotlin.codegen.coroutines
 
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.AsmUtil
+import org.jetbrains.kotlin.codegen.ClassBuilder
+import org.jetbrains.kotlin.codegen.StackValue
+import org.jetbrains.kotlin.codegen.TransformationMethodVisitor
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.*
 import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransformer
+import org.jetbrains.kotlin.codegen.linkWithLabel
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
@@ -20,7 +24,6 @@ import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import kotlin.math.max
 
 private const val COROUTINES_DEBUG_METADATA_VERSION = 1
@@ -62,9 +65,7 @@ class CoroutineTransformerMethodVisitor(
     // May differ from containingClassInternalName in case of DefaultImpls
     private val internalNameForDispatchReceiver: String? = null,
     // JVM_IR backend generates $completion, while old backend does not
-    private val putContinuationParameterToLvt: Boolean = true,
-    // New SourceInterpreter-less analyser can be somewhat unstable, disable it
-    private val useOldSpilledVarTypeAnalysis: Boolean = false
+    private val putContinuationParameterToLvt: Boolean = true
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
 
     private val classBuilderForCoroutineState: ClassBuilder by lazy(obtainClassBuilderForCoroutineState)
@@ -133,19 +134,15 @@ class CoroutineTransformerMethodVisitor(
 
         UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
 
-        updateLvtAccordingToLiveness(methodNode, isForNamedFunction)
-
         val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)
 
         val suspendMarkerVarIndex = methodNode.maxLocals++
 
         val suspensionPointLineNumbers = suspensionPoints.map { findSuspensionPointLineNumber(it) }
 
-        // Create states in state-machine, to which state-machine can jump
-        val stateLabels = suspensionPoints.withIndex().map {
-            transformCallAndReturnStateLabel(
-                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index]
-            )
+        val continuationLabels = suspensionPoints.withIndex().map {
+            transformCallAndReturnContinuationLabel(
+                it.index + 1, it.value, methodNode, suspendMarkerVarIndex, suspensionPointLineNumbers[it.index])
         }
 
         methodNode.instructions.apply {
@@ -168,7 +165,7 @@ class CoroutineTransformerMethodVisitor(
                         0,
                         suspensionPoints.size,
                         defaultLabel,
-                        firstStateLabel, *stateLabels.toTypedArray()
+                        firstStateLabel, *continuationLabels.toTypedArray()
                     ),
                     firstStateLabel
                 )
@@ -185,39 +182,25 @@ class CoroutineTransformerMethodVisitor(
             })
         }
 
-        initializeFakeInlinerVariables(methodNode, stateLabels)
-
         dropSuspensionMarkers(methodNode)
         methodNode.removeEmptyCatchBlocks()
 
+        // The parameters (and 'this') shall live throughout the method, otherwise, d8 emits warning about invalid debug info
+        val startLabel = LabelNode()
+        val endLabel = LabelNode()
+        methodNode.instructions.insertBefore(methodNode.instructions.first, startLabel)
+        methodNode.instructions.insert(methodNode.instructions.last, endLabel)
+
+        fixLvtForParameters(methodNode, startLabel, endLabel)
+
         if (languageVersionSettings.isReleaseCoroutines()) {
             writeDebugMetadata(methodNode, suspensionPointLineNumbers, spilledToVariableMapping)
         }
     }
 
-    // When suspension point is inlined, it is in range of fake inliner variables.
-    // Path from TABLESWITCH into unspilling goes to latter part of the range.
-    // In this case the variables are uninitialized, initialize them
-    private fun initializeFakeInlinerVariables(methodNode: MethodNode, stateLabels: List<LabelNode>) {
-        for (stateLabel in stateLabels) {
-            val unitializedFakeInlinerVariables = arrayListOf<LocalVariableNode>()
-            for (record in methodNode.localVariables) {
-                if (isFakeLocalVariableForInline(record.name) &&
-                    methodNode.instructions.indexOf(record.start) < methodNode.instructions.indexOf(stateLabel) &&
-                    methodNode.instructions.indexOf(stateLabel) < methodNode.instructions.indexOf(record.end)
-                ) {
-                    methodNode.instructions.insert(stateLabel, withInstructionAdapter {
-                        iconst(0)
-                        store(record.index, Type.INT_TYPE)
-                    })
-                }
-            }
-        }
-    }
-
     private fun addCompletionParameterToLVT(methodNode: MethodNode) {
         val index =
-            /*  all args */ Type.getMethodType(methodNode.desc).argumentTypes.fold(0) { a, b -> a + b.size } +
+                /*  all args */ Type.getMethodType(methodNode.desc).argumentTypes.fold(0) { a, b -> a + b.size } +
                 /* this */ (if (isStatic(methodNode.access)) 0 else 1) -
                 /* only last */ 1
         val startLabel = with(methodNode.instructions) {
@@ -330,10 +313,31 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
+    private fun fixLvtForParameters(methodNode: MethodNode, startLabel: LabelNode, endLabel: LabelNode) {
+        val paramsNum =
+                /* this */ (if (isStatic(methodNode.access)) 0 else 1) +
+                /* real params */ Type.getArgumentTypes(methodNode.desc).fold(0) { a, b -> a + b.size }
+
+        for (i in 0 until paramsNum) {
+            fixRangeOfLvtRecord(methodNode, i, startLabel, endLabel)
+        }
+    }
+
+    private fun fixRangeOfLvtRecord(methodNode: MethodNode, index: Int, startLabel: LabelNode, endLabel: LabelNode) {
+        val vars = methodNode.localVariables.filter { it.index == index }
+        assert(vars.size <= 1) {
+            "Someone else occupies parameter's slot at $index"
+        }
+        vars.firstOrNull()?.let {
+            it.start = startLabel
+            it.end = endLabel
+        }
+    }
+
     private fun writeDebugMetadata(
         methodNode: MethodNode,
         suspensionPointLineNumbers: List<LineNumberNode?>,
-        spilledToLocalMapping: List<List<SpilledVariableAndField>>
+        spilledToLocalMapping: List<List<SpilledVariableDescriptor>>
     ) {
         val lines = suspensionPointLineNumbers.map { it?.line ?: -1 }
         val metadata = classBuilderForCoroutineState.newAnnotation(DEBUG_METADATA_ANNOTATION_ASM_TYPE.descriptor, true)
@@ -588,23 +592,16 @@ class CoroutineTransformerMethodVisitor(
         }
     }
 
-    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableAndField>> {
+    private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableDescriptor>> {
         val instructions = methodNode.instructions
-        val frames =
-            if (useOldSpilledVarTypeAnalysis) performRefinedTypeAnalysis(methodNode, containingClassInternalName)
-            else performSpilledVariableFieldTypesAnalysis(methodNode, containingClassInternalName)
-
+        val frames = performRefinedTypeAnalysis(methodNode, containingClassInternalName)
         fun AbstractInsnNode.index() = instructions.indexOf(this)
 
+        // We postpone these actions because they change instruction indices that we use when obtaining frames
+        val postponedActions = mutableListOf<() -> Unit>()
         val maxVarsCountByType = mutableMapOf<Type, Int>()
         val livenessFrames = analyzeLiveness(methodNode)
-
-        // References shall be cleaned up after uspill (during spill in next suspension point) to prevent memory leaks,
-        val referencesToSpillBySuspensionPointIndex = arrayListOf<List<ReferenceToSpill>>()
-        // while primitives shall not
-        val primitivesToSpillBySuspensionPointIndex = arrayListOf<List<PrimitiveToSpill>>()
-
-        // Collect information about spillable variables, that we use to determine which variables we need to cleanup
+        val spilledToVariableMapping = arrayListOf<List<SpilledVariableDescriptor>>()
 
         for (suspension in suspensionPoints) {
             val suspensionCallBegin = suspension.suspensionCallBegin
@@ -631,8 +628,7 @@ class CoroutineTransformerMethodVisitor(
             // NB: it's also rather useful for sake of optimization
             val livenessFrame = livenessFrames[suspensionCallBegin.index()]
 
-            val referencesToSpill = arrayListOf<ReferenceToSpill>()
-            val primitivesToSpill = arrayListOf<PrimitiveToSpill>()
+            val spilledToVariable = arrayListOf<SpilledVariableDescriptor>()
 
             // 0 - this
             // 1 - parameter
@@ -640,144 +636,69 @@ class CoroutineTransformerMethodVisitor(
             // k - continuation
             // k + 1 - data
             // k + 2 - exception
-            for (slot in 0 until localsCount) {
-                if (slot == continuationIndex || slot == dataIndex || slot == exceptionIndex) continue
-                val value = frame.getLocal(slot)
-                if (value.type == null || !livenessFrame.isAlive(slot)) continue
+            val variablesToSpill =
+                (0 until localsCount)
+                    .filterNot { it in setOf(continuationIndex, dataIndex, exceptionIndex) }
+                    .map { Pair(it, frame.getLocal(it)) }
+                    .filter { (index, value) ->
+                        (index == 0 && needDispatchReceiver && isForNamedFunction) ||
+                                (value != StrictBasicValue.UNINITIALIZED_VALUE && livenessFrame.isAlive(index))
+                    }
 
-                if (value == StrictBasicValue.NULL_VALUE) {
-                    referencesToSpill += slot to null
+            for ((index, basicValue) in variablesToSpill) {
+                if (basicValue === StrictBasicValue.NULL_VALUE) {
+                    postponedActions.add {
+                        with(instructions) {
+                            insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                                aconst(null)
+                                store(index, AsmTypes.OBJECT_TYPE)
+                            })
+                        }
+                    }
                     continue
                 }
 
-                val type = value.type!!
+                val type = basicValue.type
                 val normalizedType = type.normalize()
 
                 val indexBySort = varsCountByType[normalizedType]?.plus(1) ?: 0
                 varsCountByType[normalizedType] = indexBySort
 
                 val fieldName = normalizedType.fieldNameForVar(indexBySort)
-                if (normalizedType == AsmTypes.OBJECT_TYPE) {
-                    referencesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
-                } else {
-                    primitivesToSpill += slot to SpillableVariable(value, type, normalizedType, fieldName)
+                localVariableName(methodNode, index, suspension.suspensionCallEnd.next.index())
+                    ?.let { spilledToVariable.add(SpilledVariableDescriptor(fieldName, it)) }
+
+                postponedActions.add {
+                    with(instructions) {
+                        // store variable before suspension call
+                        insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
+                            load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                            load(index, type)
+                            StackValue.coerce(type, normalizedType, this)
+                            putfield(classBuilderForCoroutineState.thisName, fieldName, normalizedType.descriptor)
+                        })
+
+                        // restore variable after suspension call
+                        insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
+                            load(continuationIndex, AsmTypes.OBJECT_TYPE)
+                            getfield(classBuilderForCoroutineState.thisName, fieldName, normalizedType.descriptor)
+                            StackValue.coerce(normalizedType, type, this)
+                            store(index, type)
+                        })
+                    }
                 }
             }
 
-            referencesToSpillBySuspensionPointIndex += referencesToSpill
-            primitivesToSpillBySuspensionPointIndex += primitivesToSpill
+            spilledToVariableMapping.add(spilledToVariable)
 
-            for ((type, index) in varsCountByType) {
-                maxVarsCountByType[type] = max(maxVarsCountByType[type] ?: 0, index)
+            varsCountByType.forEach {
+                maxVarsCountByType[it.key] = max(maxVarsCountByType[it.key] ?: 0, it.value)
             }
         }
 
-        // Calculate variables to cleanup
+        postponedActions.forEach(Function0<Unit>::invoke)
 
-        // Use CFG to calculate amount of spilled variables in previous suspension point (P) and current one (C).
-        // All fields from L$C to L$P should be cleaned. I.e. we should spill ACONST_NULL to them.
-        val cfg = ControlFlowGraph.build(methodNode)
-
-        // Collect all immediately preceding suspension points. I.e. suspension points, from which there is a path
-        // into current one, that does not cross other suspension points.
-        val suspensionPointEnds = suspensionPoints.associateBy { it.suspensionCallEnd }
-        fun findSuspensionPointPredecessors(suspension: SuspensionPoint): List<SuspensionPoint> {
-            val visited = mutableSetOf<AbstractInsnNode>()
-            fun dfs(current: AbstractInsnNode): List<SuspensionPoint> {
-                if (!visited.add(current)) return emptyList()
-                suspensionPointEnds[current]?.let { return listOf(it) }
-                return cfg.getPredecessorsIndices(current).flatMap { dfs(instructions[it]) }
-            }
-            return dfs(suspension.suspensionCallBegin)
-        }
-
-        val predSuspensionPoints = suspensionPoints.associateWith { findSuspensionPointPredecessors(it) }
-
-        // Calculate all pairs SuspensionPoint -> C and P, where P is minimum of all preds' Cs
-        fun countVariablesToSpill(index: Int): Int =
-            referencesToSpillBySuspensionPointIndex[index].count { (_, variable) -> variable != null }
-
-        val referencesToCleanBySuspensionPointIndex = arrayListOf<Pair<Int, Int>>() // current to pred
-        for (suspensionPointIndex in suspensionPoints.indices) {
-            val suspensionPoint = suspensionPoints[suspensionPointIndex]
-            val currentSpilledReferencesCount = countVariablesToSpill(suspensionPointIndex)
-            val preds = predSuspensionPoints[suspensionPoint]
-            val predSpilledReferencesCount =
-                if (preds.isNullOrEmpty()) 0 else preds.maxOf { countVariablesToSpill(suspensionPoints.indexOf(it)) }
-            referencesToCleanBySuspensionPointIndex += currentSpilledReferencesCount to predSpilledReferencesCount
-        }
-
-        // Mutate method node
-
-        fun generateSpillAndUnspill(suspension: SuspensionPoint, slot: Int, spillableVariable: SpillableVariable?) {
-            if (spillableVariable == null) {
-                with(instructions) {
-                    insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                        aconst(null)
-                        store(slot, AsmTypes.OBJECT_TYPE)
-                    })
-                }
-                return
-            }
-
-            with(instructions) {
-                // store variable before suspension call
-                insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
-                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                    load(slot, spillableVariable.type)
-                    StackValue.coerce(spillableVariable.type, spillableVariable.normalizedType, this)
-                    putfield(
-                        classBuilderForCoroutineState.thisName,
-                        spillableVariable.fieldName,
-                        spillableVariable.normalizedType.descriptor
-                    )
-                })
-
-                // restore variable after suspension call
-                insert(suspension.tryCatchBlockEndLabelAfterSuspensionCall, withInstructionAdapter {
-                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                    getfield(
-                        classBuilderForCoroutineState.thisName,
-                        spillableVariable.fieldName,
-                        spillableVariable.normalizedType.descriptor
-                    )
-                    StackValue.coerce(spillableVariable.normalizedType, spillableVariable.type, this)
-                    store(slot, spillableVariable.type)
-                })
-            }
-        }
-
-        fun cleanUpField(suspension: SuspensionPoint, fieldIndex: Int) {
-            with(instructions) {
-                insertBefore(suspension.suspensionCallBegin, withInstructionAdapter {
-                    load(continuationIndex, AsmTypes.OBJECT_TYPE)
-                    aconst(null)
-                    putfield(
-                        classBuilderForCoroutineState.thisName,
-                        "L\$$fieldIndex",
-                        AsmTypes.OBJECT_TYPE.descriptor
-                    )
-                })
-            }
-        }
-
-        for (suspensionPointIndex in suspensionPoints.indices) {
-            val suspension = suspensionPoints[suspensionPointIndex]
-            for ((slot, referenceToSpill) in referencesToSpillBySuspensionPointIndex[suspensionPointIndex]) {
-                generateSpillAndUnspill(suspension, slot, referenceToSpill)
-            }
-            val (currentSpilledCount, predSpilledCount) = referencesToCleanBySuspensionPointIndex[suspensionPointIndex]
-            if (predSpilledCount > currentSpilledCount) {
-                for (fieldIndex in currentSpilledCount until predSpilledCount) {
-                    cleanUpField(suspension, fieldIndex)
-                }
-            }
-            for ((slot, primitiveToSpill) in primitivesToSpillBySuspensionPointIndex[suspensionPointIndex]) {
-                generateSpillAndUnspill(suspension, slot, primitiveToSpill)
-            }
-        }
-
-        for (entry in maxVarsCountByType) {
+        maxVarsCountByType.forEach { entry ->
             val (type, maxIndex) = entry
             for (index in 0..maxIndex) {
                 classBuilderForCoroutineState.newField(
@@ -786,34 +707,6 @@ class CoroutineTransformerMethodVisitor(
                 )
             }
         }
-
-        // Calculate debug metadata mapping
-
-        fun calculateSpilledVariableAndField(
-            suspension: SuspensionPoint,
-            slot: Int,
-            spillableVariable: SpillableVariable?
-        ): SpilledVariableAndField? {
-            if (spillableVariable == null) return null
-            val name = localVariableName(methodNode, slot, suspension.suspensionCallEnd.next.index()) ?: return null
-            return SpilledVariableAndField(spillableVariable.fieldName, name)
-        }
-
-        val spilledToVariableMapping = arrayListOf<List<SpilledVariableAndField>>()
-        for (suspensionPointIndex in suspensionPoints.indices) {
-            val suspension = suspensionPoints[suspensionPointIndex]
-
-            val spilledToVariable = arrayListOf<SpilledVariableAndField>()
-
-            referencesToSpillBySuspensionPointIndex[suspensionPointIndex].mapNotNullTo(spilledToVariable) { (slot, spillableVariable) ->
-                calculateSpilledVariableAndField(suspension, slot, spillableVariable)
-            }
-            primitivesToSpillBySuspensionPointIndex[suspensionPointIndex].mapNotNullTo(spilledToVariable) { (slot, spillableVariable) ->
-                calculateSpilledVariableAndField(suspension, slot, spillableVariable)
-            }
-
-            spilledToVariableMapping += spilledToVariable
-        }
         return spilledToVariableMapping
     }
 
@@ -842,14 +735,14 @@ class CoroutineTransformerMethodVisitor(
             return suspensionCallEnd.next as LabelNode
         }
 
-    private fun transformCallAndReturnStateLabel(
+    private fun transformCallAndReturnContinuationLabel(
         id: Int,
         suspension: SuspensionPoint,
         methodNode: MethodNode,
         suspendMarkerVarIndex: Int,
         suspendPointLineNumber: LineNumberNode?
     ): LabelNode {
-        val stateLabel = LabelNode().linkWithLabel()
+        val continuationLabel = LabelNode().linkWithLabel()
         val continuationLabelAfterLoadedResult = LabelNode()
         val suspendElementLineNumber = lineNumber
         var nextLineNumberNode = nextDefinitelyHitLineNumber(suspension)
@@ -877,7 +770,7 @@ class CoroutineTransformerMethodVisitor(
                 load(suspendMarkerVarIndex, AsmTypes.OBJECT_TYPE)
                 areturn(AsmTypes.OBJECT_TYPE)
                 // Mark place for continuation
-                visitLabel(stateLabel.label)
+                visitLabel(continuationLabel.label)
             })
 
             // After suspension point there is always three nodes: L1, NOP, L2
@@ -928,7 +821,7 @@ class CoroutineTransformerMethodVisitor(
             }
         }
 
-        return stateLabel
+        return continuationLabel
     }
 
     // Find the next line number instruction that is defintely hit. That is, a line number
@@ -994,19 +887,9 @@ class CoroutineTransformerMethodVisitor(
         return
     }
 
-    private data class SpilledVariableAndField(val fieldName: String, val variableName: String)
+    private data class SpilledVariableDescriptor(val fieldName: String, val variableName: String)
 }
 
-private class SpillableVariable(
-    val value: BasicValue,
-    val type: Type,
-    val normalizedType: Type,
-    val fieldName: String
-)
-
-private typealias ReferenceToSpill = Pair<Int, SpillableVariable?>
-private typealias PrimitiveToSpill = Pair<Int, SpillableVariable>
-
 internal fun InstructionAdapter.generateContinuationConstructorCall(
     objectTypeForState: Type?,
     methodNode: MethodNode,
@@ -1143,72 +1026,3 @@ internal fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, contin
         methodNode.instructions.set(fakeContinuation, VarInsnNode(Opcodes.ALOAD, continuationIndex))
     }
 }
-
-/* We do not want to spill dead variables, thus, we shrink its LVT record to region, where the variable is alive,
- * so, the variable will not be visible in debugger. User can still prolong life span of the variable by using it.
- *
- * This means, that function parameters do not longer span the whole function, including `this`.
- * This might and will break some bytecode processors, including old versions of R8. See KT-24510.
- */
-private fun updateLvtAccordingToLiveness(method: MethodNode, isForNamedFunction: Boolean) {
-    val liveness = analyzeLiveness(method)
-
-    fun List<LocalVariableNode>.findRecord(insnIndex: Int, variableIndex: Int): LocalVariableNode? {
-        for (variable in this) {
-            if (variable.index == variableIndex &&
-                method.instructions.indexOf(variable.start) <= insnIndex &&
-                insnIndex < method.instructions.indexOf(variable.end)
-            ) return variable
-        }
-        return null
-    }
-
-    fun isAlive(insnIndex: Int, variableIndex: Int): Boolean =
-        liveness[insnIndex].isAlive(variableIndex)
-
-    val oldLvt = arrayListOf<LocalVariableNode>()
-    for (record in method.localVariables) {
-        oldLvt += record
-    }
-    method.localVariables.clear()
-    // Skip `this` for suspend lamdba
-    val start = if (isForNamedFunction) 0 else 1
-    for (variableIndex in start until method.maxLocals) {
-        if (oldLvt.none { it.index == variableIndex }) continue
-        var startLabel: LabelNode? = null
-        for (insnIndex in 0 until (method.instructions.size() - 1)) {
-            val insn = method.instructions[insnIndex]
-            if (!isAlive(insnIndex, variableIndex) && isAlive(insnIndex + 1, variableIndex)) {
-                startLabel = insn as? LabelNode ?: insn.findNextOrNull { it is LabelNode } as? LabelNode
-            }
-            if (isAlive(insnIndex, variableIndex) && !isAlive(insnIndex + 1, variableIndex)) {
-                // No variable in LVT -> do not add one
-                val lvtRecord = oldLvt.findRecord(insnIndex, variableIndex) ?: continue
-                if (lvtRecord.name == CONTINUATION_VARIABLE_NAME) continue
-                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
-                // No LINENUMBER in range -> no way to put a breakpoint -> do not bother adding a record
-                if (InsnSequence(startLabel, endLabel).none { it is LineNumberNode }) continue
-                method.localVariables.add(
-                    LocalVariableNode(lvtRecord.name, lvtRecord.desc, lvtRecord.signature, startLabel, endLabel, lvtRecord.index)
-                )
-            }
-        }
-    }
-
-    for (variable in oldLvt) {
-        // $continuation and $result are dead, but they are used by debugger, as well as fake inliner variables
-        // For example, $continuation is used to create async stack trace
-        if (variable.name == CONTINUATION_VARIABLE_NAME ||
-            variable.name == SUSPEND_CALL_RESULT_NAME ||
-            isFakeLocalVariableForInline(variable.name)
-        ) {
-            method.localVariables.add(variable)
-        }
-        // this acts like $continuation for lambdas. For example, it is used by debugger to create async stack trace. Keep it.
-        if (variable.name == "this" && !isForNamedFunction) {
-            method.localVariables.add(variable)
-        }
-    }
-}

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

@@ -1,10 +1,11 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2019 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.coroutines
 
+import org.jetbrains.kotlin.codegen.inline.nodeText
 import org.jetbrains.kotlin.codegen.optimization.boxing.isUnitInstance
 import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
@@ -12,136 +13,169 @@ import org.jetbrains.kotlin.codegen.optimization.common.removeAll
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.tree.LabelNode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
+import org.jetbrains.org.objectweb.asm.Type
+import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import java.util.*
 
-/**
- * This pass removes unused Unit values. These typically occur as a result of inlining and could end up spilling
- * into the continuation object or break tail-call elimination.
- *
- * Concretely, we remove "GETSTATIC kotlin/Unit.INSTANCE" instructions if they are unused, or all uses are either
- * POP instructions, or ASTORE instructions to locals which are never read and are not named local variables.
- *
- * This pass does not touch [suspensionPoints], as later passes rely on the bytecode patterns around suspension points.
- */
-internal class RedundantLocalsEliminationMethodTransformer(private val suspensionPoints: List<SuspensionPoint>) : MethodTransformer() {
-    override fun transform(internalClassName: String, methodNode: MethodNode) {
-        val interpreter = UnitSourceInterpreter(methodNode.localVariables?.mapTo(mutableSetOf()) { it.index } ?: setOf())
-        val frames = interpreter.run(internalClassName, methodNode)
+private class PossibleSpilledValue(val source: AbstractInsnNode, type: Type?) : BasicValue(type) {
+    val usages = mutableSetOf<AbstractInsnNode>()
 
-        // Mark all unused instructions for deletion (except for labels which may be used in debug information)
-        val toDelete = mutableSetOf<AbstractInsnNode>()
-        methodNode.instructions.asSequence().zip(frames.asSequence()).mapNotNullTo(toDelete) { (insn, frame) ->
-            insn.takeIf { frame == null && insn !is LabelNode }
+    override fun toString(): String = when {
+        source.opcode == Opcodes.ALOAD -> "" + (source as VarInsnNode).`var`
+        source.isUnitInstance() -> "U"
+        else -> error("unreachable")
+    }
+
+    override fun equals(other: Any?): Boolean =
+        other is PossibleSpilledValue && source == other.source
+
+    override fun hashCode(): Int = super.hashCode() xor source.hashCode()
+}
+
+private object NonSpillableValue : BasicValue(AsmTypes.OBJECT_TYPE) {
+    override fun equals(other: Any?): Boolean = other is NonSpillableValue
+
+    override fun toString(): String = "N"
+}
+
+private object ConstructedValue : BasicValue(AsmTypes.OBJECT_TYPE) {
+    override fun equals(other: Any?): Boolean = other is ConstructedValue
+
+    override fun toString(): String = "C"
+}
+
+fun BasicValue?.nonspillable(): BasicValue? = if (this?.type?.sort == Type.OBJECT) NonSpillableValue else this
+
+private class RedundantSpillingInterpreter : BasicInterpreter(Opcodes.API_VERSION) {
+    val possibleSpilledValues = mutableSetOf<PossibleSpilledValue>()
+
+    override fun newOperation(insn: AbstractInsnNode): BasicValue? {
+        if (insn.opcode == Opcodes.NEW) return ConstructedValue
+        val basicValue = super.newOperation(insn)
+        return if (insn.isUnitInstance())
+            // Unit instances come from inlining suspend functions returning Unit.
+            // They can be spilled before they are eventually popped.
+            // Track them.
+            PossibleSpilledValue(insn, basicValue.type).also { possibleSpilledValues += it }
+        else basicValue.nonspillable()
+    }
+
+    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? =
+        when (value) {
+            is ConstructedValue -> value
+            is PossibleSpilledValue -> {
+                value.usages += insn
+                if (insn.opcode == Opcodes.ALOAD || insn.opcode == Opcodes.ASTORE) value
+                else value.nonspillable()
+            }
+            else -> value?.nonspillable()
         }
 
-        // Mark all spillable "GETSTATIC kotlin/Unit.INSTANCE" instructions for deletion
-        for ((unit, uses) in interpreter.unitUsageInformation) {
-            if (unit !in interpreter.unspillableUnitValues && unit !in suspensionPoints) {
-                toDelete += unit
-                toDelete += uses
+    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out BasicValue?>): BasicValue? {
+        for (value in values.filterIsInstance<PossibleSpilledValue>()) {
+            value.usages += insn
+        }
+        return super.naryOperation(insn, values)?.nonspillable()
+    }
+
+    override fun merge(v: BasicValue?, w: BasicValue?): BasicValue? =
+        if (v is PossibleSpilledValue && w is PossibleSpilledValue && v.source == w.source) v
+        else v?.nonspillable()
+}
+
+// Inliner emits a lot of locals during inlining.
+// Remove all of them since these locals are
+//  1) going to be spilled into continuation object
+//  2) breaking tail-call elimination
+internal class RedundantLocalsEliminationMethodTransformer(private val suspensionPoints: List<SuspensionPoint>) : MethodTransformer() {
+    override fun transform(internalClassName: String, methodNode: MethodNode) {
+        val interpreter = RedundantSpillingInterpreter()
+        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, interpreter).analyze()
+
+        val toDelete = mutableSetOf<AbstractInsnNode>()
+        for (spilledValue in interpreter.possibleSpilledValues.filter { it.usages.isNotEmpty() }) {
+            @Suppress("UNCHECKED_CAST")
+            val aloads = spilledValue.usages.filter { it.opcode == Opcodes.ALOAD } as List<VarInsnNode>
+
+            if (aloads.isEmpty()) continue
+
+            val slot = aloads.first().`var`
+
+            if (aloads.any { it.`var` != slot }) continue
+            for (aload in aloads) {
+                methodNode.instructions.set(aload, spilledValue.source.clone())
+            }
+
+            toDelete.addAll(spilledValue.usages.filter { it.opcode == Opcodes.ASTORE })
+            toDelete.add(spilledValue.source)
+        }
+
+        for (pop in methodNode.instructions.asSequence().filter { it.opcode == Opcodes.POP }) {
+            val value = (frames[methodNode.instructions.indexOf(pop)]?.top() as? PossibleSpilledValue) ?: continue
+            if (value.usages.isEmpty() && value.source !in suspensionPoints) {
+                toDelete.add(pop)
+                toDelete.add(value.source)
+            }
+        }
+
+        // Remove unreachable instructions to simplify further analyses
+        for (index in frames.indices) {
+            if (frames[index] == null) {
+                val insn = methodNode.instructions[index]
+                if (insn !is LabelNode) {
+                    toDelete.add(insn)
+                }
             }
         }
 
         methodNode.instructions.removeAll(toDelete)
     }
+
+    private fun AbstractInsnNode.clone() = when (this) {
+        is FieldInsnNode -> FieldInsnNode(opcode, owner, name, desc)
+        is VarInsnNode -> VarInsnNode(opcode, `var`)
+        is InsnNode -> InsnNode(opcode)
+        is TypeInsnNode -> TypeInsnNode(opcode, desc)
+        else -> error("clone of $this is not implemented yet")
+    }
 }
 
-// A version of SourceValue which inherits from BasicValue and is only used for Unit values.
-private class UnitValue(val insns: Set<AbstractInsnNode>) : BasicValue(AsmTypes.OBJECT_TYPE) {
-    constructor(insn: AbstractInsnNode) : this(Collections.singleton(insn))
-
-    override fun equals(other: Any?): Boolean = other is UnitValue && insns == other.insns
-    override fun hashCode() = Objects.hash(insns)
-    override fun toString() = "U"
-}
-
-// A specialized SourceInterpreter which only keeps track of the use sites for Unit values which are exclusively used as
-// arguments to POP and unused ASTORE instructions.
-private class UnitSourceInterpreter(private val localVariables: Set<Int>) : BasicInterpreter(Opcodes.API_VERSION) {
-    // All unit values with visible use-sites.
-    val unspillableUnitValues = mutableSetOf<AbstractInsnNode>()
-
-    // Map from unit values to ASTORE/POP use-sites.
-    val unitUsageInformation = mutableMapOf<AbstractInsnNode, MutableSet<AbstractInsnNode>>()
-
-    private fun markUnspillable(value: BasicValue?) =
-        value?.safeAs<UnitValue>()?.let { unspillableUnitValues += it.insns }
-
-    private fun collectUnitUsage(use: AbstractInsnNode, value: UnitValue) {
-        for (def in value.insns) {
-            if (def !in unspillableUnitValues) {
-                unitUsageInformation.getOrPut(def) { mutableSetOf() } += use
-            }
-        }
-    }
-
-    fun run(internalClassName: String, methodNode: MethodNode): Array<Frame<BasicValue>?> {
-        val frames = MethodAnalyzer<BasicValue>(internalClassName, methodNode, this).analyze()
-        // The ASM analyzer does not visit POP instructions, so we do so here.
-        for ((insn, frame) in methodNode.instructions.asSequence().zip(frames.asSequence())) {
-            if (frame != null && insn.opcode == Opcodes.POP) {
-                val value = frame.top()
-                value.safeAs<UnitValue>()?.let { collectUnitUsage(insn, it) }
-            }
-        }
-        return frames
-    }
-
-    override fun newOperation(insn: AbstractInsnNode?): BasicValue =
-        if (insn?.isUnitInstance() == true) UnitValue(insn) else super.newOperation(insn)
-
-    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        if (value is UnitValue) {
-            if (insn is VarInsnNode && insn.opcode == Opcodes.ASTORE && insn.`var` !in localVariables) {
-                collectUnitUsage(insn, value)
-                // We track the stored value in case it is subsequently read.
-                return value
-            }
-            unspillableUnitValues += value.insns
-        }
-        return super.copyOperation(insn, value)
-    }
-
-    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        markUnspillable(value)
-        return super.unaryOperation(insn, value)
-    }
-
-    override fun binaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?): BasicValue? {
-        markUnspillable(value1)
-        markUnspillable(value2)
-        return super.binaryOperation(insn, value1, value2)
-    }
-
-    override fun ternaryOperation(insn: AbstractInsnNode, value1: BasicValue?, value2: BasicValue?, value3: BasicValue?): BasicValue? {
-        markUnspillable(value1)
-        markUnspillable(value2)
-        markUnspillable(value3)
-        return super.ternaryOperation(insn, value1, value2, value3)
-    }
-
-    override fun naryOperation(insn: AbstractInsnNode, values: List<BasicValue>?): BasicValue? {
-        values?.forEach(this::markUnspillable)
-        return super.naryOperation(insn, values)
-    }
-
-    override fun merge(value1: BasicValue?, value2: BasicValue?): BasicValue? =
-        if (value1 is UnitValue && value2 is UnitValue) {
-            UnitValue(value1.insns.union(value2.insns))
-        } else {
-            // Mark unit values as unspillable if we merge them with non-unit values here.
-            // This is conservative since the value could turn out to be unused.
-            markUnspillable(value1)
-            markUnspillable(value2)
-            super.merge(value1, value2)
-        }
+// Handy debugging routing
+@Suppress("unused")
+fun MethodNode.nodeTextWithFrames(frames: Array<*>): String {
+    var insns = nodeText.split("\n")
+    val first = insns.indexOfLast { it.trim().startsWith("@") } + 1
+    var last = insns.indexOfFirst { it.trim().startsWith("LOCALVARIABLE") }
+    if (last < 0) last = insns.size
+    val prefix = insns.subList(0, first).joinToString(separator = "\n")
+    val postfix = insns.subList(last, insns.size).joinToString(separator = "\n")
+    insns = insns.subList(first, last)
+    if (insns.any { it.contains("TABLESWITCH") }) {
+        var insideTableSwitch = false
+        var buffer = ""
+        val res = arrayListOf<String>()
+        for (insn in insns) {
+            if (insn.contains("TABLESWITCH")) {
+                insideTableSwitch = true
+            }
+            if (insideTableSwitch) {
+                buffer += insn
+                if (insn.contains("default")) {
+                    insideTableSwitch = false
+                    res += buffer
+                    buffer = ""
+                    continue
+                }
+            } else {
+                res += insn
+            }
+        }
+        insns = res
+    }
+    return prefix + "\n" + insns.withIndex().joinToString(separator = "\n") { (index, insn) ->
+        if (index >= frames.size) "N/A\t$insn" else "${frames[index]}\t$insn"
+    } + "\n" + postfix
 }

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

@@ -0,0 +1,11 @@
+/*
+ * 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.coroutines
+
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
+
+typealias SourceFrames = Array<Frame<SourceValue>?>

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/SourceFrames.kt.202

@@ -0,0 +1,11 @@
+/*
+ * 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.coroutines
+
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
+import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
+
+typealias SourceFrames = Array<Frame<SourceValue>>

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

@@ -1,160 +0,0 @@
-/*
- * Copyright 2010-2019 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.coroutines
-
-import org.jetbrains.kotlin.codegen.StackValue
-import org.jetbrains.kotlin.codegen.optimization.common.MethodAnalyzer
-import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
-import org.jetbrains.org.objectweb.asm.Label
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-
-// BasicValue interpreter from ASM does not distinct 'int' types from other int-like types like 'byte' or 'boolean',
-// neither do HotSpot and JVM spec.
-// But it seems like Dalvik does not follow it, and spilling boolean value into an 'int' field fails with VerifyError on Android 4,
-// so this function calculates refined frames' markup.
-// Note that type of some values is only possible to determine by their usages (e.g. ICONST_1, BALOAD both may push boolean or byte on stack)
-// In this case, coerce the type of the value.
-
-internal class IloadedValue(val insns: Set<VarInsnNode>) : BasicValue(Type.INT_TYPE)
-
-private class IntLikeCoerceInterpreter : OptimizationBasicInterpreter() {
-    val needsToBeCoerced = mutableMapOf<VarInsnNode, Type>()
-
-    private fun coerce(value: IloadedValue, type: Type) {
-        for (insn in value.insns) {
-            needsToBeCoerced[insn] = type
-        }
-    }
-
-    override fun copyOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? =
-        when {
-            insn.opcode == Opcodes.ILOAD -> IloadedValue(setOf(insn as VarInsnNode))
-            value == null -> null
-            else -> BasicValue(value.type)
-        }
-
-    override fun binaryOperation(insn: AbstractInsnNode, v: BasicValue, w: BasicValue): BasicValue? {
-        if (insn.opcode == Opcodes.PUTFIELD) {
-            val expectedType = Type.getType((insn as FieldInsnNode).desc)
-            if (w is IloadedValue && expectedType.isIntLike()) {
-                coerce(w, expectedType)
-            }
-        }
-        return super.binaryOperation(insn, v, w)
-    }
-
-    override fun unaryOperation(insn: AbstractInsnNode, value: BasicValue?): BasicValue? {
-        if (insn.opcode == Opcodes.PUTSTATIC) {
-            val expectedType = Type.getType((insn as FieldInsnNode).desc)
-            if (value is IloadedValue && expectedType.isIntLike()) {
-                coerce(value, expectedType)
-            }
-        }
-        return super.unaryOperation(insn, value)
-    }
-
-    override fun naryOperation(insn: AbstractInsnNode, values: MutableList<out BasicValue?>): BasicValue? {
-        fun checkTypes(argTypes: Array<Type>, withReceiver: Boolean) {
-            val offset = if (withReceiver) 1 else 0
-            for ((index, argType) in argTypes.withIndex()) {
-                val value = values[index + offset] ?: continue
-                if (argType.isIntLike() && value is IloadedValue) {
-                    coerce(value, argType)
-                }
-            }
-        }
-        when (insn.opcode) {
-            Opcodes.INVOKEDYNAMIC -> {
-                checkTypes(Type.getArgumentTypes((insn as InvokeDynamicInsnNode).desc), false)
-            }
-            Opcodes.INVOKESTATIC -> {
-                checkTypes(Type.getArgumentTypes((insn as MethodInsnNode).desc), false)
-            }
-            Opcodes.INVOKEVIRTUAL, Opcodes.INVOKEINTERFACE, Opcodes.INVOKESPECIAL -> {
-                checkTypes(Type.getArgumentTypes((insn as MethodInsnNode).desc), true)
-            }
-        }
-        return super.naryOperation(insn, values)
-    }
-
-    override fun ternaryOperation(insn: AbstractInsnNode, arrayref: BasicValue?, index: BasicValue?, value: BasicValue?): BasicValue? {
-        when (insn.opcode) {
-            Opcodes.BASTORE -> {
-                if (value is IloadedValue) {
-                    val type = if (arrayref?.type?.descriptor == "[Z") Type.BOOLEAN_TYPE else Type.BYTE_TYPE
-                    coerce(value, type)
-                }
-            }
-            Opcodes.CASTORE -> {
-                if (value is IloadedValue) {
-                    coerce(value, Type.CHAR_TYPE)
-                }
-            }
-            Opcodes.SASTORE -> {
-                if (value is IloadedValue) {
-                    coerce(value, Type.SHORT_TYPE)
-                }
-            }
-        }
-        return super.ternaryOperation(insn, arrayref, index, value)
-    }
-
-    override fun merge(v: BasicValue, w: BasicValue): BasicValue =
-        when {
-            v is IloadedValue && w is IloadedValue && v.type == w.type -> {
-                val insns = v.insns + w.insns
-                insns.find { it in needsToBeCoerced }?.let {
-                    val type = needsToBeCoerced[it]!!
-                    coerce(v, type)
-                    coerce(w, type)
-                }
-                IloadedValue(insns)
-            }
-            v.type == w.type -> {
-                if (w is IloadedValue) w else v
-            }
-            else -> super.merge(v, w)
-        }
-}
-
-internal fun performSpilledVariableFieldTypesAnalysis(
-    methodNode: MethodNode,
-    thisName: String
-): Array<out Frame<BasicValue>?> {
-    val interpreter = IntLikeCoerceInterpreter()
-    MethodAnalyzer(thisName, methodNode, interpreter).analyze()
-    for ((insn, type) in interpreter.needsToBeCoerced) {
-        methodNode.instructions.insert(insn, withInstructionAdapter { coerceInt(type, this) })
-    }
-    return MethodAnalyzer(thisName, methodNode, OptimizationBasicInterpreter()).analyze()
-}
-
-private fun coerceInt(to: Type, v: InstructionAdapter) {
-    if (to == Type.BOOLEAN_TYPE) {
-        with(v) {
-            val zeroLabel = Label()
-            val resLabel = Label()
-            ifeq(zeroLabel)
-            iconst(1)
-            goTo(resLabel)
-            mark(zeroLabel)
-            iconst(0)
-            mark(resLabel)
-        }
-    } else {
-        StackValue.coerce(Type.INT_TYPE, to, v)
-    }
-}
-
-private fun Type.isIntLike(): Boolean = when (sort) {
-    Type.BOOLEAN, Type.BYTE, Type.CHAR, Type.SHORT -> true
-    else -> false
-}

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.codegen.inline.addFakeContinuationConstructorCallMar
 import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.inline.preprocessSuspendMarkers
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JVMConstructorCallNormalizationMode
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.languageVersionSettings
@@ -96,8 +95,7 @@ class SuspendFunctionGenerationStrategy(
             languageVersionSettings = languageVersionSettings,
             disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
                     originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
-                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit(),
-            useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit()
         )
     }
 

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

@@ -26,6 +26,7 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 
+// TODO Use this in variable liveness analysis
 internal class MethodNodeExaminer(
     val languageVersionSettings: LanguageVersionSettings,
     containingClassInternalName: String,

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

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

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

@@ -128,7 +128,7 @@ fun createFreeFakeLocalPropertyDescriptor(descriptor: LocalVariableDescriptor, t
     val property = PropertyDescriptorImpl.create(
         descriptor.containingDeclaration, descriptor.annotations, Modality.FINAL, descriptor.visibility, descriptor.isVar,
         descriptor.name, CallableMemberDescriptor.Kind.DECLARATION, descriptor.source, false, descriptor.isConst,
-        false, false, false, descriptor.isDelegated
+        false, false, false, @Suppress("DEPRECATION") descriptor.isDelegated
     )
     property.setType(
         descriptor.type, descriptor.typeParameters,

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

@@ -15,11 +15,9 @@ import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 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.descriptors.*
-import org.jetbrains.kotlin.incremental.components.Position
-import org.jetbrains.kotlin.incremental.components.ScopeKind
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -27,8 +25,10 @@ import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.inline.isInlineOnly
+import org.jetbrains.kotlin.resolve.isInlineClassType
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
@@ -87,9 +87,12 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         isSameModule = sourceCompiler.isCallInsideSameModuleAsDeclared(functionDescriptor)
 
         if (functionDescriptor !is FictitiousArrayConstructor) {
+            val functionOrAccessorName = jvmSignature.asmMethod.name
             //track changes for property accessor and @JvmName inline functions/property accessors
-            if (jvmSignature.asmMethod.name != functionDescriptor.name.asString()) {
-                trackLookup(functionDescriptor)
+            if (functionOrAccessorName != functionDescriptor.name.asString()) {
+                val scope = getMemberScope(functionDescriptor)
+                //Fake lookup to track track changes for property accessors and @JvmName functions/property accessors
+                scope?.getContributedFunctions(Name.identifier(functionOrAccessorName), sourceCompiler.lookupLocation)
             }
         }
     }
@@ -230,7 +233,7 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         )
 
         val sourceInfo = sourceMapper.sourceInfo!!
-        val callSite = SourcePosition(codegen.lastLineNumber, sourceInfo.sourceFileName!!, sourceInfo.pathOrCleanFQN)
+        val callSite = SourcePosition(codegen.lastLineNumber, sourceInfo.source, sourceInfo.pathOrCleanFQN)
         val inliner = MethodInliner(
             node, parameters, info, FieldRemapper(null, null, parameters), isSameModule,
             "Method inlining " + sourceCompiler.callElementText,
@@ -497,24 +500,19 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
         return true
     }
 
-    private fun trackLookup(functionOrAccessor: FunctionDescriptor) {
-        val functionOrAccessorName = jvmSignature.asmMethod.name
-        val lookupTracker = state.configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: return
-        val location = sourceCompiler.lookupLocation.location ?: return
-        val position = if (lookupTracker.requiresPosition) location.position else Position.NO_POSITION
-        val classOrPackageFragment = functionOrAccessor.containingDeclaration
-        lookupTracker.record(
-            location.filePath,
-            position,
-            DescriptorUtils.getFqName(classOrPackageFragment).asString(),
-            ScopeKind.CLASSIFIER,
-            functionOrAccessorName
-        )
-    }
-
 
     companion object {
 
+        private fun getMemberScope(functionOrAccessor: FunctionDescriptor): MemberScope? {
+            val callableMemberDescriptor = JvmCodegenUtil.getDirectMember(functionOrAccessor)
+            val classOrPackageFragment = callableMemberDescriptor.containingDeclaration
+            return when (classOrPackageFragment) {
+                is ClassDescriptor -> classOrPackageFragment.unsubstitutedMemberScope
+                is PackageFragmentDescriptor -> classOrPackageFragment.getMemberScope()
+                else -> null
+            }
+        }
+
         internal fun createInlineMethodNode(
             functionDescriptor: FunctionDescriptor,
             methodOwner: Type,

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

@@ -100,11 +100,6 @@ class PsiDefaultLambda(
     override fun mapAsmSignature(sourceCompiler: SourceCompilerForInline): Method {
         return sourceCompiler.state.typeMapper.mapSignatureSkipGeneric(invokeMethodDescriptor).asmMethod
     }
-
-    override fun findInvokeMethodDescriptor(): FunctionDescriptor =
-        parameterDescriptor.type.memberScope
-            .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
-            .single()
 }
 
 abstract class DefaultLambda(
@@ -155,10 +150,14 @@ abstract class DefaultLambda(
             }
         }, ClassReader.SKIP_CODE or ClassReader.SKIP_FRAMES or ClassReader.SKIP_DEBUG)
 
-        invokeMethodDescriptor = findInvokeMethodDescriptor().let {
-            //property reference generates erased 'get' method
-            if (isPropertyReference) it.original else it
-        }
+        invokeMethodDescriptor =
+            parameterDescriptor.type.memberScope
+                .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
+                .single()
+                .let {
+                    //property reference generates erased 'get' method
+                    if (isPropertyReference) it.original else it
+                }
 
         val descriptor = Type.getMethodDescriptor(Type.VOID_TYPE, *capturedArgs)
         val constructor = getMethodNode(
@@ -207,8 +206,6 @@ abstract class DefaultLambda(
 
     protected abstract fun mapAsmSignature(sourceCompiler: SourceCompilerForInline): Method
 
-    protected abstract fun findInvokeMethodDescriptor(): FunctionDescriptor
-
     private companion object {
         val PROPERTY_REFERENCE_SUPER_CLASSES =
             listOf(

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

@@ -85,14 +85,9 @@ class SourceMapper(val sourceInfo: SourceInfo?) {
         get() = fileMappings.values.toList()
 
     init {
-        sourceInfo?.let { sourceInfo ->
-            // If 'sourceFileName' is null, this class doesn't have debug information
-            // (e.g., multi-file class facade with multiple parts).
-            sourceInfo.sourceFileName?.let { sourceFileName ->
-                // Explicitly map the file to itself -- we'll probably need a lot of lines from it, so this will produce fewer ranges.
-                getOrRegisterNewSource(sourceFileName, sourceInfo.pathOrCleanFQN)
-                    .mapNewInterval(1, 1, sourceInfo.linesInFile)
-            }
+        sourceInfo?.let {
+            // Explicitly map the file to itself -- we'll probably need a lot of lines from it, so this will produce fewer ranges.
+            getOrRegisterNewSource(it.source, it.pathOrCleanFQN).mapNewInterval(1, 1, it.linesInFile)
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.codegen.coroutines.*
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -96,8 +95,7 @@ class CoroutineTransformer(
                 shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                 containingClassInternalName = classBuilder.thisName,
                 isForNamedFunction = false,
-                disableTailCallOptimizationForFunctionReturningUnit = false,
-                useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                disableTailCallOptimizationForFunctionReturningUnit = false
             )
 
             if (generateForInline)
@@ -133,8 +131,7 @@ class CoroutineTransformer(
                 needDispatchReceiver = true,
                 internalNameForDispatchReceiver = classBuilder.thisName,
                 disableTailCallOptimizationForFunctionReturningUnit = disableTailCallOptimization,
-                putContinuationParameterToLvt = !state.isIrBackend,
-                useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
+                putContinuationParameterToLvt = !state.isIrBackend
             )
 
             if (generateForInline)

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

@@ -242,17 +242,6 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
             methodNode.removeUnusedLocalVariables()
         }
 
-        // Be careful to not remove instructions that are the only instruction for a line number. That will
-        // break debugging. If the previous instruction is a line number and the following instruction is
-        // a label followed by a line number, insert a nop instead of deleting the instruction.
-        private fun InsnList.removeOrReplaceByNop(insn: AbstractInsnNode) {
-            if (insn.previous is LineNumberNode && insn.next is LabelNode && insn.next.next is LineNumberNode) {
-                set(insn, InsnNode(Opcodes.NOP))
-            } else {
-                remove(insn)
-            }
-        }
-
         private fun rewriteRefValue(capturedVar: CapturedVarDescriptor) {
             methodNode.instructions.run {
                 val localVar = capturedVar.localVar!!
@@ -270,10 +259,9 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
 
                 remove(capturedVar.newInsn)
                 remove(capturedVar.initCallInsn!!)
-
-                capturedVar.stackInsns.forEach { removeOrReplaceByNop(it) }
-                capturedVar.aloadInsns.forEach { removeOrReplaceByNop(it) }
-                capturedVar.astoreInsns.forEach { removeOrReplaceByNop(it) }
+                capturedVar.stackInsns.forEach { remove(it) }
+                capturedVar.aloadInsns.forEach { remove(it) }
+                capturedVar.astoreInsns.forEach { remove(it) }
                 capturedVar.getFieldInsns.forEach { set(it, VarInsnNode(loadOpcode, capturedVar.localVarIndex)) }
                 capturedVar.putFieldInsns.forEach { set(it, VarInsnNode(storeOpcode, capturedVar.localVarIndex)) }
 
@@ -285,7 +273,6 @@ class CapturedVarsOptimizationMethodTransformer : MethodTransformer() {
                 }
             }
         }
-
     }
 }
 

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

@@ -5,10 +5,16 @@
 
 package org.jetbrains.kotlin.codegen.optimization.common
 
+import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME
+import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
+import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.IincInsnNode
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.org.objectweb.asm.tree.VarInsnNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
+import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import java.util.*
 
 
@@ -23,6 +29,10 @@ class VariableLivenessFrame(val maxLocals: Int) : VarFrame<VariableLivenessFrame
         bitSet.set(varIndex, true)
     }
 
+    fun markAllAlive(bitSet: BitSet) {
+        this.bitSet.or(bitSet)
+    }
+
     fun markDead(varIndex: Int) {
         bitSet.set(varIndex, false)
     }
@@ -35,17 +45,34 @@ class VariableLivenessFrame(val maxLocals: Int) : VarFrame<VariableLivenessFrame
     }
 
     override fun hashCode() = bitSet.hashCode()
-
-    override fun toString(): String = (0 until maxLocals).map { if (bitSet[it]) '@' else '_' }.joinToString(separator = "")
 }
 
-fun analyzeLiveness(method: MethodNode): List<VariableLivenessFrame> =
-    analyze(method, object : BackwardAnalysisInterpreter<VariableLivenessFrame> {
+fun analyzeLiveness(node: MethodNode): List<VariableLivenessFrame> {
+    val typeAnnotatedFrames = MethodTransformer.analyze("fake", node, OptimizationBasicInterpreter())
+    val visibleByDebuggerVariables = analyzeVisibleByDebuggerVariables(node, typeAnnotatedFrames)
+    return analyze(node, object : BackwardAnalysisInterpreter<VariableLivenessFrame> {
         override fun newFrame(maxLocals: Int) = VariableLivenessFrame(maxLocals)
         override fun def(frame: VariableLivenessFrame, insn: AbstractInsnNode) = defVar(frame, insn)
         override fun use(frame: VariableLivenessFrame, insn: AbstractInsnNode) =
-            useVar(frame, insn)
+            useVar(frame, insn, node, visibleByDebuggerVariables[node.instructions.indexOf(insn)])
     })
+}
+
+private fun analyzeVisibleByDebuggerVariables(
+    node: MethodNode,
+    typeAnnotatedFrames: TypeAnnotatedFrames
+): Array<BitSet> {
+    val res = Array(node.instructions.size()) { BitSet(node.maxLocals) }
+    for (local in node.localVariables) {
+        if (local.name.isInvisibleDebuggerVariable()) continue
+        for (index in node.instructions.indexOf(local.start) until node.instructions.indexOf(local.end)) {
+            if (Type.getType(local.desc).sort == typeAnnotatedFrames[index]?.getLocal(local.index)?.type?.sort) {
+                res[index].set(local.index)
+            }
+        }
+    }
+    return res
+}
 
 private fun defVar(frame: VariableLivenessFrame, insn: AbstractInsnNode) {
     if (insn is VarInsnNode && insn.isStoreOperation()) {
@@ -53,10 +80,22 @@ private fun defVar(frame: VariableLivenessFrame, insn: AbstractInsnNode) {
     }
 }
 
-private fun useVar(frame: VariableLivenessFrame, insn: AbstractInsnNode) {
+private fun useVar(
+    frame: VariableLivenessFrame,
+    insn: AbstractInsnNode,
+    node: MethodNode,
+    visibleByDebuggerVariables: BitSet
+) {
+    frame.markAllAlive(visibleByDebuggerVariables)
+
     if (insn is VarInsnNode && insn.isLoadOperation()) {
         frame.markAlive(insn.`var`)
     } else if (insn is IincInsnNode) {
         frame.markAlive(insn.`var`)
     }
-}
+}
+
+private fun String.isInvisibleDebuggerVariable(): Boolean =
+    startsWith(JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_ARGUMENT) ||
+            startsWith(JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_FUNCTION) ||
+            this == SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeIntrinsicRangeValue.kt

@@ -69,10 +69,9 @@ abstract class PrimitiveNumberRangeIntrinsicRangeValue(
                     ?: throw AssertionError("Floating point intrinsic range value should be a range literal")
                 InFloatingPointRangeLiteralExpressionGenerator(operatorReference, rangeLiteral, comparisonGenerator, codegen.frameMap)
             }
-            else ->
-                InIntegralContinuousRangeExpressionGenerator(
-                    operatorReference, rangeContainsTypeInfo, getBoundedValue(codegen), comparisonGenerator, codegen.frameMap
-                )
+            else -> InIntegralContinuousRangeExpressionGenerator(
+                operatorReference, rangeContainsTypeInfo, getBoundedValue(codegen), comparisonGenerator, codegen.frameMap
+            )
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeCodegenUtil.kt

@@ -208,25 +208,17 @@ fun isPrimitiveRangeContains(descriptor: CallableDescriptor): Boolean {
 }
 
 fun isUnsignedIntegerRangeContains(descriptor: CallableDescriptor): Boolean {
+    if (descriptor.name.asString() != "contains") return false
+
     val dispatchReceiverType = descriptor.dispatchReceiverParameter?.type
     val extensionReceiverType = descriptor.extensionReceiverParameter?.type
 
-    when {
-        dispatchReceiverType != null && extensionReceiverType == null -> {
-            if (descriptor.name.asString() != "contains") return false
-            return isUnsignedRange(dispatchReceiverType)
-        }
-        extensionReceiverType != null && dispatchReceiverType == null -> {
-            if (!descriptor.isTopLevelInPackage("contains", "kotlin.ranges")) return false
-            return isUnsignedRange(extensionReceiverType)
-        }
-        else ->
-            return false
-    }
+    return (dispatchReceiverType != null && isUnsignedRange(dispatchReceiverType)) ||
+            (extensionReceiverType != null && isUnsignedRange(extensionReceiverType))
 }
 
 fun isPrimitiveNumberRangeExtensionContainsPrimitiveNumber(descriptor: CallableDescriptor): Boolean {
-    if (!descriptor.isTopLevelInPackage("contains", "kotlin.ranges")) return false
+    if (descriptor.name.asString() != "contains") return false
 
     val extensionReceiverType = descriptor.extensionReceiverParameter?.type ?: return false
 

compiler/backend/src/org/jetbrains/kotlin/codegen/range/RangeValues.kt

@@ -74,6 +74,7 @@ fun ExpressionCodegen.createRangeValueForExpression(rangeExpression: KtExpressio
     }
 }
 
+@Suppress("DEPRECATION")
 fun isLocalVarReference(rangeExpression: KtExpression, bindingContext: BindingContext): Boolean {
     if (rangeExpression !is KtSimpleNameExpression) return false
     val resultingDescriptor = rangeExpression.getResolvedCall(bindingContext)?.resultingDescriptor ?: return false

compiler/backend/src/org/jetbrains/kotlin/codegen/range/comparison/ComparisonGenerator.kt

@@ -87,10 +87,7 @@ fun getComparisonGeneratorForRangeContainsCall(
             getComparisonGeneratorForKotlinType(elementType)
 
         KotlinBuiltIns.isUInt(elementType) ->
-            if (KotlinBuiltIns.isULong(valueParameterType))
-                null
-            else
-                UIntComparisonGenerator
+            UIntComparisonGenerator
 
         KotlinBuiltIns.isULong(elementType) ->
             ULongComparisonGenerator

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

@@ -94,13 +94,7 @@ class JvmSerializerExtension @JvmOverloads constructor(
         writeVersionRequirementForJvmDefaultIfNeeded(descriptor, proto, versionRequirementTable)
 
         if (jvmDefaultMode.forAllMethodsWithBody && isInterface(descriptor)) {
-            proto.setExtension(
-                JvmProtoBuf.jvmClassFlags,
-                JvmFlags.getClassFlags(
-                    jvmDefaultMode.forAllMethodsWithBody,
-                    JvmDefaultMode.ALL_COMPATIBILITY == jvmDefaultMode
-                )
-            )
+            proto.setExtension(JvmProtoBuf.jvmClassFlags, JvmFlags.getClassFlags(true))
         }
     }
 
@@ -301,7 +295,7 @@ class JvmSerializerExtension @JvmOverloads constructor(
         super.serializeErrorType(type, builder)
     }
 
-    private fun <K : Any, V> getBinding(slice: SerializationMappingSlice<K, V>, key: K): V? =
+    private fun <K, V> getBinding(slice: SerializationMappingSlice<K, V>, key: K): V? =
         bindings.get(slice, key) ?: globalBindings.get(slice, key)
 
     private inner class SignatureSerializer {

compiler/backend/src/org/jetbrains/kotlin/codegen/signature/AsmTypeFactory.kt

@@ -16,27 +16,16 @@
 
 package org.jetbrains.kotlin.codegen.signature
 
-import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.load.kotlin.JvmTypeFactory
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.org.objectweb.asm.Type
 
 object AsmTypeFactory : JvmTypeFactory<Type> {
-    override fun boxType(possiblyPrimitiveType: Type): Type =
-        AsmUtil.boxType(possiblyPrimitiveType)
-
-    override fun createFromString(representation: String): Type =
-        Type.getType(representation)
-
-    override fun createPrimitiveType(primitiveType: PrimitiveType): Type =
-        AsmTypes.valueTypeForPrimitive(primitiveType)
-
-    override fun createObjectType(internalName: String): Type =
-        Type.getObjectType(internalName)
-
-    override fun toString(type: Type): String =
-        type.descriptor
+    override fun boxType(possiblyPrimitiveType: Type) = AsmUtil.boxType(possiblyPrimitiveType)
+    override fun createFromString(representation: String) = Type.getType(representation)
+    override fun createObjectType(internalName: String) = Type.getObjectType(internalName)
+    override fun toString(type: Type) = type.descriptor
 
     override val javaLangClassType: Type
         get() = AsmTypes.JAVA_CLASS_TYPE

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

@@ -23,9 +23,7 @@ import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
 import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.LocalVariableAccessorDescriptor
-import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
-import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.impl.*
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature
 import org.jetbrains.kotlin.load.java.JvmAbi
@@ -1210,7 +1208,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
             return StackValue.sharedTypeForType(mapType(receiverParameter.type))
         }
 
-        if (descriptor is LocalVariableDescriptor && descriptor.isDelegated) {
+        if (descriptor is LocalVariableDescriptor && @Suppress("DEPRECATION") descriptor.isDelegated) {
             return null
         }
 

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -51,7 +51,7 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
                 put(CommonConfigurationKeys.MODULE_NAME, "module for built-ins serialization")
             }
 
-            val environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+            val environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
             serialize(environment)
 

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.serialization.builtins
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
-import org.jetbrains.kotlin.serialization.AnnotationSerializer
 import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
 import org.jetbrains.kotlin.types.KotlinType
@@ -32,29 +31,20 @@ class BuiltInsSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeriali
         "CharRange" to "kotlin/ranges/CharRange"
     )
 
-    override fun createAnnotationSerializer(): AnnotationSerializer = object : AnnotationSerializer(stringTable) {
-        override fun ignoreAnnotation(type: KotlinType): Boolean =
-            type.presentableName == "JvmStatic" || type.presentableName == "JvmField" || super.ignoreAnnotation(type)
-    }
-
     override val metadataVersion: BinaryVersion
         get() = BuiltInsBinaryVersion.INSTANCE
 
     override fun shouldUseTypeTable(): Boolean = true
 
     override fun serializeErrorType(type: KotlinType, builder: ProtoBuf.Type.Builder) {
-        val className = shortNameToClassId[type.presentableName]
-            ?: throw UnsupportedOperationException("Unsupported unresolved type: ${type.unwrap()}")
+        val unwrapped = type.unwrap()
+        if (unwrapped !is UnresolvedType) {
+            throw UnsupportedOperationException("Error types which are not UnresolvedType instances are not supported here: $unwrapped")
+        }
+
+        val className = shortNameToClassId[unwrapped.presentableName]
+                ?: throw UnsupportedOperationException("Unsupported unresolved type: $unwrapped")
 
         builder.className = stringTable.getQualifiedClassNameIndex(className, false)
     }
-
-    private val KotlinType.presentableName: String
-        get() {
-            val unwrapped = unwrap()
-            if (unwrapped !is UnresolvedType) {
-                throw UnsupportedOperationException("Error types which are not UnresolvedType instances are not supported here: $unwrapped")
-            }
-            return unwrapped.presentableName
-        }
 }

compiler/cli/build.gradle.kts

@@ -31,9 +31,6 @@ dependencies {
     compile(project(":kotlin-util-io"))
     compile(project(":compiler:ir.serialization.common"))
 
-    // TODO: as soon as cli-jvm is extracted out of this module, move this dependency there
-    compileOnly(project(":compiler:ir.tree.impl"))
-
     compileOnly(toolsJarApi())
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }

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

@@ -340,12 +340,6 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var explicitApi: String by FreezableVar(ExplicitApiMode.DISABLED.state)
 
-    @Argument(
-        value = "-Xdeserialize-fake-overrides",
-        description = "Fallback to deserializing fake overrides"
-    )
-    var deserializeFakeOverrides: Boolean by FreezableVar(false)
-
     open fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         return HashMap<AnalysisFlag<*>, Any>().apply {
             put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck)
@@ -388,7 +382,6 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
                 put(LanguageFeature.NewInference, LanguageFeature.State.ENABLED)
                 put(LanguageFeature.SamConversionPerArgument, LanguageFeature.State.ENABLED)
                 put(LanguageFeature.FunctionReferenceWithDefaultValueAsOtherType, LanguageFeature.State.ENABLED)
-                put(LanguageFeature.DisableCompatibilityModeForNewInference, LanguageFeature.State.ENABLED)
             }
 
             if (inlineClasses) {
@@ -468,8 +461,6 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
 
             if (!functionReferenceWithDefaultValueFeaturePassedExplicitly)
                 put(LanguageFeature.FunctionReferenceWithDefaultValueAsOtherType, LanguageFeature.State.ENABLED)
-
-            put(LanguageFeature.DisableCompatibilityModeForNewInference, LanguageFeature.State.ENABLED)
         }
 
         if (featuresThatForcePreReleaseBinaries.isNotEmpty()) {

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

@@ -135,9 +135,6 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     )
     var irModuleName: String? by NullableStringFreezableVar(null)
 
-    @Argument(value = "-Xir-per-module", description = "Splits generated .js per-module")
-    var irPerModule: Boolean by FreezableVar(false)
-
     @Argument(
         value = "-Xinclude",
         valueDescription = "<path>",
@@ -172,9 +169,6 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xenable-js-scripting", description = "Enable experimental support of .kts files using K/JS (with -Xir only)")
     var enableJsScripting: Boolean by FreezableVar(false)
 
-    @Argument(value = "-Xdisable-fake-override-validator", description = "Disable IR fake override validator")
-    var disableFakeOverrideValidator: Boolean by FreezableVar(false)
-
     override fun checkIrSupport(languageVersionSettings: LanguageVersionSettings, collector: MessageCollector) {
         if (!isIrBackendEnabled()) return
 

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

@@ -369,12 +369,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var repeatCompileModules: String? by NullableStringFreezableVar(null)
 
-    @Argument(
-        value = "-Xuse-old-spilled-var-type-analysis",
-        description = "Use old, SourceInterpreter-based analysis for fields, used for spilled variables in coroutines"
-    )
-    var useOldSpilledVarTypeAnalysis: Boolean by FreezableVar(false)
-
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics

compiler/cli/cli-common/src/org/jetbrains/kotlin/utils/parametersMap.kt

@@ -63,8 +63,8 @@ private interface ArgsConverter<T> {
     }
 
     fun tryConvertSingle(parameter: KParameter, arg: NamedArgument<T>): Result
-    fun tryConvertVararg(parameter: KParameter, firstArg: NamedArgument<T>, restArgs: Sequence<NamedArgument<T>>): Result
-    fun tryConvertTail(parameter: KParameter, firstArg: NamedArgument<T>, restArgs: Sequence<NamedArgument<T>>): Result
+    fun tryConvertVararg(parameter: KParameter, firstArg: NamedArgument<T>, restArgsIt: Iterator<NamedArgument<T>>): Result
+    fun tryConvertTail(parameter: KParameter, firstArg: NamedArgument<T>, restArgsIt: Iterator<NamedArgument<T>>): Result
 }
 
 private enum class ArgsTraversalState { UNNAMED, NAMED, TAIL }
@@ -77,7 +77,7 @@ private fun <T> tryCreateCallableMapping(
     val res = mutableMapOf<KParameter, Any?>()
     var state = ArgsTraversalState.UNNAMED
     val unboundParams = callable.parameters.toMutableList()
-    val argIt = LookAheadIterator(args.iterator())
+    val argIt = args.iterator()
     while (argIt.hasNext()) {
         if (unboundParams.isEmpty()) return null // failed to match: no param left for the arg
         val arg = argIt.next()
@@ -102,11 +102,7 @@ private fun <T> tryCreateCallableMapping(
                     res[par] = cvtRes.v
                 } else if (par.type.jvmErasure.java.isArray) {
                     // try vararg
-
-                    // Collect all the arguments that do not have a name
-                    val unnamed = argIt.sequenceUntil { it.name != null }
-
-                    val cvtVRes = converter.tryConvertVararg(par, arg, unnamed)
+                    val cvtVRes = converter.tryConvertVararg(par, arg, argIt)
                     if (cvtVRes is ArgsConverter.Result.Success) {
                         res[par] = cvtVRes.v
                     } else return null // failed to match: no suitable param for unnamed arg
@@ -125,7 +121,7 @@ private fun <T> tryCreateCallableMapping(
             ArgsTraversalState.TAIL -> {
                 assert(arg.name == null)
                 val par = unboundParams.removeAt(unboundParams.lastIndex)
-                val cvtVRes = converter.tryConvertTail(par, arg, argIt.asSequence())
+                val cvtVRes = converter.tryConvertTail(par, arg, argIt)
                 if (cvtVRes is ArgsConverter.Result.Success) {
                     if (argIt.hasNext()) return null // failed to match: not all tail args are consumed
                     res[par] = cvtVRes.v
@@ -166,7 +162,7 @@ private class StringArgsConverter : ArgsConverter<String> {
     override fun tryConvertVararg(
         parameter: KParameter,
         firstArg: NamedArgument<String>,
-        restArgs: Sequence<NamedArgument<String>>
+        restArgsIt: Iterator<NamedArgument<String>>
     ): ArgsConverter.Result {
         fun convertPrimitivesArray(type: KType, args: Sequence<String?>): Any? =
             when (type.classifier) {
@@ -183,7 +179,7 @@ private class StringArgsConverter : ArgsConverter<String> {
 
         val parameterType = parameter.type
         if (parameterType.jvmErasure.java.isArray) {
-            val argsSequence = sequenceOf(firstArg.value) + restArgs.map { it.value }
+            val argsSequence = sequenceOf(firstArg.value) + restArgsIt.asSequence().map { it.value }
             val primArrayArgCandidate = convertPrimitivesArray(parameterType, argsSequence)
             if (primArrayArgCandidate != null)
                 return ArgsConverter.Result.Success(primArrayArgCandidate)
@@ -199,9 +195,9 @@ private class StringArgsConverter : ArgsConverter<String> {
     override fun tryConvertTail(
         parameter: KParameter,
         firstArg: NamedArgument<String>,
-        restArgs: Sequence<NamedArgument<String>>
+        restArgsIt: Iterator<NamedArgument<String>>
     ): ArgsConverter.Result =
-        tryConvertVararg(parameter, firstArg, restArgs)
+        tryConvertVararg(parameter, firstArg, restArgsIt)
 }
 
 private class AnyArgsConverter : ArgsConverter<Any> {
@@ -222,33 +218,18 @@ private class AnyArgsConverter : ArgsConverter<Any> {
                 else -> null
             }
 
-        fun evaluateValue(arg: Any): Any? {
-            if (arg::class.isSubclassOf(parameter.type.jvmErasure)) return arg
-            return convertPrimitivesArray(parameter.type, arg)
-        }
+        if (value::class.isSubclassOf(parameter.type.jvmErasure)) return ArgsConverter.Result.Success(value)
 
-        evaluateValue(value)?.let { return ArgsConverter.Result.Success(it) }
-
-        // Handle the scenario where [arg::class] is an Array<Any>
-        // but it's values could all still be valid
-        val parameterKClass = parameter.type.classifier as? KClass<*>
-        val arrayComponentType = parameterKClass?.java?.takeIf { it.isArray}?.componentType?.kotlin
-
-        if (value is Array<*> && arrayComponentType != null) {
-            // TODO: Idea! Maybe we should check if the values in the array are compatible with [arrayComponentType]
-            //  if they aren't perhaps we should fail silently
-            convertAnyArray(arrayComponentType, value.asSequence())?.let(::evaluateValue)?.let { return ArgsConverter.Result.Success(it) }
-        }
-
-        return ArgsConverter.Result.Failure
+        return convertPrimitivesArray(parameter.type, value)?.let { ArgsConverter.Result.Success(it) }
+            ?: ArgsConverter.Result.Failure
     }
 
     override fun tryConvertVararg(
-        parameter: KParameter, firstArg: NamedArgument<Any>, restArgs: Sequence<NamedArgument<Any>>
+        parameter: KParameter, firstArg: NamedArgument<Any>, restArgsIt: Iterator<NamedArgument<Any>>
     ): ArgsConverter.Result {
         val parameterType = parameter.type
         if (parameterType.jvmErasure.java.isArray) {
-            val argsSequence = sequenceOf(firstArg.value) + restArgs.map { it.value }
+            val argsSequence = sequenceOf(firstArg.value) + restArgsIt.asSequence().map { it.value }
             val arrayElementType = parameterType.arguments.firstOrNull()?.type
             val arrayArgCandidate = convertAnyArray(arrayElementType?.classifier, argsSequence)
             if (arrayArgCandidate != null)
@@ -261,7 +242,7 @@ private class AnyArgsConverter : ArgsConverter<Any> {
     override fun tryConvertTail(
         parameter: KParameter,
         firstArg: NamedArgument<Any>,
-        restArgs: Sequence<NamedArgument<Any>>
+        restArgsIt: Iterator<NamedArgument<Any>>
     ): ArgsConverter.Result =
         tryConvertSingle(parameter, firstArg)
 }
@@ -285,38 +266,3 @@ private fun <T> convertAnyArrayImpl(classifier: KClassifier?, args: Sequence<T?>
     }
     return result
 }
-
-/*
- An iterator that allows us to read the next value without consuming it.
- */
-private class LookAheadIterator<T>(private val iterator: Iterator<T>) : Iterator<T> {
-    private var currentLookAhead: T? = null
-
-    override fun hasNext(): Boolean {
-        return currentLookAhead != null || iterator.hasNext()
-    }
-
-    override fun next(): T {
-        currentLookAhead?.let { value ->
-            currentLookAhead = null
-            return value
-        }
-
-        return iterator.next()
-    }
-
-    fun nextWithoutConsuming(): T {
-        return currentLookAhead ?: iterator.next().also { currentLookAhead = it }
-    }
-}
-
-/*
- Will return a sequence with the values of the iterator until the predicate evaluates to true.
- */
-private fun <T> LookAheadIterator<T>.sequenceUntil(predicate: (T) -> Boolean): Sequence<T> = sequence {
-    while (hasNext()) {
-        if (predicate(nextWithoutConsuming()))
-            break
-        yield(next())
-    }
-}

compiler/cli/cli-js-klib/build.gradle.kts

@@ -6,7 +6,6 @@ plugins {
 dependencies {
     compile(project(":compiler:cli"))
     compile(project(":compiler:ir.serialization.js"))
-    compileOnly(project(":compiler:ir.tree.persistent"))
     runtimeOnly(project(":kotlin-reflect"))
     if (Platform[193].orLower()) {
         compile(intellijDep()) { includeJars("picocontainer", rootProject = rootProject) }

compiler/cli/cli-js-klib/src/GenerateJsIrKlib.kt

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.psi.KtFile
@@ -88,7 +87,6 @@ fun buildKLib(
         configuration = configuration,
         allDependencies = allDependencies,
         friendDependencies = emptyList(),
-        irFactory = PersistentIrFactory,
         outputKlibPath = outputPath,
         nopack = true
     )

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

@@ -24,17 +24,13 @@ import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.IncrementalCompilation
-import org.jetbrains.kotlin.config.Services
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.ir.backend.js.*
-import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -197,7 +193,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     configuration = config.configuration,
                     allDependencies = resolvedLibraries,
                     friendDependencies = friendDependencies,
-                    irFactory = PersistentIrFactory,
                     outputKlibPath = outputKlibPath,
                     nopack = arguments.irProduceKlibDir
                 )
@@ -234,19 +229,14 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     mainArguments = mainCallArguments,
                     generateFullJs = !arguments.irDce,
                     generateDceJs = arguments.irDce,
-                    dceDriven = arguments.irDceDriven,
-                    multiModule = arguments.irPerModule,
-                    relativeRequirePath = true
+                    dceDriven = arguments.irDceDriven
                 )
             } catch (e: JsIrCompilationError) {
                 return COMPILATION_ERROR
             }
 
             val jsCode = if (arguments.irDce && !arguments.irDceDriven) compiledModule.dceJsCode!! else compiledModule.jsCode!!
-            outputFile.writeText(jsCode.mainModule)
-            jsCode.dependencies.forEach { (name, content) ->
-                outputFile.resolveSibling("$name.js").writeText(content)
-            }
+            outputFile.writeText(jsCode)
             if (arguments.generateDts) {
                 val dtsFile = outputFile.withReplacedExtensionOrNull(outputFile.extension, "d.ts")!!
                 dtsFile.writeText(compiledModule.tsDefinitions ?: error("No ts definitions"))
@@ -332,7 +322,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         }
 
         configuration.put(JSConfigurationKeys.PRINT_REACHABILITY_INFO, arguments.irDcePrintReachabilityInfo)
-        configuration.put(JSConfigurationKeys.DISABLE_FAKE_OVERRIDE_VALIDATOR, arguments.disableFakeOverrideValidator)
     }
 
     override fun executableScriptFileName(): String {

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt

@@ -45,7 +45,7 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
 
     protected abstract val performanceManager: CommonCompilerPerformanceManager
 
-    protected open fun createPerformanceManager(arguments: A, services: Services): CommonCompilerPerformanceManager = performanceManager
+    protected open fun createPerformanceManager(arguments: A): CommonCompilerPerformanceManager = performanceManager
 
     // Used in CompilerRunnerUtil#invokeExecMethod, in Eclipse plugin (KotlinCLICompiler) and in kotlin-gradle-plugin (GradleCompilerRunner)
     fun execAndOutputXml(errStream: PrintStream, services: Services, vararg args: String): ExitCode {
@@ -58,7 +58,7 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
     }
 
     public override fun execImpl(messageCollector: MessageCollector, services: Services, arguments: A): ExitCode {
-        val performanceManager = createPerformanceManager(arguments, services)
+        val performanceManager = createPerformanceManager(arguments)
         if (arguments.reportPerf || arguments.dumpPerf != null) {
             performanceManager.enableCollectingPerformanceStatistics()
         }

compiler/cli/src/org/jetbrains/kotlin/cli/common/CommonCompilerPerformanceManager.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.cli.common
 
 import org.jetbrains.kotlin.util.PerformanceCounter
 import java.io.File
-import java.lang.management.GarbageCollectorMXBean
 import java.lang.management.ManagementFactory
 import java.util.concurrent.TimeUnit
 
@@ -19,21 +18,13 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
     private var analysisStart: Long = 0
     private var generationStart: Long = 0
 
-    private var startGCData = mutableMapOf<String, GCData>()
-
-    private var irTranslationStart: Long = 0
-    private var irGenerationStart: Long = 0
-
     fun getMeasurementResults(): List<PerformanceMeasurement> = measurements
 
     fun enableCollectingPerformanceStatistics() {
         isEnabled = true
         PerformanceCounter.setTimeCounterEnabled(true)
-        ManagementFactory.getGarbageCollectorMXBeans().associateTo(startGCData) { it.name to GCData(it) }
     }
 
-    private fun deltaTime(start: Long): Long = PerformanceCounter.currentTime() - start
-
     open fun notifyCompilerInitialized() {
         if (!isEnabled) return
         recordInitializationTime()
@@ -59,39 +50,9 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
         generationStart = PerformanceCounter.currentTime()
     }
 
-    open fun notifyGenerationFinished(files: Int, lines: Int, additionalDescription: String) {
+    open fun notifyGenerationFinished(lines: Int, files: Int, additionalDescription: String) {
         val time = PerformanceCounter.currentTime() - generationStart
-        measurements += CodeGenerationMeasurement(files, lines, TimeUnit.NANOSECONDS.toMillis(time), additionalDescription)
-    }
-
-    open fun notifyIRTranslationStarted() {
-        irTranslationStart = PerformanceCounter.currentTime()
-    }
-
-    open fun notifyIRTranslationFinished(files: Int, lines: Int, additionalDescription: String?) {
-        val time = deltaTime(irTranslationStart)
-        measurements += IRMeasurement(
-            files,
-            lines,
-            TimeUnit.NANOSECONDS.toMillis(time),
-            additionalDescription,
-            IRMeasurement.Kind.Translation
-        )
-    }
-
-    open fun notifyIRGenerationStarted() {
-        irGenerationStart = PerformanceCounter.currentTime()
-    }
-
-    open fun notifyIRGenerationFinished(files: Int, lines: Int, additionalDescription: String) {
-        val time = deltaTime(irGenerationStart)
-        measurements += IRMeasurement(
-            files,
-            lines,
-            TimeUnit.NANOSECONDS.toMillis(time),
-            additionalDescription,
-            IRMeasurement.Kind.Generation
-        )
+        measurements += CodeGenerationMeasurement(lines, files, TimeUnit.NANOSECONDS.toMillis(time), additionalDescription)
     }
 
     fun dumpPerformanceReport(destination: File) {
@@ -102,14 +63,7 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
         if (!isEnabled) return
 
         ManagementFactory.getGarbageCollectorMXBeans().forEach {
-            val startCounts = startGCData[it.name]
-            val startCollectionTime = startCounts?.collectionTime ?: 0
-            val startCollectionCount = startCounts?.collectionCount ?: 0
-            measurements += GarbageCollectionMeasurement(
-                it.name,
-                it.collectionTime - startCollectionTime,
-                it.collectionCount - startCollectionCount
-            )
+            measurements += GarbageCollectionMeasurement(it.name, it.collectionTime)
         }
     }
 
@@ -135,8 +89,4 @@ abstract class CommonCompilerPerformanceManager(private val presentableName: Str
     }.toByteArray()
 
     open fun notifyRepeat(total: Int, number: Int) {}
-
-    private data class GCData(val name: String, val collectionTime: Long, val collectionCount: Long) {
-        constructor(bean: GarbageCollectorMXBean) : this(bean.name, bean.collectionTime, bean.collectionCount)
-    }
 }

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

@@ -26,7 +26,6 @@ fun <A : CommonCompilerArguments> CompilerConfiguration.setupCommonArguments(
     put(CommonConfigurationKeys.EXPECT_ACTUAL_LINKER, arguments.expectActualLinker)
     putIfNotNull(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, arguments.intellijPluginRoot)
     put(CommonConfigurationKeys.REPORT_OUTPUT_FILES, arguments.reportOutputFiles)
-    put(CommonConfigurationKeys.DESERIALIZE_FAKE_OVERRIDES, arguments.deserializeFakeOverrides)
 
     val metadataVersionString = arguments.metadataVersion
     if (metadataVersionString != null) {

compiler/cli/src/org/jetbrains/kotlin/cli/common/performanceMeasurements.kt

@@ -20,13 +20,13 @@ class CompilerInitializationMeasurement(private val milliseconds: Long) : Perfor
 }
 
 
-class CodeAnalysisMeasurement(val files: Int, val lines: Int, val milliseconds: Long, private val description: String?) :
+class CodeAnalysisMeasurement(private val files: Int, val lines: Int, private val milliseconds: Long, private val description: String?) :
     PerformanceMeasurement {
 
-    val lps: Double = lines.toDouble() * 1000 / milliseconds
+    private val speed: Double = lines.toDouble() * 1000 / milliseconds
 
     override fun render(): String =
-        "ANALYZE: $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(lps)} loc/s"
+        "ANALYZE: $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(speed)} loc/s"
 }
 
 
@@ -40,23 +40,11 @@ class CodeGenerationMeasurement(private val files: Int, val lines: Int, private
 }
 
 
-class GarbageCollectionMeasurement(val garbageCollectionKind: String, val milliseconds: Long, val count: Long) : PerformanceMeasurement {
-    override fun render(): String = "GC time for $garbageCollectionKind is $milliseconds ms, $count collections"
+class GarbageCollectionMeasurement(private val garbageCollectionKind: String, private val milliseconds: Long) : PerformanceMeasurement {
+    override fun render(): String = "GC time for $garbageCollectionKind is $milliseconds ms"
 }
 
 
 class PerformanceCounterMeasurement(private val counterReport: String) : PerformanceMeasurement {
     override fun render(): String = counterReport
 }
-
-class IRMeasurement(val files: Int, val lines: Int, val milliseconds: Long, private val description: String?, val kind: Kind) :
-    PerformanceMeasurement {
-
-    val lps: Double = lines.toDouble() * 1000 / milliseconds
-    override fun render(): String =
-        "IR: $kind $files files ($lines lines) ${description ?: ""}in $milliseconds ms - ${"%.3f".format(lps)} loc/s"
-
-    enum class Kind {
-        Generation, Translation
-    }
-}

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

@@ -267,9 +267,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
     override val performanceManager: CommonCompilerPerformanceManager
         get() = error("Unsupported")
 
-    override fun createPerformanceManager(arguments: K2JVMCompilerArguments, services: Services): CommonCompilerPerformanceManager {
-        val externalManager = services[CommonCompilerPerformanceManager::class.java]
-        if (externalManager != null) return externalManager
+    override fun createPerformanceManager(arguments: K2JVMCompilerArguments): CommonCompilerPerformanceManager {
         val argument = arguments.profileCompilerCommand ?: return K2JVMCompilerPerformanceManager()
         return ProfilingCompilerPerformanceManager.create(argument)
     }

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

@@ -4,52 +4,147 @@
  */
 package org.jetbrains.kotlin.cli.jvm.compiler;
 
-import com.intellij.DynamicBundle;
 import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.JavaContainerProvider;
+import com.intellij.codeInsight.folding.JavaCodeFoldingSettings;
+import com.intellij.codeInsight.folding.impl.JavaCodeFoldingSettingsBase;
+import com.intellij.codeInsight.folding.impl.JavaFoldingBuilderBase;
 import com.intellij.codeInsight.runner.JavaMainMethodProvider;
-import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.core.CoreApplicationEnvironment;
+import com.intellij.core.CoreJavaDirectoryService;
+import com.intellij.core.CorePsiPackageImplementationHelper;
+import com.intellij.ide.highlighter.ArchiveFileType;
+import com.intellij.ide.highlighter.JavaClassFileType;
+import com.intellij.ide.highlighter.JavaFileType;
+import com.intellij.lang.LanguageASTFactory;
 import com.intellij.lang.MetaLanguage;
+import com.intellij.lang.folding.LanguageFolding;
+import com.intellij.lang.java.JavaLanguage;
+import com.intellij.lang.java.JavaParserDefinition;
+import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.extensions.ExtensionsArea;
+import com.intellij.openapi.fileTypes.FileTypeExtensionPoint;
+import com.intellij.openapi.fileTypes.PlainTextFileType;
+import com.intellij.openapi.fileTypes.PlainTextLanguage;
+import com.intellij.openapi.fileTypes.PlainTextParserDefinition;
+import com.intellij.openapi.projectRoots.JavaVersionService;
 import com.intellij.openapi.vfs.VirtualFileSystem;
-import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.*;
 import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.augment.TypeAnnotationModifier;
 import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.impl.LanguageConstantExpressionEvaluator;
+import com.intellij.psi.impl.PsiExpressionEvaluator;
+import com.intellij.psi.impl.PsiSubstitutorFactoryImpl;
+import com.intellij.psi.impl.compiled.ClassFileStubBuilder;
+import com.intellij.psi.impl.file.PsiPackageImplementationHelper;
+import com.intellij.psi.impl.search.MethodSuperSearcher;
+import com.intellij.psi.impl.source.tree.JavaASTFactory;
+import com.intellij.psi.impl.source.tree.PlainTextASTFactory;
 import com.intellij.psi.meta.MetaDataContributor;
+import com.intellij.psi.presentation.java.*;
+import com.intellij.psi.search.searches.SuperMethodsSearch;
+import com.intellij.psi.stubs.BinaryFileStubBuilders;
+import com.intellij.util.QueryExecutor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
 
-public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
-    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
-        registerExtensionPoints();
-        return environment;
-    }
+/**
+ * adapted from com.intellij.core.JavaCoreApplicationEnvironment
+ * TODO: initiate removal original from com.intellij.core since it seems that there are no usages left
+ */
+public class KotlinCoreApplicationEnvironment extends CoreApplicationEnvironment {
 
-    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-        super(parentDisposable, unitTestMode);
-    }
+  public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+  }
 
-    private static void registerExtensionPoints() {
-        registerApplicationExtensionPoint(DynamicBundle.LanguageBundleEP.EP_NAME, DynamicBundle.LanguageBundleEP.class);
-        registerApplicationExtensionPoint(FileContextProvider.EP_NAME, FileContextProvider.class);
+  private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+    super(parentDisposable, unitTestMode);
 
-        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
-        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
-        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+    registerExtensionPoints();
 
-        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
-        registerApplicationExtensionPoint(ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
+    registerExtensions();
+  }
 
-        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
+  private void registerExtensionPoints() {
+    ExtensionsArea area = Extensions.getRootArea();
 
-        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
-    }
+    CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider.class);
 
-    @Nullable
-    @Override
-    protected VirtualFileSystem createJrtFileSystem() {
-        return new CoreJrtFileSystem();
-    }
+    CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
+
+    CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier.class);
+    CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage.class);
+
+    IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(area);
+  }
+
+  private void registerExtensions() {
+    registerFileType(JavaClassFileType.INSTANCE, "class");
+    registerFileType(JavaFileType.INSTANCE, "java");
+    registerFileType(ArchiveFileType.INSTANCE, "jar;zip");
+    registerFileType(PlainTextFileType.INSTANCE, "txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");
+
+    addExplicitExtension(LanguageASTFactory.INSTANCE, PlainTextLanguage.INSTANCE, new PlainTextASTFactory());
+    registerParserDefinition(new PlainTextParserDefinition());
+
+    addExplicitExtension(FileTypeFileViewProviders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileViewProviderFactory());
+    addExplicitExtension(BinaryFileStubBuilders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileStubBuilder());
+
+    addExplicitExtension(LanguageASTFactory.INSTANCE, JavaLanguage.INSTANCE, new JavaASTFactory());
+    registerParserDefinition(new JavaParserDefinition());
+    addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE, JavaLanguage.INSTANCE, new PsiExpressionEvaluator());
+
+    addExtension(ContainerProvider.EP_NAME, new JavaContainerProvider());
+
+    myApplication.registerService(PsiPackageImplementationHelper.class, new CorePsiPackageImplementationHelper());
+    myApplication.registerService(PsiSubstitutorFactory.class, new PsiSubstitutorFactoryImpl());
+
+    myApplication.registerService(JavaDirectoryService.class, createJavaDirectoryService());
+    myApplication.registerService(JavaVersionService.class, new JavaVersionService());
+
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiPackage.class, new PackagePresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiClass.class, new ClassPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiMethod.class, new MethodPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiField.class, new FieldPresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiLocalVariable.class, new VariablePresentationProvider());
+    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiParameter.class, new VariablePresentationProvider());
+
+    registerApplicationService(JavaCodeFoldingSettings.class, new JavaCodeFoldingSettingsBase());
+    addExplicitExtension(LanguageFolding.INSTANCE, JavaLanguage.INSTANCE, new JavaFoldingBuilderBase() {
+      @Override
+      protected boolean shouldShowExplicitLambdaType(@NotNull PsiAnonymousClass anonymousClass, @NotNull PsiNewExpression expression) {
+        return false;
+      }
+
+      @Override
+      protected boolean isBelowRightMargin(@NotNull PsiFile file, int lineLength) {
+        return false;
+      }
+    });
+
+    registerApplicationExtensionPoint(SuperMethodsSearch.EP_NAME, QueryExecutor.class);
+    addExtension(SuperMethodsSearch.EP_NAME, new MethodSuperSearcher());
+  }
+
+  // overridden in upsource
+  protected CoreJavaDirectoryService createJavaDirectoryService() {
+    return new CoreJavaDirectoryService();
+  }
+
+  @Nullable
+  @Override
+  protected VirtualFileSystem createJrtFileSystem() {
+    return new CoreJrtFileSystem();
+  }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java.193

@@ -1,150 +0,0 @@
-/*
- * Copyright 2010-2019 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.codeInsight.ContainerProvider;
-import com.intellij.codeInsight.JavaContainerProvider;
-import com.intellij.codeInsight.folding.JavaCodeFoldingSettings;
-import com.intellij.codeInsight.folding.impl.JavaCodeFoldingSettingsBase;
-import com.intellij.codeInsight.folding.impl.JavaFoldingBuilderBase;
-import com.intellij.codeInsight.runner.JavaMainMethodProvider;
-import com.intellij.core.CoreApplicationEnvironment;
-import com.intellij.core.CoreJavaDirectoryService;
-import com.intellij.core.CorePsiPackageImplementationHelper;
-import com.intellij.ide.highlighter.ArchiveFileType;
-import com.intellij.ide.highlighter.JavaClassFileType;
-import com.intellij.ide.highlighter.JavaFileType;
-import com.intellij.lang.LanguageASTFactory;
-import com.intellij.lang.MetaLanguage;
-import com.intellij.lang.folding.LanguageFolding;
-import com.intellij.lang.java.JavaLanguage;
-import com.intellij.lang.java.JavaParserDefinition;
-import com.intellij.navigation.ItemPresentationProviders;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.extensions.ExtensionsArea;
-import com.intellij.openapi.fileTypes.FileTypeExtensionPoint;
-import com.intellij.openapi.fileTypes.PlainTextFileType;
-import com.intellij.openapi.fileTypes.PlainTextLanguage;
-import com.intellij.openapi.fileTypes.PlainTextParserDefinition;
-import com.intellij.openapi.projectRoots.JavaVersionService;
-import com.intellij.openapi.vfs.VirtualFileSystem;
-import com.intellij.psi.*;
-import com.intellij.psi.augment.PsiAugmentProvider;
-import com.intellij.psi.augment.TypeAnnotationModifier;
-import com.intellij.psi.compiled.ClassFileDecompilers;
-import com.intellij.psi.impl.LanguageConstantExpressionEvaluator;
-import com.intellij.psi.impl.PsiExpressionEvaluator;
-import com.intellij.psi.impl.PsiSubstitutorFactoryImpl;
-import com.intellij.psi.impl.compiled.ClassFileStubBuilder;
-import com.intellij.psi.impl.file.PsiPackageImplementationHelper;
-import com.intellij.psi.impl.search.MethodSuperSearcher;
-import com.intellij.psi.impl.source.tree.JavaASTFactory;
-import com.intellij.psi.impl.source.tree.PlainTextASTFactory;
-import com.intellij.psi.meta.MetaDataContributor;
-import com.intellij.psi.presentation.java.*;
-import com.intellij.psi.search.searches.SuperMethodsSearch;
-import com.intellij.psi.stubs.BinaryFileStubBuilders;
-import com.intellij.util.QueryExecutor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
-
-/**
- * adapted from com.intellij.core.JavaCoreApplicationEnvironment
- * TODO: initiate removal original from com.intellij.core since it seems that there are no usages left
- */
-public class KotlinCoreApplicationEnvironment extends CoreApplicationEnvironment {
-
-  public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-    return new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
-  }
-
-  private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
-    super(parentDisposable, unitTestMode);
-
-    registerExtensionPoints();
-
-    registerExtensions();
-  }
-
-  private void registerExtensionPoints() {
-    ExtensionsArea area = Extensions.getRootArea();
-
-    CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider.class);
-
-    CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
-
-    CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
-
-    CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier.class);
-    CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage.class);
-
-    IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(area);
-  }
-
-  private void registerExtensions() {
-    registerFileType(JavaClassFileType.INSTANCE, "class");
-    registerFileType(JavaFileType.INSTANCE, "java");
-    registerFileType(ArchiveFileType.INSTANCE, "jar;zip");
-    registerFileType(PlainTextFileType.INSTANCE, "txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");
-
-    addExplicitExtension(LanguageASTFactory.INSTANCE, PlainTextLanguage.INSTANCE, new PlainTextASTFactory());
-    registerParserDefinition(new PlainTextParserDefinition());
-
-    addExplicitExtension(FileTypeFileViewProviders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileViewProviderFactory());
-    addExplicitExtension(BinaryFileStubBuilders.INSTANCE, JavaClassFileType.INSTANCE, new ClassFileStubBuilder());
-
-    addExplicitExtension(LanguageASTFactory.INSTANCE, JavaLanguage.INSTANCE, new JavaASTFactory());
-    registerParserDefinition(new JavaParserDefinition());
-    addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE, JavaLanguage.INSTANCE, new PsiExpressionEvaluator());
-
-    addExtension(ContainerProvider.EP_NAME, new JavaContainerProvider());
-
-    myApplication.registerService(PsiPackageImplementationHelper.class, new CorePsiPackageImplementationHelper());
-    myApplication.registerService(PsiSubstitutorFactory.class, new PsiSubstitutorFactoryImpl());
-
-    myApplication.registerService(JavaDirectoryService.class, createJavaDirectoryService());
-    myApplication.registerService(JavaVersionService.class, new JavaVersionService());
-
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiPackage.class, new PackagePresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiClass.class, new ClassPresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiMethod.class, new MethodPresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiField.class, new FieldPresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiLocalVariable.class, new VariablePresentationProvider());
-    addExplicitExtension(ItemPresentationProviders.INSTANCE, PsiParameter.class, new VariablePresentationProvider());
-
-    registerApplicationService(JavaCodeFoldingSettings.class, new JavaCodeFoldingSettingsBase());
-    addExplicitExtension(LanguageFolding.INSTANCE, JavaLanguage.INSTANCE, new JavaFoldingBuilderBase() {
-      @Override
-      protected boolean shouldShowExplicitLambdaType(@NotNull PsiAnonymousClass anonymousClass, @NotNull PsiNewExpression expression) {
-        return false;
-      }
-
-      @Override
-      protected boolean isBelowRightMargin(@NotNull PsiFile file, int lineLength) {
-        return false;
-      }
-    });
-
-    registerApplicationExtensionPoint(SuperMethodsSearch.EP_NAME, QueryExecutor.class);
-    addExtension(SuperMethodsSearch.EP_NAME, new MethodSuperSearcher());
-  }
-
-  // overridden in upsource
-  protected CoreJavaDirectoryService createJavaDirectoryService() {
-    return new CoreJavaDirectoryService();
-  }
-
-  @Nullable
-  @Override
-  protected VirtualFileSystem createJrtFileSystem() {
-    return new CoreJrtFileSystem();
-  }
-}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreApplicationEnvironment.java.201

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2019 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;
@@ -40,7 +40,7 @@ public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnviron
         registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
 
         registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
-        registerApplicationExtensionPoint(ClassFileDecompilers.getInstance().EP_NAME, ClassFileDecompilers.Decompiler.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
 
         registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
 

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

@@ -52,12 +52,8 @@ import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.GenerationStateEventCallback
 import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
-import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmClassCodegen
@@ -75,7 +71,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
-import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
 import org.jetbrains.kotlin.modules.Module
@@ -87,7 +82,6 @@ import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
-import org.jetbrains.kotlin.resolve.diagnostics.SimpleDiagnostics
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.utils.newLinkedHashMapWithExpectedSize
@@ -361,28 +355,17 @@ object KotlinToJVMBytecodeCompiler {
             val firProvider = (session.firProvider as FirProviderImpl)
             val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
             val resolveTransformer = FirTotalResolveProcessor(session)
-            val collector = FirDiagnosticsCollector.create(session)
-            val diagnostics = mutableListOf<FirDiagnostic<*>>()
             val firFiles = ktFiles.map {
                 val firFile = builder.buildFirFile(it)
                 firProvider.recordFile(firFile)
                 firFile
-            }.also { firFiles ->
+            }.also {
                 try {
-                    resolveTransformer.process(firFiles)
-                    firFiles.forEach {
-                        diagnostics += collector.collectDiagnostics(it)
-                    }
+                    resolveTransformer.process(it)
                 } catch (e: Exception) {
                     throw e
                 }
             }
-            AnalyzerWithCompilerReport.reportDiagnostics(
-                SimpleDiagnostics(
-                    diagnostics.map { it.toRegularDiagnostic() }
-                ),
-                environment.messageCollector
-            )
 
             val debugTargetDescription = "target " + module.getModuleName() + "-" + module.getModuleType() + " "
             val codeLines = environment.countLinesOfCode(ktFiles)
@@ -391,16 +374,13 @@ object KotlinToJVMBytecodeCompiler {
             performanceManager?.notifyGenerationStarted()
             val signaturer = IdSignatureDescriptor(JvmManglerDesc())
 
-            performanceManager?.notifyIRTranslationStarted()
             val (moduleFragment, symbolTable, sourceManager, components) =
                 Fir2IrConverter.createModuleFragment(
                     session, resolveTransformer.scopeSession, firFiles,
-                    moduleConfiguration.languageVersionSettings, signaturer,
-                    JvmGeneratorExtensions(), FirJvmKotlinMangler(session), IrFactoryImpl
+                    moduleConfiguration.languageVersionSettings, signaturer = signaturer,
+                    generatorExtensions = JvmGeneratorExtensions(),
+                    mangler = FirJvmKotlinMangler(session)
                 )
-
-            performanceManager?.notifyIRTranslationFinished(ktFiles.size, codeLines, debugTargetDescription)
-
             val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext
 
             val codegenFactory = JvmIrCodegenFactory(moduleConfiguration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases))
@@ -422,7 +402,7 @@ object KotlinToJVMBytecodeCompiler {
 
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 
-            performanceManager?.notifyIRGenerationStarted()
+
             generationState.beforeCompile()
             codegenFactory.generateModuleInFrontendIRMode(
                 generationState, moduleFragment, symbolTable, sourceManager
@@ -451,37 +431,12 @@ object KotlinToJVMBytecodeCompiler {
                 generationState.extraJvmDiagnosticsTrace.bindingContext, environment.messageCollector
             )
 
-            performanceManager?.notifyIRGenerationFinished(ktFiles.size, codeLines, additionalDescription = debugTargetDescription)
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
             outputs[module] = generationState
         }
         return writeOutputs(environment, projectConfiguration, chunk, outputs)
     }
 
-    private fun FirDiagnostic<*>.toRegularDiagnostic(): Diagnostic {
-        val psiSource = element as FirPsiSourceElement<*>
-        @Suppress("TYPE_MISMATCH")
-        when (this) {
-            is FirSimpleDiagnostic ->
-                return SimpleDiagnostic(
-                    psiSource.psi, factory.psiDiagnosticFactory, severity
-                )
-            is FirDiagnosticWithParameters1<*, *> ->
-                return DiagnosticWithParameters1(
-                    psiSource.psi, this.a, factory.psiDiagnosticFactory, severity
-                )
-            is FirDiagnosticWithParameters2<*, *, *> ->
-                return DiagnosticWithParameters2(
-                    psiSource.psi, this.a, this.b, factory.psiDiagnosticFactory, severity
-                )
-            is FirDiagnosticWithParameters3<*, *, *, *> ->
-                return DiagnosticWithParameters3(
-                    psiSource.psi, this.a, this.b, this.c, factory.psiDiagnosticFactory, severity
-                )
-        }
-        throw IllegalArgumentException("Unknown diagnostics: $this")
-    }
-
     private fun getBuildFilePaths(buildFile: File?, sourceFilePaths: List<String>): List<String> =
         if (buildFile == null) sourceFilePaths
         else sourceFilePaths.map { path ->

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

@@ -22,7 +22,6 @@ import com.intellij.psi.*
 
 class MockExternalAnnotationsManager : ExternalAnnotationsManager() {
     override fun chooseAnnotationsPlace(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
-    override fun chooseAnnotationsPlaceNoUi(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
 
     override fun isExternalAnnotationWritable(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean = false
     override fun isExternalAnnotation(annotation: PsiAnnotation): Boolean = false

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

@@ -22,6 +22,7 @@ import com.intellij.psi.*
 
 class MockExternalAnnotationsManager : ExternalAnnotationsManager() {
     override fun chooseAnnotationsPlace(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
+    override fun chooseAnnotationsPlaceNoUi(element: PsiElement): AnnotationPlace = AnnotationPlace.NOWHERE
 
     override fun isExternalAnnotationWritable(listOwner: PsiModifierListOwner, annotationFQN: String): Boolean = false
     override fun isExternalAnnotation(annotation: PsiAnnotation): Boolean = false

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

@@ -66,7 +66,6 @@ import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.calls.tower.ImplicitsExtensionsResolutionFilter
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
@@ -136,8 +135,7 @@ object TopDownAnalyzerFacadeForJVM {
         declarationProviderFactory: (StorageManager, Collection<KtFile>) -> DeclarationProviderFactory,
         targetEnvironment: TargetEnvironment = CompilerEnvironment,
         sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files),
-        klibList: List<KotlinLibrary> = emptyList(),
-        implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null
+        klibList: List<KotlinLibrary> = emptyList()
     ): ComponentProvider {
         val jvmTarget = configuration.get(JVMConfigurationKeys.JVM_TARGET, JvmTarget.DEFAULT)
         val languageVersionSettings = configuration.languageVersionSettings
@@ -188,8 +186,7 @@ object TopDownAnalyzerFacadeForJVM {
                 targetEnvironment, lookupTracker, expectActualTracker,
                 packagePartProvider(dependencyScope), languageVersionSettings,
                 useBuiltInsProvider = true,
-                configureJavaClassFinder = configureJavaClassFinder,
-                implicitsResolutionFilter = implicitsResolutionFilter
+                configureJavaClassFinder = configureJavaClassFinder
             )
 
             moduleClassResolver.compiledCodeResolver = dependenciesContainer.get()
@@ -223,8 +220,7 @@ object TopDownAnalyzerFacadeForJVM {
             partProvider, languageVersionSettings,
             useBuiltInsProvider = true,
             configureJavaClassFinder = configureJavaClassFinder,
-            javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER],
-            implicitsResolutionFilter = implicitsResolutionFilter
+            javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER]
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get()

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

@@ -6,10 +6,4 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 fun setupIdeaStandaloneExecution() {
-    System.getProperties().setProperty("idea.plugins.compatible.build", "201.6668.13")
-    System.getProperties().setProperty("project.structure.add.tools.jar.to.new.jdk", "false")
-    System.getProperties().setProperty("psi.track.invalidation", "true")
-    System.getProperties().setProperty("psi.incremental.reparse.depth.limit", "1000")
-    System.getProperties().setProperty("ide.hide.excluded.files", "false")
-    System.getProperties().setProperty("ast.loading.filter", "false")
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/compat.kt.193

@@ -1,9 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler
-
-fun setupIdeaStandaloneExecution() {
-}

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

@@ -12,6 +12,4 @@ fun setupIdeaStandaloneExecution() {
     System.getProperties().setProperty("psi.incremental.reparse.depth.limit", "1000")
     System.getProperties().setProperty("ide.hide.excluded.files", "false")
     System.getProperties().setProperty("ast.loading.filter", "false")
-    System.getProperties().setProperty("idea.ignore.disabled.plugins", "true")
-    System.getProperties().setProperty("idea.home.path", System.getProperty("java.io.tmpdir"))
 }

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

@@ -8,11 +8,9 @@ package org.jetbrains.kotlin.cli.jvm.compiler
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.openapi.extensions.ExtensionsArea
 import java.io.File
-import java.nio.file.FileSystems
 
 // FIX ME WHEN BUNCH 193 REMOVED
 fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
-    val pluginRoot = FileSystems.getDefault().getPath(pluginFile.path)
     @Suppress("MissingRecentApi")
-    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, fileName, area)
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
 }

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

@@ -8,9 +8,11 @@ package org.jetbrains.kotlin.cli.jvm.compiler
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.openapi.extensions.ExtensionsArea
 import java.io.File
+import java.nio.file.FileSystems
 
 // FIX ME WHEN BUNCH 193 REMOVED
 fun registerExtensionPointAndExtensionsEx(pluginFile: File, fileName: String, area: ExtensionsArea) {
+    val pluginRoot = FileSystems.getDefault().getPath(pluginFile.path)
     @Suppress("MissingRecentApi")
-    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginFile, fileName, area)
+    CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, fileName, area)
 }

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

@@ -38,17 +38,6 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
         }
     }
 
-    val jvmTarget = get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT
-    if (jvmTarget.bytecodeVersion < JvmTarget.JVM_1_8.bytecodeVersion) {
-        val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)
-        if (jvmDefaultMode.forAllMethodsWithBody) {
-            messageCollector.report(
-                ERROR,
-                "'-Xjvm-default=${jvmDefaultMode.description}' is only supported since JVM target 1.8. Recompile with '-jvm-target 1.8'"
-            )
-        }
-    }
-
     addAll(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES, arguments.additionalJavaModules?.asList())
 }
 
@@ -209,7 +198,6 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
 
     put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
     put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
-    put(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS, arguments.useOldSpilledVarTypeAnalysis)
 
     arguments.declarationsOutputPath?.let { put(JVMConfigurationKeys.DECLARATIONS_JSON_PATH, it) }
 }

compiler/compiler.version/src/org/jetbrains/kotlin/config/KotlinCompilerVersion.java

@@ -19,7 +19,7 @@ public class KotlinCompilerVersion {
     // Binaries produced by this compiler with that language version (or any future language version) are going to be marked
     // as "pre-release" and will not be loaded by release versions of the compiler.
     // Change this value before and after every major release
-    private static final boolean IS_PRE_RELEASE = false;
+    private static final boolean IS_PRE_RELEASE = true;
 
     public static final String TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY = "kotlin.test.is.pre.release";
 

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

@@ -122,7 +122,4 @@ public class JVMConfigurationKeys {
 
     public static final CompilerConfigurationKey<Boolean> NO_KOTLIN_NOTHING_VALUE_EXCEPTION =
             CompilerConfigurationKey.create("Do not use KotlinNothingValueException available since 1.4");
-
-    public static final CompilerConfigurationKey<Boolean> USE_OLD_SPILLED_VAR_TYPE_ANALYSIS =
-            CompilerConfigurationKey.create("Use old, SourceInterpreter-based analysis for fields, used for spilled variables in coroutines");
 }

compiler/config/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.kt

@@ -47,9 +47,6 @@ object CommonConfigurationKeys {
 
     @JvmField
     val EXPECT_ACTUAL_LINKER = CompilerConfigurationKey.create<Boolean>("Experimental expext/actual linker")
-
-    @JvmField
-    val DESERIALIZE_FAKE_OVERRIDES = CompilerConfigurationKey.create<Boolean>("Deserialize fake overrides")
 }
 
 var CompilerConfiguration.languageVersionSettings: LanguageVersionSettings