JavaClassifierTypeImpl.resolutionResult dropped

.bunch

@@ -1,7 +1,7 @@
-201
-202
-203_202
 193
-as40_193
-as41
-as42_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

.gitignore

@@ -59,6 +59,3 @@ node_modules/
 .rpt2_cache/
 libraries/tools/kotlin-test-js-runner/lib/
 local.properties
-buildSrcTmp/
-distTmp/
-outTmp/

.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/dictionaries/yan.xml

@@ -10,10 +10,7 @@
       <w>kapt</w>
       <w>kotlinc</w>
       <w>mutators</w>
-      <w>parcelable</w>
       <w>parceler</w>
-      <w>parcelers</w>
-      <w>parcelize</w>
       <w>repl</w>
       <w>testdata</w>
       <w>uast</w>

.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,862 +1,5 @@
 # CHANGELOG
 
-## 1.4.10
-
-### Compiler
-
-#### Performance Improvements
-
-- [`KT-41149`](https://youtrack.jetbrains.com/issue/KT-41149) NI: Upgraded project from 1.3.72 to 1.4.0 hangs during build
-- [`KT-41335`](https://youtrack.jetbrains.com/issue/KT-41335) Kotlin Out of Memory When evaluating expression
-- [`KT-41400`](https://youtrack.jetbrains.com/issue/KT-41400) NI: Huge performance regression for kotlin compiler from 1.3.72 to 1.4.0 due to using list of dozen lambdas in a call
-
-#### Fixes
-
-- [`KT-41005`](https://youtrack.jetbrains.com/issue/KT-41005) Coercion to Unit doesn't take into account nullability of a return type for lambda
-- [`KT-41043`](https://youtrack.jetbrains.com/issue/KT-41043) NI: StackOverflowError through `PostponedArgumentInputTypesResolver.getAllDeeplyRelatedTypeVariables`
-- [`KT-41135`](https://youtrack.jetbrains.com/issue/KT-41135) Type Inference Regression For Property Delegate With Receiver Type
-- [`KT-41140`](https://youtrack.jetbrains.com/issue/KT-41140) Unresolved reference to parameter of a catch block from lambda expression on 1.4.0
-- [`KT-41150`](https://youtrack.jetbrains.com/issue/KT-41150) IllegalStateException: Couldn't obtain compiled function body for public final inline fun
-- [`KT-41164`](https://youtrack.jetbrains.com/issue/KT-41164) NI: "IllegalStateException: Error type encountered" with callbackFlow builder inside condition
-- [`KT-41202`](https://youtrack.jetbrains.com/issue/KT-41202) Type inference fails in 1.4.0
-- [`KT-41218`](https://youtrack.jetbrains.com/issue/KT-41218) HMPP: arrayList declarations are visible both from stdlib-common and stdlib-jvm and lead to false-positive resolution ambiguity in IDE
-- [`KT-41308`](https://youtrack.jetbrains.com/issue/KT-41308) 1.4.0 Type inference regression in suspend blocks with elvis operator expressions
-- [`KT-41357`](https://youtrack.jetbrains.com/issue/KT-41357) ClassCastException for unstable smart cast on a property call receiver
-- [`KT-41386`](https://youtrack.jetbrains.com/issue/KT-41386) NI: Type mismatch with generic type parameters
-- [`KT-41426`](https://youtrack.jetbrains.com/issue/KT-41426) Operator compareTo is not called with nullable type
-- [`KT-41430`](https://youtrack.jetbrains.com/issue/KT-41430) Broken choosing overload by lambda return type inside builder inference
-- [`KT-41470`](https://youtrack.jetbrains.com/issue/KT-41470) Wrong nullability assertion is generated when using the BuilderInference annotation
-- [`KT-41482`](https://youtrack.jetbrains.com/issue/KT-41482) Add a fallback compiler flag to disable the unified null checks behavior
-
-### IDE
-
-- [`KT-41325`](https://youtrack.jetbrains.com/issue/KT-41325) SOE in IDEKotlinAsJavaSupport
-- [`KT-41390`](https://youtrack.jetbrains.com/issue/KT-41390) Typo: equals & hashCode are written with the first uppercase letter
-
-### IDE. Code Style, Formatting
-
-- [`KT-41314`](https://youtrack.jetbrains.com/issue/KT-41314) Formatter: Frequent freezes when reformatting code (TrailingCommaPostFormatProcessor)
-
-### IDE. Debugger
-
-- [`KT-40417`](https://youtrack.jetbrains.com/issue/KT-40417) Coroutines Debugger: “No coroutine information found” in case of main() entry-point without explicit debug-artifact
-
-### IDE. Gradle. Script
-
-- [`KT-39542`](https://youtrack.jetbrains.com/issue/KT-39542) EA-218043: java.util.NoSuchElementException: No element of given type found (GradleBuildRootsManager)
-- [`KT-41283`](https://youtrack.jetbrains.com/issue/KT-41283) Gradle scripts unable to support 1.4 language level features yet
-
-### IDE. Inspections and Intentions
-
-- [`KT-41264`](https://youtrack.jetbrains.com/issue/KT-41264) Disable “Redundant inner modifier” in 1.4.10
-- [`KT-41395`](https://youtrack.jetbrains.com/issue/KT-41395) Inspection description misses a space (needs to be lowercase)
-
-### IDE. REPL
-
-- [`KT-40898`](https://youtrack.jetbrains.com/issue/KT-40898) REPL: "IllegalAccessError: tried to access field" caused by log4j
-
-### IDE. Wizards
-
-- [`KT-38921`](https://youtrack.jetbrains.com/issue/KT-38921) New project wizard: Backend/Console applications template with Groovy DSL generates build.gradle with KotlinCompile instead of compileKotlin
-
-### JavaScript
-
-- [`KT-38059`](https://youtrack.jetbrains.com/issue/KT-38059) Support arrays passed as named arguments to varargs
-- [`KT-40964`](https://youtrack.jetbrains.com/issue/KT-40964) KJS / IR: don't generate "import" (short names) for external interfaces
-- [`KT-41081`](https://youtrack.jetbrains.com/issue/KT-41081) KJS IR: nativeGetter, nativeSetter, nativeInvoke are not supported
-
-### Libraries
-
-- [`KT-41320`](https://youtrack.jetbrains.com/issue/KT-41320) Actual  kotlin.test annotation typealiases are inaccessible in modular environment
-
-### Middle-end. IR
-
-- [`KT-41324`](https://youtrack.jetbrains.com/issue/KT-41324) IR: "Compilation failed: null" caused by StackOverflowError in compiler in multi-module project
-
-### Native. C and ObjC Import
-
-- [`KT-39762`](https://youtrack.jetbrains.com/issue/KT-39762) cinterop on 1.4-M2 doesn't include @Deprecated Kotlin declaration for C declaration it fails to import
-
-### Native. ObjC Export
-
-- [`KT-39206`](https://youtrack.jetbrains.com/issue/KT-39206) New line characters in @Deprecated annotation cause syntax error in Kotlin/native exported header
-- [`KT-40976`](https://youtrack.jetbrains.com/issue/KT-40976) "Unrecognized selector sent to instance" exception invoking suspending lambda from Swift in Native iOS project
-
-### Reflection
-
-- [`KT-40842`](https://youtrack.jetbrains.com/issue/KT-40842) "AssertionError: Built-in class kotlin.Any is not found" on java modular run
-
-### Tools. Compiler Plugins
-
-- [`KT-41321`](https://youtrack.jetbrains.com/issue/KT-41321) Upgrading to 1.4.0 fails compiling native with <x> is not bound error
-
-### Tools. Gradle. Multiplatform
-
-- [`KT-41083`](https://youtrack.jetbrains.com/issue/KT-41083) Transitive dependency on an MPP with host-specific source sets fails to resolve: "Couldn't resolve metadata artifact..."
-
-### Tools. Gradle. Native
-
-- [`KT-40834`](https://youtrack.jetbrains.com/issue/KT-40834) Cannot build Kotlin Multiplatform project on Windows 10 64-bit when the Cocoapods plugin is applied
-
-### Tools. Scripts
-
-- [`KT-35925`](https://youtrack.jetbrains.com/issue/KT-35925) REPL: Springboot autoconfiguration problem (META-INF/spring.factories not found ?)
-
-### Tools. kapt
-
-- [`KT-41313`](https://youtrack.jetbrains.com/issue/KT-41313) kapt 1.4.0 throws "ZipException: zip END header not found", when Graal SVM jar in classpath
-
-
-## 1.4.0
-
-### Compiler
-
-#### New Features
-
-- [`KT-23729`](https://youtrack.jetbrains.com/issue/KT-23729) Provide a way to generate JVM default method bodies in interfaces delegating to DefaultImpls
-- [`KT-30330`](https://youtrack.jetbrains.com/issue/KT-30330) Introduce KotlinNothingValueException and throw it instead of NPE on expressions of type Nothing
-- [`KT-38435`](https://youtrack.jetbrains.com/issue/KT-38435) Support suspend conversion on callable references in JVM backend
-
-#### Fixes
-
-- [`KT-35483`](https://youtrack.jetbrains.com/issue/KT-35483) NI: compatibility mode
-- [`KT-39728`](https://youtrack.jetbrains.com/issue/KT-39728) Declarations from `kotlin.reflect` resolved to expect-classes even in JVM modules in IDE
-- [`KT-40153`](https://youtrack.jetbrains.com/issue/KT-40153) REPL IDE services completion fails on imports completion
-- [`KT-40404`](https://youtrack.jetbrains.com/issue/KT-40404) Mixed named/positional arguments: argument can be passed twice
-- [`KT-40544`](https://youtrack.jetbrains.com/issue/KT-40544) NI: "TYPE_MISMATCH: Required: MutableList<out T!> Found: List<T>" caused by Java interface function
-- [`KT-40555`](https://youtrack.jetbrains.com/issue/KT-40555) NI: Spread operator allows inferred nullable types
-- [`KT-40646`](https://youtrack.jetbrains.com/issue/KT-40646) NI: TYPE_MISMATCH: "inferred type is Unit but Observer<T> was expected" caused by LieData.observe inference
-- [`KT-40691`](https://youtrack.jetbrains.com/issue/KT-40691) False positive CAPTURED_VAL_INITIALIZATION with EXACTLY_ONCE contract
-- [`KT-40693`](https://youtrack.jetbrains.com/issue/KT-40693) UnsupportedOperationException: no descriptor for type constructor of (CapturedType(out TResult)..CapturedType(out TResult)?)
-- [`KT-40824`](https://youtrack.jetbrains.com/issue/KT-40824) Usages of a typealias lose nullability and annotations in deserialization
-- [`KT-40843`](https://youtrack.jetbrains.com/issue/KT-40843) Unhandled exception for suspending methods that return Result type
-- [`KT-40869`](https://youtrack.jetbrains.com/issue/KT-40869) Recursion computation inside compiler resolve on a correct code
-- [`KT-40893`](https://youtrack.jetbrains.com/issue/KT-40893) Error "Captured values initialization is forbidden due to possible reassignment" when attempting to use the plusAssign operator with a java list inside an inline function
-- [`KT-40919`](https://youtrack.jetbrains.com/issue/KT-40919) kotlin.collections.ArrayDeque requires an explicit import when compiling with kotlinc 1.4-RC and -language-version 1.3
-- [`KT-40920`](https://youtrack.jetbrains.com/issue/KT-40920) Regression in JvmDefault: incorrect access to missing DefaultImpls on default methods in Java interface overriding Kotlin interface
-- [`KT-40978`](https://youtrack.jetbrains.com/issue/KT-40978) Prohibit using suspend functions as SAM in fun interfaces
-
-### Docs & Examples
-
-- [`KT-35218`](https://youtrack.jetbrains.com/issue/KT-35218) Fix misleading in JavaDoc for `createTempDir`/`createTempFile`
-- [`KT-36981`](https://youtrack.jetbrains.com/issue/KT-36981) Provide a visual illustration of source sets structure generated by `ios()`, `watchos()`, `tvos()` presets
-- [`KT-38050`](https://youtrack.jetbrains.com/issue/KT-38050) Language Guide: MPP reference: add sample of language settings for all roots instead of common root only
-
-### IDE
-
-- [`KT-30265`](https://youtrack.jetbrains.com/issue/KT-30265) IDE, MPP: False negative TYPE_PARAMETER_AS_REIFIED in common code
-- [`KT-40494`](https://youtrack.jetbrains.com/issue/KT-40494) UAST: "NoSuchElementException: No element of given type found" with use-site target annotation
-- [`KT-40639`](https://youtrack.jetbrains.com/issue/KT-40639) Shift IDE plugins updater numbers for Kotlin plugin
-
-### IDE. Code Style, Formatting
-
-- [`KT-40636`](https://youtrack.jetbrains.com/issue/KT-40636) Hard freeze on formatter: infinite recursion
-
-### IDE. Gradle Integration
-
-- [`KT-30116`](https://youtrack.jetbrains.com/issue/KT-30116) IDE: Unresolved reference in MPP module (androidMain source set) for annotation from common module (defined in commonMain and with JVM target)
-
-### IDE. Gradle. Script
-
-- [`KT-34552`](https://youtrack.jetbrains.com/issue/KT-34552) Deadlock in ScriptDefinitionsManager
-- [`KT-40675`](https://youtrack.jetbrains.com/issue/KT-40675) Gradle build file is not highlighted until navigating to symbol
-
-### IDE. JS
-
-- [`KT-40461`](https://youtrack.jetbrains.com/issue/KT-40461) Create new projects with kotlin.js.generate.executable.default=false
-
-### IDE. Script
-
-- [`KT-39547`](https://youtrack.jetbrains.com/issue/KT-39547) Kotlin script support freezes IDEA
-- [`KT-40242`](https://youtrack.jetbrains.com/issue/KT-40242) gradle.kts: Deadlock in ScriptClassRootsUpdater
-
-### IDE. Wizards
-
-- [`KT-36153`](https://youtrack.jetbrains.com/issue/KT-36153) New Project Wizard: provide more referential info on project structure editor screen
-- [`KT-39904`](https://youtrack.jetbrains.com/issue/KT-39904) New Project wizard 1.4: update Frontend Application to make it run with JS IR
-- [`KT-40149`](https://youtrack.jetbrains.com/issue/KT-40149) Gradle project wizard: templates for Kotlin/JS are not properly formatted
-
-### JavaScript
-
-- [`KT-25859`](https://youtrack.jetbrains.com/issue/KT-25859) JS: support function references to functions with vararg if expected type ends with repeated vararg element type
-- [`KT-40083`](https://youtrack.jetbrains.com/issue/KT-40083) K/JS-IR: java.lang.IllegalStateException: has not acquired a symbol yet
-- [`KT-40892`](https://youtrack.jetbrains.com/issue/KT-40892) KJS, IR: Unresolved references on importing classes from kotlinx-nodejs
-
-### Libraries
-
-- [`KT-39051`](https://youtrack.jetbrains.com/issue/KT-39051) Libraries native artifacts are published without sources
-
-### Tools. Gradle
-
-- [`KT-27816`](https://youtrack.jetbrains.com/issue/KT-27816) Provide a possibility to specify intermediate source sets between platform-agnostic and platform-specific test source sets
-- [`KT-37720`](https://youtrack.jetbrains.com/issue/KT-37720) Replace ArtifactTransform with TransformAction
-- [`KT-40559`](https://youtrack.jetbrains.com/issue/KT-40559) Adding the stdlib by default triggers warning in the Android Gradle Plugin
-
-### Tools. Gradle. JS
-
-- [`KT-40093`](https://youtrack.jetbrains.com/issue/KT-40093) Incorrect updating version of Kotlin/JS dependencies in package.json
-
-### Tools. Gradle. Multiplatform
-
-- [`KT-27320`](https://youtrack.jetbrains.com/issue/KT-27320) Provide a way to reuse same sources for similar Native target
-- [`KT-40058`](https://youtrack.jetbrains.com/issue/KT-40058) NPE from mpp gradle plugin on kotlinx.benchmarks
-
-### Tools. Gradle. Native
-
-- [`KT-40801`](https://youtrack.jetbrains.com/issue/KT-40801) Gradle CocoaPods integration: Cannot change a framework name
-
-
-## 1.4-RC
-
-### Backend. Native
-
-- [`KT-40209`](https://youtrack.jetbrains.com/issue/KT-40209) java.lang.UnsupportedOperationException: org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl@76484173
-- [`KT-40367`](https://youtrack.jetbrains.com/issue/KT-40367) Kotlin/Native-Swift interop (iOS): Array member initialization failing in release builds
-
-### Compiler
-
-#### Fixes
-
-- [`KT-31025`](https://youtrack.jetbrains.com/issue/KT-31025) Type mismatch when callable reference is resolved with a functional expected type and SAM conversion
-- [`KT-37388`](https://youtrack.jetbrains.com/issue/KT-37388) Consider relaxing rules about inferring Nothing inside special constructions (if, try, when)
-- [`KT-37717`](https://youtrack.jetbrains.com/issue/KT-37717) NI: "IllegalStateException: Error type encountered" with @BuilderInference
-- [`KT-38427`](https://youtrack.jetbrains.com/issue/KT-38427) New inference in branched conditions (if, when) results in odd behavior with inconsistent compiler warnings and runtime errors
-- [`KT-38899`](https://youtrack.jetbrains.com/issue/KT-38899) NI: False positive IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION leads to NPE
-- [`KT-39468`](https://youtrack.jetbrains.com/issue/KT-39468) NI: overload resolution ambiguity between functions passing `T` and `Foo<T>` with a contravariant receiver
-- [`KT-39618`](https://youtrack.jetbrains.com/issue/KT-39618) NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER: unable to infer generic type on @BuilderInference annotated lambda parameter with receiver type
-- [`KT-39633`](https://youtrack.jetbrains.com/issue/KT-39633) NI: Incorrect type parameter instantiation based on contravariant type argument
-- [`KT-39691`](https://youtrack.jetbrains.com/issue/KT-39691) NI: Missing SAM conversion for nullable lambda
-- [`KT-39860`](https://youtrack.jetbrains.com/issue/KT-39860) Make Kotlin binaries publicly available (set KotlinCompilerVersion.IS_PRE_RELEASE = false)
-- [`KT-39900`](https://youtrack.jetbrains.com/issue/KT-39900) NI: Incorrect type inference in a lambda returning Unit
-- [`KT-39925`](https://youtrack.jetbrains.com/issue/KT-39925) New JVM default compilation mode doesn't check that JVM target is 1.8
-- [`KT-39943`](https://youtrack.jetbrains.com/issue/KT-39943) Write information about all-compatibility mode in metadata
-- [`KT-39953`](https://youtrack.jetbrains.com/issue/KT-39953) NI: ClassCastException "cannot be cast to java.lang.Void" with if-else in return statement in ANdroid project
-- [`KT-40045`](https://youtrack.jetbrains.com/issue/KT-40045) NI: lambda’s receiver type isn't inferred properly
-- [`KT-40057`](https://youtrack.jetbrains.com/issue/KT-40057) NI: provideDelegate org.jetbrains.kotlin.codegen.CompilationException: Back-end (JVM) Internal error: wrong bytecode generated for static initializer
-- [`KT-40060`](https://youtrack.jetbrains.com/issue/KT-40060) NI: postponed variable from the builder inference flows to back-end and leads to throw an exception
-- [`KT-40112`](https://youtrack.jetbrains.com/issue/KT-40112) Kotlin Gradle DSL: COMPATIBILITY_WARNING on `kotlin.sourceSets` block
-- [`KT-40113`](https://youtrack.jetbrains.com/issue/KT-40113) Kotlin Gradle DSL: "Expression 'main' cannot be invoked as a function" for `distributions.main` DSL block
-- [`KT-40128`](https://youtrack.jetbrains.com/issue/KT-40128) Introduce compiler key to disable compatibility resolution mechanism for new inference features
-- [`KT-40151`](https://youtrack.jetbrains.com/issue/KT-40151) NI: postponed variable isn't substituted for top-level CR inside builder inference
-- [`KT-40214`](https://youtrack.jetbrains.com/issue/KT-40214) AbstractMethodError in gradle subplugin which is used in Android app
-- [`KT-40234`](https://youtrack.jetbrains.com/issue/KT-40234) Deprecation level "hidden" has no effect on callable reference argument
-- [`KT-40247`](https://youtrack.jetbrains.com/issue/KT-40247) NI: false positive "function should be called from coroutine or another suspend function" for suspend invoke operator in try-catch
-- [`KT-40254`](https://youtrack.jetbrains.com/issue/KT-40254) Rewrite at slice with two callable reference arguments
-- [`KT-40269`](https://youtrack.jetbrains.com/issue/KT-40269) NI: "disabled Unit conversions" error has appeared on green code
-- [`KT-40337`](https://youtrack.jetbrains.com/issue/KT-40337) NI: false positive "function should be called from coroutine or another suspend function" for suspend invoke operator in `when` block
-- [`KT-40406`](https://youtrack.jetbrains.com/issue/KT-40406) Prohibit reflection on adapted callable references
-
-### IDE
-
-- [`KT-39968`](https://youtrack.jetbrains.com/issue/KT-39968) Paths in KotlinJavaRuntime library aren't updated after you run IDE from a different directory
-- [`KT-39989`](https://youtrack.jetbrains.com/issue/KT-39989) NullPointerException when opening Kotlin facets in Project Structure dialog in IDEA 192
-- [`KT-40311`](https://youtrack.jetbrains.com/issue/KT-40311) Create change_notes for 1.4 in IDE plugin description
-
-### IDE. Debugger
-
-- [`KT-39808`](https://youtrack.jetbrains.com/issue/KT-39808) (CoroutineDebugger) Doesn't start with kotlinx-coroutines-core >= 1.3.6
-- [`KT-40073`](https://youtrack.jetbrains.com/issue/KT-40073) (CoroutineDebugger) Change minimum supported kotlinx.coroutines version to 1.3.8*
-- [`KT-40172`](https://youtrack.jetbrains.com/issue/KT-40172) Restored frame variables isn't shown for suspended coroutines
-- [`KT-40635`](https://youtrack.jetbrains.com/issue/KT-40635) Coroutines Debugger: make IDE plugin accept coroutines 1.3.8-rc* versions as well
-
-### IDE. Gradle Integration
-
-- [`KT-38744`](https://youtrack.jetbrains.com/issue/KT-38744) No dependency between Android `test` and commonTest source sets with kotlin.mpp.enableGranularSourceSetsMetadata=true
-- [`KT-39037`](https://youtrack.jetbrains.com/issue/KT-39037) 'None of the consumable configurations have attributes' in MPP IDE import with transitive project dependency on self
-
-### IDE. Gradle. Script
-
-- [`KT-31137`](https://youtrack.jetbrains.com/issue/KT-31137) IntelliJ would get very slow when editing gradle buildSrc(using the kotlin dsl)
-- [`KT-36078`](https://youtrack.jetbrains.com/issue/KT-36078) Gradle Kotlin script context is not reloaded when gradle/wrapper/gradle-wrapper.properties file is changed
-- [`KT-39317`](https://youtrack.jetbrains.com/issue/KT-39317) ISE “Calling invokeAndWait from read-action leads to possible deadlock.” on importing simple Gradle-based project in nightly IJ
-
-### IDE. Inspections and Intentions
-
-- [`KT-28662`](https://youtrack.jetbrains.com/issue/KT-28662) Inspection to flag usage of the wrong Transient annotation on Kotlin Serializable class
-- [`KT-34209`](https://youtrack.jetbrains.com/issue/KT-34209) Switch default behaviour in 1.4 for insertion (to build script) via quick fix of the compiler option enabling inline classes
-- [`KT-36131`](https://youtrack.jetbrains.com/issue/KT-36131) Suggest to add a missing module dependency on an unresolved reference in Kotlin code
-- [`KT-37462`](https://youtrack.jetbrains.com/issue/KT-37462) Add "Add dependency to module" quickfix in multimodule Maven project
-- [`KT-39869`](https://youtrack.jetbrains.com/issue/KT-39869) Add whole project migration usages of kotlin.browser.* & kotlin.dom.* to kotlinx.browser.* & kotlinx.dom.* respectively
-
-### IDE. Wizards
-
-- [`KT-40004`](https://youtrack.jetbrains.com/issue/KT-40004) New Project wizard 1.4+: no `https://dl.bintray.com/kotlin/kotlinx` repository is added for kotlinx-html
-- [`KT-40037`](https://youtrack.jetbrains.com/issue/KT-40037) New Project wizard: update Ktor version
-- [`KT-40092`](https://youtrack.jetbrains.com/issue/KT-40092) Wizard: the templates panel on mac OS is too wide
-- [`KT-40232`](https://youtrack.jetbrains.com/issue/KT-40232) New Wizard: Android Sdk path doesn't have backslash escaping on Windows
-- [`KT-40371`](https://youtrack.jetbrains.com/issue/KT-40371) New Project Wizard: Frontend Application / Library results in broken run configuration
-- [`KT-40377`](https://youtrack.jetbrains.com/issue/KT-40377) New Project Wizard: Frontend Application defines NPM dependencies that are unnecessary with Kotlin 1.4-RC+
-- [`KT-40378`](https://youtrack.jetbrains.com/issue/KT-40378) New Project Wizard: Frontend Application, Disabling JavaScript test framework has no effect
-- [`KT-40407`](https://youtrack.jetbrains.com/issue/KT-40407) Wizard: do not add stdlib by default for Gradle projects in wizard
-
-### JS. Tools
-
-- [`KT-39984`](https://youtrack.jetbrains.com/issue/KT-39984) Update dukat version in toolchain near to release of 1.4-RC
-
-### JavaScript
-
-- [`KT-32186`](https://youtrack.jetbrains.com/issue/KT-32186) Make sure K/JS Reflection API documentation is correct and fix it.
-- [`KT-37563`](https://youtrack.jetbrains.com/issue/KT-37563) K/JS: stacktrace is not captured for exceptions without primary constructor inherited from Exception/Error
-- [`KT-37752`](https://youtrack.jetbrains.com/issue/KT-37752) Generated typescript incorrect for constructors of derived classes
-- [`KT-37883`](https://youtrack.jetbrains.com/issue/KT-37883) KJS: Generated TypeScript uses 'declare' rather than 'export'
-- [`KT-38771`](https://youtrack.jetbrains.com/issue/KT-38771) JS: support non-reified type parameters in typeOf
-- [`KT-39873`](https://youtrack.jetbrains.com/issue/KT-39873) Update Kotlin JavaScript wrappers due to NON_EXPORTABLE_TYPE diagnostic introduction
-- [`KT-40126`](https://youtrack.jetbrains.com/issue/KT-40126) [JS / IR] NPE while compiling interfaces with invoke which is passed as a delegate
-- [`KT-40216`](https://youtrack.jetbrains.com/issue/KT-40216) KJS / IR:  AssertionError caused by an anonymous object in the dependency project
-
-### Libraries
-
-- [`KT-33069`](https://youtrack.jetbrains.com/issue/KT-33069) StringBuilder common functions
-- [`KT-35972`](https://youtrack.jetbrains.com/issue/KT-35972) Add contract to builder functions
-- [`KT-37101`](https://youtrack.jetbrains.com/issue/KT-37101) Mark following api with DeprecatedSinceKotlin("1.4")
-- [`KT-38360`](https://youtrack.jetbrains.com/issue/KT-38360) Make sure that JB libraries correctly define their npm deps and republish them (after KT-30619)
-- [`KT-38817`](https://youtrack.jetbrains.com/issue/KT-38817) 'capitalize' should convert digraphs to title case
-- [`KT-40168`](https://youtrack.jetbrains.com/issue/KT-40168) Remove StringBuilder.capacity from common and JS parts
-
-### Middle-end. IR
-
-- [`KT-40520`](https://youtrack.jetbrains.com/issue/KT-40520) Assert during fake-override generation
-
-### Tools. Commonizer
-
-- [`KT-40199`](https://youtrack.jetbrains.com/issue/KT-40199) Commonizer loses nullability of abbreviated types
-
-### Tools. Compiler Plugins
-
-- [`KT-40036`](https://youtrack.jetbrains.com/issue/KT-40036) Add diagnostic that shows is serialization plugin compatible with serialization-runtime
-
-### Tools. Gradle
-
-- [`KT-39755`](https://youtrack.jetbrains.com/issue/KT-39755) [KJS / Gradle / Legacy mode] Directory with whitespace is not processed
-- [`KT-39809`](https://youtrack.jetbrains.com/issue/KT-39809) Kotlin Gradle plugin: ServiceConfigurationError: org.jetbrains.kotlin.gradle.plugin.KotlinGradleSubplugin: Provider org.jetbrains.kotlin.gradle.internal.AndroidSubplugin not a subtype
-- [`KT-39977`](https://youtrack.jetbrains.com/issue/KT-39977) Collect statistics of used -Xjvm-default options
-- [`KT-40300`](https://youtrack.jetbrains.com/issue/KT-40300) Fail the build if in MPP plugin no targets configured
-
-### Tools. Gradle. JS
-
-- [`KT-38170`](https://youtrack.jetbrains.com/issue/KT-38170) Investigate how to improve migration experience from pre 1.4.0 DSL to the new one
-- [`KT-39654`](https://youtrack.jetbrains.com/issue/KT-39654) Default CSS settings in webpack has priority over user's settings
-- [`KT-39842`](https://youtrack.jetbrains.com/issue/KT-39842) Kotlin/JS Gradle DSL: peerNpm dependency fails
-- [`KT-40048`](https://youtrack.jetbrains.com/issue/KT-40048) [Gradle, JS] Deprecate kotlin-frontend plugin
-- [`KT-40067`](https://youtrack.jetbrains.com/issue/KT-40067) [Gradle, JS] Public package.json for mixed JS/TS project
-- [`KT-40210`](https://youtrack.jetbrains.com/issue/KT-40210) Fail the build when Kotlin/JS target is not (properly) configured
-- [`KT-40320`](https://youtrack.jetbrains.com/issue/KT-40320) Gradle JS: make migration to the new Gradle DSL smoother
-
-### Tools. Gradle. Multiplatform
-
-- [`KT-32239`](https://youtrack.jetbrains.com/issue/KT-32239) Custom configurations inside Kotlin JVM Gradle projects can't properly resolve multiplatform dependencies
-- [`KT-39897`](https://youtrack.jetbrains.com/issue/KT-39897) [Commonizer] Fast-pass for library fragments absent for some targets
-
-### Tools. J2K
-
-- [`KT-39739`](https://youtrack.jetbrains.com/issue/KT-39739) J2K: Access is allowed from event dispatch thread with IW lock only
-
-### Tools. kapt
-
-- [`KT-34604`](https://youtrack.jetbrains.com/issue/KT-34604) KAPT: Flaky NPE through `org.jetbrains.kotlin.kapt3.base.ProcessorLoader.doLoadProcessors`
-- [`KT-36302`](https://youtrack.jetbrains.com/issue/KT-36302) TypeTreeVisitor.visitMemberSelect IllegalStateException: node.sym must not be null on JDK 11
-- [`KT-39876`](https://youtrack.jetbrains.com/issue/KT-39876) KAPT: Serialization of classpath structure is incorrect if there are dependencies between types in jar/dir
-
-
-## 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
@@ -957,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
 
@@ -1184,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
 
@@ -1237,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
 
@@ -1867,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

@@ -18,16 +18,6 @@ Welcome to [Kotlin](https://kotlinlang.org/)! Some handy links:
  * [Public Slack channel](https://slack.kotlinlang.org/)
  * [TeamCity CI build](https://teamcity.jetbrains.com/project.html?tab=projectOverview&projectId=Kotlin)
 
-## Kotlin Multiplatform capabilities
-
-Support for multiplatform programming is one of Kotlin’s key benefits. It reduces time spent writing and maintaining the same code for [different platforms](https://kotlinlang.org/docs/reference/mpp-supported-platforms.html) while retaining the flexibility and benefits of native programming.
-
- * [Kotlin Multiplatform Mobile](https://kotlinlang.org/lp/mobile/) for sharing code between Android and iOS
- * [Getting Started with Kotlin Multiplatform Mobile Guide](https://kotlinlang.org/docs/mobile/create-first-app.html)
- * [Kotlin Multiplatform Benefits](https://kotlinlang.org/docs/reference/multiplatform.html)
- * [Share code on all platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-all-platforms)
- * [Share code on similar platforms](https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html#share-code-on-similar-platforms)
-
 ## Editing Kotlin
 
  * [Kotlin IntelliJ IDEA Plugin](https://kotlinlang.org/docs/tutorials/getting-started.html)
@@ -51,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:
 
@@ -96,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

@@ -8,8 +8,10 @@ buildscript {
         val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
         if (cacheRedirectorEnabled) {
             maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
+            maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
         } else {
             maven("https://dl.bintray.com/kotlin/kotlinx")
+            maven("https://dl.bintray.com/kotlin/kotlin-dev")
         }
     }
     dependencies {
@@ -28,15 +30,16 @@ repositories {
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
     if (cacheRedirectorEnabled) {
         maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlinx")
-   } else {
+        maven("https://cache-redirector.jetbrains.com/dl.bintray.com/kotlin/kotlin-dev")
+    } else {
         maven("https://dl.bintray.com/kotlin/kotlinx")
+        maven("https://dl.bintray.com/kotlin/kotlin-dev")
     }
 }
 
 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") }
@@ -70,7 +73,6 @@ benchmark {
             param("size", 1000)
 
             include("CommonCallsBenchmark")
-            include("ControlFlowAnalysisBenchmark")
             //include("InferenceBaselineCallsBenchmark")
         }
 
@@ -93,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

@@ -5,6 +5,7 @@
 package org.jetbrains.kotlin.benchmarks
 
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.psi.PsiElementFinder
@@ -12,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
@@ -24,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
@@ -103,7 +111,9 @@ abstract class AbstractSimpleFileBenchmark {
         )
 
         if (isIR) {
-            PsiElementFinder.EP.getPoint(env.project).unregisterExtension(JavaElementFinder::class.java)
+            Extensions.getArea(env.project)
+                .getExtensionPoint(PsiElementFinder.EP_NAME)
+                .unregisterExtension(JavaElementFinder::class.java)
         }
 
         file = createFile(
@@ -160,10 +170,43 @@ abstract class AbstractSimpleFileBenchmark {
         totalTransformer.process(listOf(firFile))
 
         bh.consume(firFile.hashCode())
-        env.project.extensionArea
-            .getExtensionPoint<PsiElementFinder>(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/build.gradle.kts

@@ -7,7 +7,6 @@ plugins {
 
 dependencies {
     compileOnly(project(":core:util.runtime"))
-    compileOnly(project(":compiler:backend.common.jvm"))
     compileOnly(project(":compiler:util"))
     compileOnly(project(":compiler:cli-common"))
     compileOnly(project(":compiler:frontend.java"))

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

@@ -75,7 +75,7 @@ open class IncrementalJsCache(
     override fun markDirty(removedAndCompiledSources: Collection<File>) {
         removedAndCompiledSources.forEach { sourceFile ->
             // The common prefix of all FQN parents has to be the file package
-            sourceToClassesMap[sourceFile].map { it.parentOrNull()?.asString() ?: "" }.minByOrNull { it.length }?.let {
+            sourceToClassesMap[sourceFile].map { it.parentOrNull()?.asString() ?: "" }.minBy { it.length }?.let {
                 packageMetadata.remove(it)
             }
         }

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

@@ -168,8 +168,6 @@ open class IncrementalJvmCache(
                 constantsMap.process(kotlinClass, changesCollector)
                 inlineFunctionsMap.process(kotlinClass, changesCollector)
             }
-            KotlinClassHeader.Kind.UNKNOWN, KotlinClassHeader.Kind.SYNTHETIC_CLASS -> {
-            }
         }
     }
 

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.load.java.JavaDescriptorVisibilities
+import org.jetbrains.kotlin.load.java.JavaVisibilities
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.metadata.java.JavaClassProtoBuf
@@ -41,7 +41,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
             childSerializer: DescriptorSerializer
     ) {
         super.serializeClass(descriptor, proto, versionRequirementTable, childSerializer)
-        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateClass, true)
         }
     }
@@ -50,7 +50,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
                                       proto: ProtoBuf.Constructor.Builder,
                                       childSerializer: DescriptorSerializer) {
         super.serializeConstructor(descriptor, proto, childSerializer)
-        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateConstructor, true)
         }
     }
@@ -62,7 +62,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
         childSerializer: DescriptorSerializer
     ) {
         super.serializeFunction(descriptor, proto, versionRequirementTable, childSerializer)
-        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateMethod, true)
         }
 
@@ -78,7 +78,7 @@ class JavaClassesSerializerExtension : KotlinSerializerExtensionBase(BuiltInSeri
             childSerializer: DescriptorSerializer
     ) {
         super.serializeProperty(descriptor, proto, versionRequirementTable, childSerializer)
-        if (descriptor.visibility == JavaDescriptorVisibilities.PACKAGE_VISIBILITY) {
+        if (descriptor.visibility == JavaVisibilities.PACKAGE_VISIBILITY) {
             proto.setExtension(JavaClassProtoBuf.isPackagePrivateField, true)
         }
 

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

@@ -23,12 +23,12 @@ import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import java.io.File
 
 class LocalFileKotlinClass private constructor(
-    private val file: File,
-    private val fileContents: ByteArray,
-    className: ClassId,
-    classVersion: Int,
-    classHeader: KotlinClassHeader,
-    innerClasses: InnerClassesInfo
+        private val file: File,
+        private val fileContents: ByteArray,
+        className: ClassId,
+        classVersion: Int,
+        classHeader: KotlinClassHeader,
+        innerClasses: InnerClassesInfo
 ) : FileBasedKotlinClass(className, classVersion, classHeader, innerClasses) {
 
     companion object {

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

@@ -80,7 +80,7 @@ open class LookupStorage(
 
         for (lookupSymbol in lookups.keySet().sorted()) {
             val key = LookupSymbolKey(lookupSymbol.name, lookupSymbol.scope)
-            val paths = lookups[lookupSymbol]
+            val paths = lookups[lookupSymbol]!!
             val fileIds = paths.mapTo(TreeSet()) { pathToId[it]!! }
             fileIds.addAll(lookupMap[key] ?: emptySet())
             lookupMap[key] = fileIds

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

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-@file:Suppress("UNUSED_PARAMETER")
-
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.incremental
 
-import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufClassKind
 import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufPackageKind
 import org.jetbrains.kotlin.incremental.storage.ProtoMapValue
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
-import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
 import java.util.*
 
 data class Difference(
@@ -50,8 +49,8 @@ fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
     }
 
 internal val MessageLite.isPrivate: Boolean
-    get() = DescriptorVisibilities.isPrivate(
-        ProtoEnumFlags.descriptorVisibility(
+    get() = Visibilities.isPrivate(
+        ProtoEnumFlags.visibility(
             when (this) {
                 is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.Function -> Flags.VISIBILITY.get(flags)
@@ -347,4 +346,4 @@ val ProtoBuf.Class.typeTableOrNull: ProtoBuf.TypeTable?
     get() = if (hasTypeTable()) typeTable else null
 
 val ProtoBuf.Package.typeTableOrNull: ProtoBuf.TypeTable?
-    get() = if (hasTypeTable()) typeTable else null
+    get() = if (hasTypeTable()) typeTable else null

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.193

@@ -1,106 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.incremental.storage
-
-import com.intellij.util.io.DataExternalizer
-import com.intellij.util.io.KeyDescriptor
-import com.intellij.util.io.JpsPersistentHashMap
-import java.io.File
-
-
-class NonCachingLazyStorage<K, V>(
-    private val storageFile: File,
-    private val keyDescriptor: KeyDescriptor<K>,
-    private val valueExternalizer: DataExternalizer<V>
-) : LazyStorage<K, V> {
-    @Volatile
-    private var storage: JpsPersistentHashMap<K, V>? = null
-
-    @Synchronized
-    private fun getStorageIfExists(): JpsPersistentHashMap<K, V>? {
-        if (storage != null) return storage
-
-        if (storageFile.exists()) {
-            storage = createMap()
-            return storage
-        }
-
-        return null
-    }
-
-    @Synchronized
-    private fun getStorageOrCreateNew(): JpsPersistentHashMap<K, V> {
-        if (storage == null) {
-            storage = createMap()
-        }
-
-        return storage!!
-    }
-
-    override val keys: Collection<K>
-        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
-
-    override operator fun contains(key: K): Boolean =
-        getStorageIfExists()?.containsMapping(key) ?: false
-
-    override operator fun get(key: K): V? =
-        getStorageIfExists()?.get(key)
-
-    override operator fun set(key: K, value: V) {
-        getStorageOrCreateNew().put(key, value)
-    }
-
-    override fun remove(key: K) {
-        getStorageIfExists()?.remove(key)
-    }
-
-    override fun append(key: K, value: V) {
-        getStorageOrCreateNew().appendDataWithoutCache(key, value)
-    }
-
-    @Synchronized
-    override fun clean() {
-        try {
-            storage?.close()
-        } catch (ignored: Throwable) {
-        }
-
-        JpsPersistentHashMap.deleteFilesStartingWith(storageFile)
-        storage = null
-    }
-
-    @Synchronized
-    override fun flush(memoryCachesOnly: Boolean) {
-        val existingStorage = storage ?: return
-
-        if (memoryCachesOnly) {
-            if (existingStorage.isDirty) {
-                existingStorage.dropMemoryCaches()
-            }
-        } else {
-            existingStorage.force()
-        }
-    }
-
-    @Synchronized
-    override fun close() {
-        storage?.close()
-    }
-
-    private fun createMap(): JpsPersistentHashMap<K, V> =
-        JpsPersistentHashMap(storageFile, keyDescriptor, valueExternalizer)
-}

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import com.intellij.util.io.DataExternalizer
+import com.intellij.util.io.KeyDescriptor
+import com.intellij.util.io.PersistentHashMap
+import java.io.File
+
+
+class NonCachingLazyStorage<K, V>(
+    private val storageFile: File,
+    private val keyDescriptor: KeyDescriptor<K>,
+    private val valueExternalizer: DataExternalizer<V>
+) : LazyStorage<K, V> {
+    @Volatile
+    private var storage: PersistentHashMap<K, V>? = null
+
+    @Synchronized
+    private fun getStorageIfExists(): PersistentHashMap<K, V>? {
+        if (storage != null) return storage
+
+        if (storageFile.exists()) {
+            storage = createMap()
+            return storage
+        }
+
+        return null
+    }
+
+    @Synchronized
+    private fun getStorageOrCreateNew(): PersistentHashMap<K, V> {
+        if (storage == null) {
+            storage = createMap()
+        }
+
+        return storage!!
+    }
+
+    override val keys: Collection<K>
+        get() = getStorageIfExists()?.allKeysWithExistingMapping ?: listOf()
+
+    override operator fun contains(key: K): Boolean =
+        getStorageIfExists()?.containsMapping(key) ?: false
+
+    override operator fun get(key: K): V? =
+        getStorageIfExists()?.get(key)
+
+    override operator fun set(key: K, value: V) {
+        getStorageOrCreateNew().put(key, value)
+    }
+
+    override fun remove(key: K) {
+        getStorageIfExists()?.remove(key)
+    }
+
+    override fun append(key: K, value: V) {
+        getStorageOrCreateNew().appendData(key) { dataOutput -> valueExternalizer.save(dataOutput, value) }
+    }
+
+    @Synchronized
+    override fun clean() {
+        try {
+            storage?.close()
+        } catch (ignored: Throwable) {
+        }
+
+        PersistentHashMap.deleteFilesStartingWith(storageFile)
+        storage = null
+    }
+
+    @Synchronized
+    override fun flush(memoryCachesOnly: Boolean) {
+        val existingStorage = storage ?: return
+
+        if (memoryCachesOnly) {
+            if (existingStorage.isDirty) {
+                existingStorage.dropMemoryCaches()
+            }
+        } else {
+            existingStorage.force()
+        }
+    }
+
+    @Synchronized
+    override fun close() {
+        storage?.close()
+    }
+
+    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)
@@ -177,8 +176,8 @@ extra["versions.org.springframework"] = "4.2.0.RELEASE"
 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.3"
-extra["versions.r8"] = "2.0.88"
+extra["versions.completion-ranking-kotlin"] = "0.1.2"
+extra["versions.r8"] = "1.5.70"
 val immutablesVersion = "0.3.1"
 extra["versions.kotlinx-collections-immutable"] = immutablesVersion
 extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
@@ -187,13 +186,12 @@ extra["versions.kotlinx-collections-immutable-jvm"] = immutablesVersion
 extra["versions.ktor-network"] = "1.0.1"
 
 if (!project.hasProperty("versions.kotlin-native")) {
-    extra["versions.kotlin-native"] = "1.4.20-dev-16314"
+    extra["versions.kotlin-native"] = "1.4-M3-dev-15627"
 }
 
 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
 
@@ -221,8 +219,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:config",
     ":compiler:config.jvm",
     ":compiler:container",
-    ":compiler:resolution.common",
-    ":compiler:resolution.common.jvm",
     ":compiler:resolution",
     ":compiler:serialization",
     ":compiler:psi",
@@ -231,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",
@@ -241,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",
@@ -267,22 +260,17 @@ extra["compilerModules"] = arrayOf(
     ":kotlin-build-common",
     ":core:metadata",
     ":core:metadata.jvm",
-    ":core:deserialization.common",
-    ":core:deserialization.common.jvm",
-    ":core:compiler.common",
-    ":core:compiler.common.jvm",
-    ":compiler:backend.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":core:descriptors.runtime",
     ":core:deserialization",
     ":core:util.runtime",
+    ":core:type-system",
     ":compiler:fir:cones",
     ":compiler:fir:resolve",
     ":compiler:fir:fir-serialization",
-    ":compiler:fir:fir-deserialization",
     ":compiler:fir:tree",
-    ":compiler:fir:raw-fir:raw-fir.common",
+    ":compiler:fir:raw-fir:fir-common",
     ":compiler:fir:raw-fir:psi2fir",
     ":compiler:fir:raw-fir:light-tree2fir",
     ":compiler:fir:fir2ir",
@@ -290,11 +278,11 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:java",
     ":compiler:fir:jvm",
     ":compiler:fir:checkers",
-    ":compiler:fir:entrypoint",
     ":compiler:fir:analysis-tests"
 )
 
 extra["compilerModulesForJps"] = listOf(
+    ":core:type-system",
     ":kotlin-build-common",
     ":kotlin-util-io",
     ":kotlin-util-klib",
@@ -303,8 +291,6 @@ extra["compilerModulesForJps"] = listOf(
     ":kotlin-compiler-runner",
     ":daemon-common",
     ":daemon-common-new",
-    ":core:compiler.common",
-    ":core:compiler.common.jvm",
     ":core:descriptors",
     ":core:descriptors.jvm",
     ":idea:idea-jps-common",
@@ -321,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",
@@ -330,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"
 )
@@ -340,8 +328,7 @@ val gradlePluginProjects = listOf(
     ":kotlin-allopen",
     ":kotlin-annotation-processing-gradle",
     ":kotlin-noarg",
-    ":kotlin-sam-with-receiver",
-    ":kotlin-parcelize-compiler"
+    ":kotlin-sam-with-receiver"
 )
 
 apply {
@@ -365,7 +352,7 @@ fun Task.listConfigurationContents(configName: String) {
 }
 
 val defaultJvmTarget = "1.8"
-val defaultJavaHome = jdkPath(if (Platform[203].orHigher()) "11" else defaultJvmTarget)
+val defaultJavaHome = jdkPath(defaultJvmTarget)
 val ignoreTestFailures by extra(project.kotlinBuildProperties.ignoreTestFailures)
 
 allprojects {
@@ -379,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
 
@@ -418,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") }
     )
 
@@ -429,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")
         }
     }
 
@@ -472,7 +442,6 @@ allprojects {
             ignore("META-INF/MANIFEST.MF")
             ignore("META-INF/compiler.version")
             ignore("META-INF/plugin.xml")
-            ignore("kotlin/KotlinVersionCurrentValue.class")
         }
     }
 
@@ -522,23 +491,6 @@ allprojects {
         }
 
         apply(from = "$rootDir/gradle/cacheRedirector.gradle.kts")
-        apply(from = "$rootDir/gradle/testRetry.gradle.kts")
-    }
-}
-
-gradle.buildFinished {
-    val taskGraph = gradle?.taskGraph
-    if (taskGraph != null) {
-        taskGraph.allTasks
-                .filterIsInstance<SourceTask>()
-                .filter { it.didWork }
-                .forEach {
-                    it.source.visit {
-                        if (file.isDirectory && file.listFiles()?.isEmpty() == true) {
-                            logger.warn("Empty source directories may cause build cache misses: " + file.absolutePath)
-                        }
-                    }
-                }
     }
 }
 
@@ -546,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)
@@ -565,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)
@@ -594,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") }
         }
@@ -603,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"
@@ -693,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")
     }
 
@@ -712,12 +654,9 @@ tasks {
         dependsOn("scriptingTest")
         dependsOn(":kotlin-build-common:test")
         dependsOn(":compiler:incremental-compilation-impl:test")
-        dependsOn(":compiler:incremental-compilation-impl:testJvmICWithJdk11")
         dependsOn(":core:descriptors.runtime:test")
 
         dependsOn("jvmCompilerIntegrationTest")
-
-        dependsOn(":plugins:parcelize:parcelize-compiler:test")
     }
 
     register("toolsTest") {
@@ -753,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",
@@ -778,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(
@@ -790,26 +747,14 @@ tasks {
         dependsOn(
             ":plugins:android-extensions-ide:test",
             ":idea:idea-android:test",
+            ":kotlin-annotation-processing:test"
+        )
+    }
+
+    register("plugins-tests") {
+        dependsOn("dist")
+        dependsOn(
             ":kotlin-annotation-processing:test",
-            ":plugins:parcelize:parcelize-ide:test"
-        )
-    }
-
-    register("ideaPluginTest") {
-        dependsOn(
-            "mainIdeTests",
-            "gradleIdeTest",
-            "kaptIdeTest",
-            "miscIdeTests"
-        )
-    }
-
-    register("mainIdeTests") {
-        dependsOn(":idea:test")
-    }
-
-    register("miscIdeTests") {
-        dependsOn(
             ":kotlin-allopen-compiler-plugin:test",
             ":kotlin-noarg-compiler-plugin:test",
             ":kotlin-sam-with-receiver-compiler-plugin:test",
@@ -817,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") {
@@ -886,7 +792,6 @@ tasks {
                 ":prepare:ide-plugin-dependencies:noarg-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:sam-with-receiver-compiler-plugin-for-ide:publish",
                 ":prepare:ide-plugin-dependencies:compiler-components-for-jps:publish",
-                ":prepare:ide-plugin-dependencies:parcelize-compiler-plugin-for-ide:publish",
                 ":kotlin-script-runtime:publish",
                 ":kotlin-script-util:publish",
                 ":kotlin-scripting-common:publish",
@@ -899,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() {
@@ -968,7 +889,7 @@ val zipPlugin by task<Zip> {
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Plugin artifacts packed to ${archiveFile.get()}")
+        logger.lifecycle("Plugin artifacts packed to $archiveFile")
     }
 }
 
@@ -1137,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")}")
@@ -110,8 +109,6 @@ dependencies {
     implementation("org.jetbrains.intellij.deps:asm-all:8.0.1")
 
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.5")
-
-    implementation("org.gradle:test-retry-gradle-plugin:1.1.9")
 }
 
 samWithReceiver {

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,13 +48,11 @@ 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),
     AS40(Platform.P193),
-    AS41(Platform.P201),
-    AS42(Platform.P201);
+    AS41(Platform.P201);
 
     val kind = Kind.values().first { it.shortName == name.take(2) }
     val version = name.dropWhile { !it.isDigit() }.toInt()

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

@@ -80,8 +80,6 @@ fun Project.androidDxJar() = "org.jetbrains.kotlin:android-dx:${rootProject.extr
 
 fun Project.jpsBuildTest() = "com.jetbrains.intellij.idea:jps-build-test:${rootProject.extra["versions.intellijSdk"]}"
 
-fun Project.kotlinxCollectionsImmutable() = "org.jetbrains.kotlinx:kotlinx-collections-immutable-jvm:${rootProject.extra["versions.kotlinx-collections-immutable"]}"
-
 /**
  * Runtime version of annotations that are already in Kotlin stdlib (historically Kotlin has older version of this one).
  *
@@ -167,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")
 
@@ -180,14 +178,13 @@ fun Project.runIdeTask(name: String, ideaPluginDir: File, ideaSandboxDir: File,
             "-Didea.system.path=$ideaSandboxDir",
             "-Didea.config.path=$ideaSandboxConfigDir",
             "-Didea.tooling.debug=true",
-            "-Dfus.internal.test.mode=true",
             "-Dapple.laf.useScreenMenuBar=true",
             "-Dapple.awt.graphics.UseQuartz=true",
             "-Dsun.io.useCanonCaches=false",
             "-Dplugin.path=${ideaPluginDir.absolutePath}"
         )
 
-        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/plugins/PublishedKotlinModule.kt

@@ -52,7 +52,6 @@ open class PublishedKotlinModule : Plugin<Project> {
                 configure<SigningExtension> {
                     isRequired = signingRequired
                     sign(configurations["archives"])
-                    useGpgCmd()
                 }
 
                 tasks.named<Sign>("signArchives").configure {

buildSrc/src/main/kotlin/tasks.kt

@@ -31,47 +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-parcelize-compiler: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",
-        ":native:kotlin-klib-commonizer-embeddable:install"
-    )
-}
-
 fun Project.projectTest(
     taskName: String = "test",
     parallel: Boolean = false,

compiler/android-tests/build.gradle.kts

@@ -6,23 +6,25 @@ plugins {
 }
 
 dependencies {
+    compile(project(":compiler:util"))
+    compile(project(":compiler:cli"))
+    compile(project(":compiler:frontend"))
+    compile(project(":compiler:backend"))
+    compile(kotlinStdlib())
+    compile(project(":kotlin-reflect"))
+    compile(projectTests(":compiler:tests-common"))
+    compile(commonDep("junit:junit"))
+
+    Platform[193].orLower {
+        compileOnly(intellijDep()) { includeJars("openapi") }
+    }
+
+    testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":core:descriptors"))
     testCompile(project(":core:descriptors.jvm"))
-    testCompile(project(":compiler:util"))
-    testCompile(project(":compiler:cli"))
-    testCompile(project(":compiler:frontend"))
-    testCompile(project(":compiler:backend"))
-    testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(project(":compiler:frontend.java"))
-
-    testCompile(kotlinStdlib())
-    testCompile(project(":kotlin-reflect"))
-    testCompile(projectTests(":compiler:tests-common"))
-    testCompile(commonDep("junit:junit"))
-
     testCompile(projectTests(":jps-plugin"))
     testCompile(commonDep("junit:junit"))
-
     Platform[193].orLower {
         testCompile(intellijDep()) { includeJars("openapi", rootProject = rootProject) }
     }
@@ -42,7 +44,7 @@ dependencies {
 }
 
 sourceSets {
-    "main" { }
+    "main" { projectDefault() }
     "test" { projectDefault() }
 }
 

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

@@ -25,7 +25,7 @@ import org.junit.runners.AllTests;
 
 import java.io.File;
 
-//@RunWith(AllTests.class)
+@RunWith(AllTests.class)
 public class AndroidRunner {
 
     private static PathManager pathManager;

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
@@ -65,7 +71,7 @@ object CodegenUtil {
                 if (copy)
                     copyFunctions(
                         declaration, traitMember, declaration.containingDeclaration, traitMember.modality,
-                        DescriptorVisibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, true
+                        Visibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, true
                     )
                 else mapMembers(declaration, traitMember)
             )
@@ -74,13 +80,13 @@ object CodegenUtil {
     }
 
     fun copyFunctions(
-            inheritedMember: CallableMemberDescriptor,
-            traitMember: CallableMemberDescriptor,
-            newOwner: DeclarationDescriptor,
-            modality: Modality,
-            visibility: DescriptorVisibility,
-            kind: CallableMemberDescriptor.Kind,
-            copyOverrides: Boolean
+        inheritedMember: CallableMemberDescriptor,
+        traitMember: CallableMemberDescriptor,
+        newOwner: DeclarationDescriptor,
+        modality: Modality,
+        visibility: Visibility,
+        kind: CallableMemberDescriptor.Kind,
+        copyOverrides: Boolean
     ): Map<FunctionDescriptor, FunctionDescriptor> =
         mapMembers(inheritedMember.copy(newOwner, modality, visibility, kind, copyOverrides), traitMember)
 

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.common.jvm/build.gradle.kts

@@ -1,15 +0,0 @@
-plugins {
-    kotlin("jvm")
-    id("jps-compatible")
-}
-
-dependencies {
-    api(project(":core:compiler.common.jvm"))
-    api(project(":compiler:config.jvm"))
-    api(intellijCoreDep()) { includeJars("asm-all", "guava", rootProject = rootProject) }
-}
-
-sourceSets {
-    "main" { projectDefault() }
-    "test" {}
-}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/codegen/AsmUtil.java

@@ -1,450 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen;
-
-import com.google.common.collect.ImmutableMap;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.PrimitiveType;
-import org.jetbrains.kotlin.descriptors.Visibilities;
-import org.jetbrains.kotlin.descriptors.Visibility;
-import org.jetbrains.kotlin.descriptors.java.JavaVisibilities;
-import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
-import org.jetbrains.kotlin.name.ClassId;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
-import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
-import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
-import org.jetbrains.org.objectweb.asm.MethodVisitor;
-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.commons.Method;
-
-import java.util.Map;
-
-import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
-import static org.jetbrains.org.objectweb.asm.Opcodes.*;
-
-public class AsmUtil {
-    private static final int NO_FLAG_LOCAL = 0;
-    public static final int NO_FLAG_PACKAGE_PRIVATE = 0;
-
-    @NotNull
-    private static final Map<Visibility, Integer> visibilityToAccessFlag = ImmutableMap.<Visibility, Integer>builder()
-            .put(Visibilities.Private.INSTANCE, ACC_PRIVATE)
-            .put(Visibilities.PrivateToThis.INSTANCE, ACC_PRIVATE)
-            .put(Visibilities.Protected.INSTANCE, ACC_PROTECTED)
-            .put(JavaVisibilities.ProtectedStaticVisibility.INSTANCE, ACC_PROTECTED)
-            .put(JavaVisibilities.ProtectedAndPackage.INSTANCE, ACC_PROTECTED)
-            .put(Visibilities.Public.INSTANCE, ACC_PUBLIC)
-            .put(Visibilities.Internal.INSTANCE, ACC_PUBLIC)
-            .put(Visibilities.Local.INSTANCE, NO_FLAG_LOCAL)
-            .put(JavaVisibilities.PackageVisibility.INSTANCE, NO_FLAG_PACKAGE_PRIVATE)
-            .build();
-
-    public static final String CAPTURED_PREFIX = "$";
-
-    public static final String THIS = "this";
-
-    public static final String THIS_IN_DEFAULT_IMPLS = "$this";
-
-    public static final String LABELED_THIS_FIELD = THIS + "_";
-
-    public static final String CAPTURED_LABELED_THIS_FIELD = CAPTURED_PREFIX + LABELED_THIS_FIELD;
-
-    public static final String INLINE_DECLARATION_SITE_THIS = "this_";
-
-    public static final String LABELED_THIS_PARAMETER = CAPTURED_PREFIX + THIS + "$";
-
-    public static final String CAPTURED_THIS_FIELD = "this$0";
-
-    public static final String RECEIVER_PARAMETER_NAME = "$receiver";
-
-    /*
-        This is basically an old convention. Starting from Kotlin 1.3, it was replaced with `$this_<label>`.
-        Note that it is still used for inlined callable references and anonymous callable extension receivers
-        even in 1.3.
-    */
-    public static final String CAPTURED_RECEIVER_FIELD = "receiver$0";
-
-    // For non-inlined callable references ('kotlin.jvm.internal.CallableReference' has a 'receiver' field)
-    public static final String BOUND_REFERENCE_RECEIVER = "receiver";
-
-    public static final String LOCAL_FUNCTION_VARIABLE_PREFIX = "$fun$";
-
-    private static final ImmutableMap<Integer, JvmPrimitiveType> primitiveTypeByAsmSort;
-    private static final ImmutableMap<Type, Type> primitiveTypeByBoxedType;
-
-    static {
-        ImmutableMap.Builder<Integer, JvmPrimitiveType> typeBySortBuilder = ImmutableMap.builder();
-        ImmutableMap.Builder<Type, Type> typeByWrapperBuilder = ImmutableMap.builder();
-        for (JvmPrimitiveType primitiveType : JvmPrimitiveType.values()) {
-            Type asmType = Type.getType(primitiveType.getDesc());
-            typeBySortBuilder.put(asmType.getSort(), primitiveType);
-            typeByWrapperBuilder.put(asmTypeByFqNameWithoutInnerClasses(primitiveType.getWrapperFqName()), asmType);
-        }
-        primitiveTypeByAsmSort = typeBySortBuilder.build();
-        primitiveTypeByBoxedType = typeByWrapperBuilder.build();
-    }
-
-    private AsmUtil() {
-    }
-
-    @NotNull
-    public static String getCapturedFieldName(@NotNull String originalName) {
-        return CAPTURED_PREFIX + originalName;
-    }
-
-    @NotNull
-    public static String getLabeledThisName(@NotNull String callableName, @NotNull String prefix, @NotNull String defaultName) {
-        if (!Name.isValidIdentifier(callableName)) {
-            return defaultName;
-        }
-
-        return prefix + CommonVariableAsmNameManglingUtils.mangleNameIfNeeded(callableName);
-    }
-
-    @NotNull
-    public static Type boxType(@NotNull Type type) {
-        Type boxedType = boxPrimitiveType(type);
-        return boxedType != null ? boxedType : type;
-    }
-
-    @Nullable
-    public static Type boxPrimitiveType(@NotNull Type type) {
-        JvmPrimitiveType jvmPrimitiveType = primitiveTypeByAsmSort.get(type.getSort());
-        return jvmPrimitiveType != null ? asmTypeByFqNameWithoutInnerClasses(jvmPrimitiveType.getWrapperFqName()) : null;
-    }
-
-    @NotNull
-    public static Type unboxType(@NotNull Type boxedType) {
-        Type primitiveType = unboxPrimitiveTypeOrNull(boxedType);
-        if (primitiveType == null) {
-            throw new UnsupportedOperationException("Unboxing: " + boxedType);
-        }
-        return primitiveType;
-    }
-
-    @Nullable
-    public static Type unboxPrimitiveTypeOrNull(@NotNull Type boxedType) {
-        return primitiveTypeByBoxedType.get(boxedType);
-    }
-
-    public static boolean isBoxedPrimitiveType(@NotNull Type boxedType) {
-        return primitiveTypeByBoxedType.get(boxedType) != null;
-    }
-
-    @NotNull
-    public static Type unboxUnlessPrimitive(@NotNull Type boxedOrPrimitiveType) {
-        if (isPrimitive(boxedOrPrimitiveType)) return boxedOrPrimitiveType;
-        return unboxType(boxedOrPrimitiveType);
-    }
-
-    public static boolean isBoxedTypeOf(@NotNull Type boxedType, @NotNull Type unboxedType) {
-        return unboxPrimitiveTypeOrNull(boxedType) == unboxedType;
-    }
-
-    public static boolean isIntPrimitive(Type type) {
-        return type == Type.INT_TYPE || type == Type.SHORT_TYPE || type == Type.BYTE_TYPE || type == Type.CHAR_TYPE;
-    }
-
-    public static boolean isIntOrLongPrimitive(Type type) {
-        return isIntPrimitive(type) || type == Type.LONG_TYPE;
-    }
-
-    public static boolean isPrimitive(Type type) {
-        return type.getSort() != Type.OBJECT && type.getSort() != Type.ARRAY;
-    }
-
-    @NotNull
-    public static Type correctElementType(@NotNull Type type) {
-        String internalName = type.getInternalName();
-        assert internalName.charAt(0) == '[';
-        return Type.getType(internalName.substring(1));
-    }
-
-    @NotNull
-    public static Type getArrayType(@NotNull Type componentType) {
-        return Type.getType("[" + componentType.getDescriptor());
-    }
-
-    @Nullable
-    public static PrimitiveType asmPrimitiveTypeToLangPrimitiveType(Type type) {
-        JvmPrimitiveType jvmPrimitiveType = primitiveTypeByAsmSort.get(type.getSort());
-        return jvmPrimitiveType != null ? jvmPrimitiveType.getPrimitiveType() : null;
-    }
-
-    @NotNull
-    public static Method method(@NotNull String name, @NotNull Type returnType, @NotNull Type... parameterTypes) {
-        return new Method(name, Type.getMethodDescriptor(returnType, parameterTypes));
-    }
-
-    public static Type stringValueOfType(Type type) {
-        int sort = type.getSort();
-        return sort == Type.OBJECT || sort == Type.ARRAY
-               ? OBJECT_TYPE
-               : sort == Type.BYTE || sort == Type.SHORT ? Type.INT_TYPE : type;
-    }
-
-    public static void genThrow(@NotNull InstructionAdapter v, @NotNull String exception, @Nullable String message) {
-        v.anew(Type.getObjectType(exception));
-        v.dup();
-        if (message != null) {
-            v.aconst(message);
-            v.invokespecial(exception, "<init>", "(Ljava/lang/String;)V", false);
-        }
-        else {
-            v.invokespecial(exception, "<init>", "()V", false);
-        }
-        v.athrow();
-    }
-
-    public static void genStringBuilderConstructor(InstructionAdapter v) {
-        v.visitTypeInsn(NEW, "java/lang/StringBuilder");
-        v.dup();
-        v.invokespecial("java/lang/StringBuilder", "<init>", "()V", false);
-    }
-
-    public static void genInvertBoolean(InstructionAdapter v) {
-        v.iconst(1);
-        v.xor(Type.INT_TYPE);
-    }
-
-    public static void numConst(int value, Type type, InstructionAdapter v) {
-        if (type == Type.FLOAT_TYPE) {
-            v.fconst(value);
-        }
-        else if (type == Type.DOUBLE_TYPE) {
-            v.dconst(value);
-        }
-        else if (type == Type.LONG_TYPE) {
-            v.lconst(value);
-        }
-        else if (type == Type.CHAR_TYPE || type == Type.BYTE_TYPE || type == Type.SHORT_TYPE || type == Type.INT_TYPE) {
-            v.iconst(value);
-        }
-        else {
-            throw new IllegalArgumentException("Primitive numeric type expected, got: " + type);
-        }
-    }
-
-    public static void swap(InstructionAdapter v, Type stackTop, Type afterTop) {
-        if (stackTop.getSize() == 1) {
-            if (afterTop.getSize() == 1) {
-                v.swap();
-            }
-            else {
-                v.dupX2();
-                v.pop();
-            }
-        }
-        else {
-            if (afterTop.getSize() == 1) {
-                v.dup2X1();
-            }
-            else {
-                v.dup2X2();
-            }
-            v.pop2();
-        }
-    }
-
-    public static void pushDefaultValueOnStack(@NotNull Type type, @NotNull InstructionAdapter v) {
-        v.visitInsn(defaultValueOpcode(type));
-    }
-
-    public static int defaultValueOpcode(@NotNull Type type) {
-        if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
-            return ACONST_NULL;
-        }
-        if (type.getSort() == Type.FLOAT) {
-            return FCONST_0;
-        }
-        if (type.getSort() == Type.DOUBLE) {
-            return DCONST_0;
-        }
-        if (type.getSort() == Type.LONG) {
-            return LCONST_0;
-        }
-        return ICONST_0;
-    }
-
-    public static Type comparisonOperandType(Type left, Type right) {
-        if (left == Type.DOUBLE_TYPE || right == Type.DOUBLE_TYPE) return Type.DOUBLE_TYPE;
-        if (left == Type.FLOAT_TYPE || right == Type.FLOAT_TYPE) return Type.FLOAT_TYPE;
-        if (left == Type.LONG_TYPE || right == Type.LONG_TYPE) return Type.LONG_TYPE;
-        if (left == Type.CHAR_TYPE || right == Type.CHAR_TYPE) return Type.CHAR_TYPE;
-        return Type.INT_TYPE;
-    }
-
-    @NotNull
-    public static Type numberFunctionOperandType(@NotNull Type expectedType) {
-        if (expectedType == Type.SHORT_TYPE || expectedType == Type.BYTE_TYPE || expectedType == Type.CHAR_TYPE) {
-            return Type.INT_TYPE;
-        }
-        return expectedType;
-    }
-
-    public static void pop(@NotNull MethodVisitor v, @NotNull Type type) {
-        if (type.getSize() == 2) {
-            v.visitInsn(Opcodes.POP2);
-        }
-        else {
-            v.visitInsn(Opcodes.POP);
-        }
-    }
-
-    public static void pop2(@NotNull MethodVisitor v, @NotNull Type topOfStack, @NotNull Type afterTop) {
-        if (topOfStack.getSize() == 1 && afterTop.getSize() == 1) {
-            v.visitInsn(POP2);
-        } else {
-            pop(v, topOfStack);
-            pop(v, afterTop);
-        }
-    }
-
-    public static void pop2(@NotNull MethodVisitor v, @NotNull Type type) {
-        if (type.getSize() == 2) {
-            v.visitInsn(Opcodes.POP2);
-            v.visitInsn(Opcodes.POP2);
-        }
-        else {
-            v.visitInsn(Opcodes.POP2);
-        }
-    }
-
-    public static void dup(@NotNull InstructionAdapter v, @NotNull Type type) {
-        dup(v, type.getSize());
-    }
-
-    private static void dup(@NotNull InstructionAdapter v, int size) {
-        if (size == 2) {
-            v.dup2();
-        }
-        else if (size == 1) {
-            v.dup();
-        }
-        else {
-            throw new UnsupportedOperationException();
-        }
-    }
-
-    public static void dupx(@NotNull InstructionAdapter v, @NotNull Type type) {
-        dupx(v, type.getSize());
-    }
-
-    private static void dupx(@NotNull InstructionAdapter v, int size) {
-        if (size == 2) {
-            v.dup2X2();
-        }
-        else if (size == 1) {
-            v.dupX1();
-        }
-        else {
-            throw new UnsupportedOperationException();
-        }
-    }
-
-    // Duplicate the element afterTop and push it on the top of the stack.
-    public static void dupSecond(@NotNull InstructionAdapter v, @NotNull Type topOfStack, @NotNull Type afterTop) {
-        if (afterTop.getSize() == 0) {
-            return;
-        }
-
-        if (topOfStack.getSize() == 0) {
-            dup(v, afterTop);
-        } else if (topOfStack.getSize() == 1 && afterTop.getSize() == 1) {
-            v.dup2();
-            v.pop();
-        } else {
-            swap(v, topOfStack, afterTop);
-            if (topOfStack.getSize() == 1 && afterTop.getSize() == 2) {
-                v.dup2X1();
-            } else if (topOfStack.getSize() == 2 && afterTop.getSize() == 1) {
-                v.dupX2();
-            } else /* top = 2, after top = 2 */ {
-                v.dup2X2();
-            }
-        }
-    }
-
-    public static void dup(@NotNull InstructionAdapter v, @NotNull Type topOfStack, @NotNull Type afterTop) {
-        if (topOfStack.getSize() == 0 && afterTop.getSize() == 0) {
-            return;
-        }
-
-        if (topOfStack.getSize() == 0) {
-            dup(v, afterTop);
-        }
-        else if (afterTop.getSize() == 0) {
-            dup(v, topOfStack);
-        }
-        else if (afterTop.getSize() == 1) {
-            if (topOfStack.getSize() == 1) {
-                dup(v, 2);
-            }
-            else {
-                v.dup2X1();
-                v.pop2();
-                v.dupX2();
-                v.dupX2();
-                v.pop();
-                v.dup2X1();
-            }
-        }
-        else {
-            //Note: it's possible to write dup3 and dup4
-            throw new UnsupportedOperationException("Don't know how generate dup3/dup4 for: " + topOfStack + " and " + afterTop);
-        }
-    }
-
-    public static void writeAnnotationData(
-            @NotNull AnnotationVisitor av, @NotNull String[] data, @NotNull String[] strings
-    ) {
-        AnnotationVisitor dataVisitor = av.visitArray(JvmAnnotationNames.METADATA_DATA_FIELD_NAME);
-        for (String string : data) {
-            dataVisitor.visit(null, string);
-        }
-        dataVisitor.visitEnd();
-
-        AnnotationVisitor stringsVisitor = av.visitArray(JvmAnnotationNames.METADATA_STRINGS_FIELD_NAME);
-        for (String string : strings) {
-            stringsVisitor.visit(null, string);
-        }
-        stringsVisitor.visitEnd();
-    }
-
-    @NotNull
-    public static Type asmTypeByFqNameWithoutInnerClasses(@NotNull FqName fqName) {
-        return Type.getObjectType(internalNameByFqNameWithoutInnerClasses(fqName));
-    }
-
-    @NotNull
-    public static Type asmTypeByClassId(@NotNull ClassId classId) {
-        return Type.getObjectType(classId.asString().replace('.', '$'));
-    }
-
-    @NotNull
-    public static String internalNameByFqNameWithoutInnerClasses(@NotNull FqName fqName) {
-        return JvmClassName.byFqNameWithoutInnerClasses(fqName).getInternalName();
-    }
-
-
-    public static void wrapJavaClassIntoKClass(@NotNull InstructionAdapter v) {
-        v.invokestatic(REFLECTION, "getOrCreateKotlinClass", Type.getMethodDescriptor(K_CLASS_TYPE, getType(Class.class)), false);
-    }
-
-    public static void wrapJavaClassesIntoKClasses(@NotNull InstructionAdapter v) {
-        v.invokestatic(REFLECTION, "getOrCreateKotlinClasses", Type.getMethodDescriptor(K_CLASS_ARRAY_TYPE, getType(Class[].class)), false);
-    }
-
-    @Nullable
-    public static Integer getVisibilityAccessFlag(Visibility visibility) {
-        return visibilityToAccessFlag.get(visibility);
-    }
-}

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

@@ -1,31 +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.
- */
-
-@file:JvmName("CommonVariableAsmNameManglingUtils")
-package org.jetbrains.kotlin.codegen
-
-import org.jetbrains.kotlin.resolve.jvm.checkers.isValidDalvikCharacter
-
-fun mangleNameIfNeeded(name: String): String {
-    if (name.all { it.isValidCharacter() }) {
-        return name
-    }
-
-    return buildString {
-        for (c in name) {
-            if (c.isValidCharacter()) {
-                append(c)
-            } else {
-                val hexString = Integer.toHexString(c.toInt())
-                assert(hexString.length <= 4)
-                append("_u").append(hexString)
-            }
-        }
-    }
-}
-
-private fun Char.isValidCharacter(): Boolean {
-    return this != '$' && this != '-' && isValidDalvikCharacter(this)
-}

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

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.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 val javaLangClassType: Type
-        get() = AsmTypes.JAVA_CLASS_TYPE
-}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/resolve/jvm/checkers/dalvikIdentifierUtils.kt

@@ -1,22 +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.
- */
-
-@file:JvmName("DalvikIdentifierUtils")
-package org.jetbrains.kotlin.resolve.jvm.checkers
-
-fun isValidDalvikIdentifier(identifier: String): Boolean = identifier.all { isValidDalvikCharacter(it) }
-
-// https://source.android.com/devices/tech/dalvik/dex-format.html#string-syntax
-fun isValidDalvikCharacter(c: Char): Boolean = when (c) {
-    in 'A'..'Z' -> true
-    in 'a'..'z' -> true
-    in '0'..'9' -> true
-    '$', '-', '_' -> true
-    in '\u00a1' .. '\u1fff' -> true
-    in '\u2010' .. '\u2027' -> true
-    in '\u2030' .. '\ud7ff' -> true
-    in '\ue000' .. '\uffef' -> true
-    else -> false
-}

compiler/backend.common.jvm/src/org/jetbrains/kotlin/types/AbstractTypeMapper.kt

@@ -1,136 +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.types
-
-import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.codegen.signature.AsmTypeFactory
-import org.jetbrains.kotlin.load.kotlin.JvmDescriptorTypeWriter
-import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
-import org.jetbrains.kotlin.load.kotlin.mapBuiltInType
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes
-import org.jetbrains.kotlin.types.model.*
-import org.jetbrains.org.objectweb.asm.Type
-
-interface TypeMappingContext<Writer : JvmDescriptorTypeWriter<Type>> {
-    val typeContext: TypeSystemCommonBackendContextForTypeMapping
-
-    fun getClassInternalName(typeConstructor: TypeConstructorMarker): String
-    fun Writer.writeGenericType(type: SimpleTypeMarker, asmType: Type, mode: TypeMappingMode)
-}
-
-object AbstractTypeMapper {
-    fun <Writer : JvmDescriptorTypeWriter<Type>> mapClass(context: TypeMappingContext<Writer>, typeConstructor: TypeConstructorMarker): Type {
-        return with(context.typeContext) {
-            when {
-                typeConstructor.isClassTypeConstructor() -> {
-                    mapType(context, typeConstructor.defaultType(), TypeMappingMode.CLASS_DECLARATION)
-                }
-                typeConstructor.isTypeParameter() -> {
-                    mapType(context, typeConstructor.defaultType())
-                }
-                else -> error("Unknown type constructor: $typeConstructor")
-            }
-        }
-    }
-
-    fun <Writer : JvmDescriptorTypeWriter<Type>> mapType(
-        context: TypeMappingContext<Writer>,
-        type: KotlinTypeMarker,
-        mode: TypeMappingMode = TypeMappingMode.DEFAULT,
-        sw: Writer? = null
-    ): Type = context.typeContext.mapType(context, type, mode, sw)
-
-    @OptIn(ExperimentalStdlibApi::class)
-    private fun <Writer : JvmDescriptorTypeWriter<Type>> TypeSystemCommonBackendContextForTypeMapping.mapType(
-        context: TypeMappingContext<Writer>,
-        type: KotlinTypeMarker,
-        mode: TypeMappingMode = TypeMappingMode.DEFAULT,
-        sw: Writer? = null
-    ): Type {
-        if (type !is SimpleTypeMarker) {
-            error("Unexpected type: $type (original Kotlin type=$type of ${type.let { it::class }})")
-        }
-        if (type.isSuspendFunction()) {
-            val argumentsCount = type.argumentsCount()
-            val argumentsList = type.asArgumentList()
-            val arguments = buildList {
-                for (i in 0 until (argumentsCount - 1)) {
-                    this += argumentsList[i].adjustedType()
-                }
-                this += continuationTypeConstructor().typeWithArguments(argumentsList[argumentsCount - 1].adjustedType())
-                this += nullableAnyType()
-            }
-            val runtimeFunctionType = functionNTypeConstructor(arguments.size - 1).typeWithArguments(arguments)
-            return mapType(context, runtimeFunctionType, mode, sw)
-        }
-
-        mapBuiltInType(type, AsmTypeFactory, mode)?.let { builtInType ->
-            return boxTypeIfNeeded(builtInType, mode.needPrimitiveBoxing).also { asmType ->
-                with(context) { sw?.writeGenericType(type, asmType, mode) }
-            }
-        }
-
-        val typeConstructor = type.typeConstructor()
-
-        when {
-            type.isArrayOrNullableArray() -> {
-                val typeArgument = type.asArgumentList()[0]
-                val (variance, memberType) = when {
-                    typeArgument.isStarProjection() -> Variance.OUT_VARIANCE to nullableAnyType()
-                    else -> typeArgument.getVariance().toVariance() to typeArgument.getType()
-                }
-                require(memberType is SimpleTypeMarker)
-
-                val arrayElementType: Type
-                sw?.writeArrayType()
-                if (variance == Variance.IN_VARIANCE) {
-                    arrayElementType = AsmTypes.OBJECT_TYPE
-                    sw?.writeClass(arrayElementType)
-                } else {
-                    arrayElementType = mapType(context, memberType, mode.toGenericArgumentMode(variance, ofArray = true), sw)
-                }
-                sw?.writeArrayEnd()
-                return AsmUtil.getArrayType(arrayElementType)
-            }
-
-            typeConstructor.isClassTypeConstructor() -> {
-                if (typeConstructor.isInlineClass() && !mode.needInlineClassWrapping) {
-                    val expandedType = computeExpandedTypeForInlineClass(type)
-                    require(expandedType is SimpleTypeMarker?)
-                    if (expandedType != null) {
-                        return mapType(context, expandedType, mode.wrapInlineClassesMode(), sw)
-                    }
-                }
-
-                val asmType = if (mode.isForAnnotationParameter && type.isKClass())
-                    AsmTypes.JAVA_CLASS_TYPE
-                else
-                    Type.getObjectType(context.getClassInternalName(typeConstructor))
-
-                with(context) { sw?.writeGenericType(type, asmType, mode) }
-                return asmType
-            }
-
-            typeConstructor.isTypeParameter() -> {
-                val typeParameter = typeConstructor as TypeParameterMarker
-                return mapType(context, typeParameter.representativeUpperBound(), mode, null).also { asmType ->
-                    sw?.writeTypeVariable(typeParameter.getName(), asmType)
-                }
-            }
-
-            else -> throw UnsupportedOperationException("Unknown type $type")
-        }
-    }
-
-    private fun boxTypeIfNeeded(possiblyPrimitiveType: Type, needBoxedType: Boolean): Type =
-        if (needBoxedType) AsmUtil.boxType(possiblyPrimitiveType) else possiblyPrimitiveType
-
-    private fun TypeVariance.toVariance(): Variance = when (this) {
-        TypeVariance.IN -> Variance.IN_VARIANCE
-        TypeVariance.OUT -> Variance.OUT_VARIANCE
-        TypeVariance.INV -> Variance.INVARIANT
-    }
-}

compiler/backend/build.gradle.kts

@@ -10,7 +10,6 @@ dependencies {
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.java"))
     compile(project(":compiler:serialization"))
-    api(project(":compiler:backend.common.jvm"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "asm-all", "guava", rootProject = rootProject) }
     compileOnly(intellijDep()) { includeJars("trove4j", rootProject = rootProject) }
 }

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

@@ -27,7 +27,7 @@ class AccessorForCompanionObjectInstanceFieldDescriptor(
             null, null, emptyList(), emptyList(),
             companionObjectDescriptor.defaultType,
             Modality.FINAL,
-            DescriptorVisibilities.LOCAL
+            Visibilities.LOCAL
         )
     }
 
@@ -41,4 +41,4 @@ class AccessorForCompanionObjectInstanceFieldDescriptor(
     ): FunctionDescriptorImpl {
         throw UnsupportedOperationException("Accessor for companion object $companionObjectDescriptor should not be substituted")
     }
-}
+}

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

@@ -42,11 +42,11 @@ class AccessorForConstructorDescriptor(
     override fun substitute(substitutor: TypeSubstitutor) = super.substitute(substitutor) as ClassConstructorDescriptor
 
     override fun copy(
-            newOwner: DeclarationDescriptor,
-            modality: Modality,
-            visibility: DescriptorVisibility,
-            kind: CallableMemberDescriptor.Kind,
-            copyOverrides: Boolean
+        newOwner: DeclarationDescriptor,
+        modality: Modality,
+        visibility: Visibility,
+        kind: CallableMemberDescriptor.Kind,
+        copyOverrides: Boolean
     ): AccessorForConstructorDescriptor {
         throw UnsupportedOperationException()
     }
@@ -61,7 +61,7 @@ class AccessorForConstructorDescriptor(
             copyValueParameters(calleeDescriptor),
             calleeDescriptor.returnType,
             Modality.FINAL,
-            DescriptorVisibilities.LOCAL
+            Visibilities.LOCAL
         )
     }
 }

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

@@ -43,7 +43,7 @@ class AccessorForFunctionDescriptor(
             copyValueParameters(calleeDescriptor),
             calleeDescriptor.returnType,
             Modality.FINAL,
-            DescriptorVisibilities.LOCAL
+            Visibilities.LOCAL
         )
 
         isSuspend = calleeDescriptor.isSuspend

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

@@ -43,7 +43,7 @@ open class AccessorForPropertyDescriptor private constructor(
     null,
     Annotations.EMPTY,
     Modality.FINAL,
-    DescriptorVisibilities.LOCAL,
+    Visibilities.LOCAL,
     calleeDescriptor.isVar,
     Name.identifier("access$$accessorSuffix"),
     CallableMemberDescriptor.Kind.DECLARATION,
@@ -111,7 +111,7 @@ open class AccessorForPropertyDescriptor private constructor(
         property,
         Annotations.EMPTY,
         Modality.FINAL,
-        DescriptorVisibilities.LOCAL,
+        Visibilities.LOCAL,
         false,
         false,
         false,
@@ -136,7 +136,7 @@ open class AccessorForPropertyDescriptor private constructor(
         property,
         Annotations.EMPTY,
         Modality.FINAL,
-        DescriptorVisibilities.LOCAL,
+        Visibilities.LOCAL,
         false,
         false,
         false,

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;
 
@@ -142,7 +126,7 @@ public abstract class AnnotationCodegen {
                 && !applicableTargets.contains(KotlinTarget.CLASS)
                 && !applicableTargets.contains(KotlinTarget.ANNOTATION_CLASS)) {
                 ClassDescriptor classDescriptor = (ClassDescriptor) annotated;
-                if (classDescriptor.getVisibility() == DescriptorVisibilities.LOCAL) {
+                if (classDescriptor.getVisibility() == Visibilities.LOCAL) {
                     assert applicableTargets.contains(KotlinTarget.EXPRESSION) :
                             "Inconsistent target list for object literal annotation: " + applicableTargets + " on " + annotated;
                     continue;
@@ -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);
         }
     }
@@ -221,7 +195,7 @@ public abstract class AnnotationCodegen {
     private static boolean isInvisibleFromTheOutside(@Nullable DeclarationDescriptor descriptor) {
         if (isAccessor(descriptor)) return true;
         if (descriptor instanceof MemberDescriptor) {
-            return DescriptorAsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
+            return AsmUtil.getVisibilityAccessFlag((MemberDescriptor) descriptor) == Opcodes.ACC_PRIVATE;
         }
         return false;
     }
@@ -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,8 +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.findImplementationFromInterface;
-import static org.jetbrains.kotlin.util.DeclarationUtilKt.findInterfaceImplementation;
 
 public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject> {
     @NotNull
@@ -126,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);
                     }
@@ -237,12 +236,12 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
             @NotNull GenerationState state,
             boolean isErasedInlineClass
     ) {
-        CallableMemberDescriptor actualImplementation =
-                interfaceFun.getKind().isReal() ? interfaceFun : findImplementationFromInterface(interfaceFun);
-        assert actualImplementation != null : "Can't find actual implementation for " + interfaceFun;
         // Skip Java 8 default methods
-        if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(actualImplementation) ||
-            JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(actualImplementation, state.getJvmDefaultMode())) {
+        if (CodegenUtilKt.isDefinitelyNotDefaultImplsMethod(interfaceFun) ||
+            JvmAnnotationUtilKt.isCallableMemberCompiledToJvmDefault(
+                    DescriptorUtils.unwrapFakeOverrideToAnyDeclaration(interfaceFun), state.getJvmDefaultMode()
+            )
+        ) {
             return;
         }
 

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

@@ -50,9 +50,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
+import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CallableReferenceUtilKt.*;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
@@ -140,7 +139,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
         this.asmType = typeMapper.mapClass(classDescriptor);
 
-        visibilityFlag = DescriptorAsmUtil.getVisibilityAccessFlagForClass(classDescriptor);
+        visibilityFlag = AsmUtil.getVisibilityAccessFlagForClass(classDescriptor);
     }
 
     @Override
@@ -590,8 +589,4 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         MemberScope scope = functionClass.getDefaultType().getMemberScope();
         return scope.getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND).iterator().next();
     }
-
-    public boolean isCallableReference() {
-        return functionReferenceTarget != null;
-    }
 }

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMapper
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
@@ -321,7 +321,7 @@ class CollectionStubMethodGenerator(
         )
 
         child.modality = Modality.FINAL
-        child.visibility = DescriptorVisibilities.PUBLIC
+        child.visibility = Visibilities.PUBLIC
         val typeParameters = descriptor.typeConstructor.parameters
         val newTypeParameters = ArrayList<TypeParameterDescriptor>(typeParameters.size)
         DescriptorSubstitutor.substituteTypeParameters(typeParameters, TypeSubstitution.EMPTY, child, newTypeParameters)
@@ -360,7 +360,7 @@ private val READ_ONLY_ARE_EQUAL_TO_MUTABLE_TYPE_CHECKER = KotlinTypeCheckerImpl.
     val firstClass = x.declarationDescriptor as? ClassDescriptor ?: return@withAxioms x == y
     val secondClass = y.declarationDescriptor as? ClassDescriptor ?: return@withAxioms x == y
 
-    val j2k = JavaToKotlinClassMapper
+    val j2k = JavaToKotlinClassMap
     val firstReadOnly = if (j2k.isMutable(firstClass)) j2k.convertMutableToReadOnly(firstClass) else firstClass
     val secondReadOnly = if (j2k.isMutable(secondClass)) j2k.convertMutableToReadOnly(secondClass) else secondClass
     firstReadOnly.typeConstructor == secondReadOnly.typeConstructor

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

@@ -298,7 +298,7 @@ public class ConstructorCodegen {
 
             int k = 1;
             for (FieldInfo info : argsFromClosure) {
-                k = DescriptorAsmUtil.genAssignInstanceFieldFromParam(info, k, iv);
+                k = AsmUtil.genAssignInstanceFieldFromParam(info, k, iv);
             }
         }
     }

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

@@ -127,8 +127,8 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
         substituteCount: Int
     ) {
         val typeMapper = state.typeMapper
-        val isStatic = DescriptorAsmUtil.isStaticMethod(contextKind, functionDescriptor)
-        val baseMethodFlags = DescriptorAsmUtil.getCommonCallableFlags(functionDescriptor, state) and Opcodes.ACC_VARARGS.inv()
+        val isStatic = AsmUtil.isStaticMethod(contextKind, functionDescriptor)
+        val baseMethodFlags = AsmUtil.getCommonCallableFlags(functionDescriptor, state) and Opcodes.ACC_VARARGS.inv()
         val remainingParameters = getRemainingParameters(functionDescriptor.original, substituteCount)
         val remainingParametersDeclarations =
             remainingParameters.map { DescriptorToSourceUtils.descriptorToDeclaration(it) as? KtParameter }
@@ -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(
@@ -268,7 +268,7 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
 
         if (CodegenBinding.canHaveOuter(state.bindingContext, classDescriptor)) return false
 
-        if (DescriptorVisibilities.isPrivate(constructorDescriptor.visibility)) return false
+        if (Visibilities.isPrivate(constructorDescriptor.visibility)) return false
 
         if (constructorDescriptor.valueParameters.isEmpty()) return false
         if (classOrObject is KtClass && hasSecondaryConstructorsWithNoParameters(classOrObject)) return false

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

@@ -1,924 +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.codegen;
-
-import com.google.common.collect.Sets;
-import com.intellij.openapi.util.Pair;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.util.ArrayUtil;
-import kotlin.Unit;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
-import org.jetbrains.kotlin.codegen.binding.CodegenBinding;
-import org.jetbrains.kotlin.codegen.context.CodegenContext;
-import org.jetbrains.kotlin.codegen.intrinsics.HashCode;
-import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods;
-import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
-import org.jetbrains.kotlin.config.JvmDefaultMode;
-import org.jetbrains.kotlin.config.JvmTarget;
-import org.jetbrains.kotlin.config.LanguageFeature;
-import org.jetbrains.kotlin.config.LanguageVersionSettings;
-import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
-import org.jetbrains.kotlin.lexer.KtTokens;
-import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil;
-import org.jetbrains.kotlin.metadata.jvm.serialization.JvmStringTable;
-import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.protobuf.MessageLite;
-import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver;
-import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
-import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver;
-import org.jetbrains.kotlin.resolve.inline.InlineUtil;
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
-import org.jetbrains.kotlin.resolve.jvm.InlineClassManglingRulesKt;
-import org.jetbrains.kotlin.resolve.jvm.RuntimeAssertionInfo;
-import org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt;
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
-import org.jetbrains.kotlin.serialization.DescriptorSerializer;
-import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor;
-import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.kotlin.types.SimpleType;
-import org.jetbrains.org.objectweb.asm.*;
-import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isBoolean;
-import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isPrimitiveClass;
-import static org.jetbrains.kotlin.codegen.AsmUtil.*;
-import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isToArrayFromCollection;
-import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation;
-import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
-import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
-import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
-import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineWithReified;
-import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
-import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmSyntheticAnnotation;
-import static org.jetbrains.kotlin.types.TypeUtils.isNullableType;
-import static org.jetbrains.org.objectweb.asm.Opcodes.*;
-
-public class DescriptorAsmUtil {
-    private static final Set<Type> STRING_BUILDER_OBJECT_APPEND_ARG_TYPES = Sets.newHashSet(
-            getType(String.class),
-            getType(StringBuffer.class),
-            getType(CharSequence.class)
-    );
-
-    private DescriptorAsmUtil() {
-    }
-
-    @NotNull
-    public static String getNameForCapturedReceiverField(
-            @NotNull CallableDescriptor descriptor,
-            @NotNull BindingContext bindingContext,
-            @NotNull LanguageVersionSettings languageVersionSettings
-    ) {
-        return getLabeledThisNameForReceiver(
-                descriptor, bindingContext, languageVersionSettings, LABELED_THIS_FIELD, CAPTURED_RECEIVER_FIELD);
-    }
-
-    @NotNull
-    public static String getNameForReceiverParameter(
-            @NotNull CallableDescriptor descriptor,
-            @NotNull BindingContext bindingContext,
-            @NotNull LanguageVersionSettings languageVersionSettings
-    ) {
-        return getLabeledThisNameForReceiver(
-                descriptor, bindingContext, languageVersionSettings, LABELED_THIS_PARAMETER, RECEIVER_PARAMETER_NAME);
-    }
-
-    @NotNull
-    private static String getLabeledThisNameForReceiver(
-            @NotNull CallableDescriptor descriptor,
-            @NotNull BindingContext bindingContext,
-            @NotNull LanguageVersionSettings languageVersionSettings,
-            @NotNull String prefix,
-            @NotNull String defaultName
-    ) {
-        if (!languageVersionSettings.supportsFeature(LanguageFeature.NewCapturedReceiverFieldNamingConvention)) {
-            return defaultName;
-        }
-
-        Name callableName = null;
-
-        if (descriptor instanceof FunctionDescriptor) {
-            String labelName = bindingContext.get(CodegenBinding.CALL_LABEL_FOR_LAMBDA_ARGUMENT, (FunctionDescriptor) descriptor);
-            if (labelName != null) {
-                return getLabeledThisName(labelName, prefix, defaultName);
-            }
-
-            if (descriptor instanceof VariableAccessorDescriptor) {
-                VariableAccessorDescriptor accessor = (VariableAccessorDescriptor) descriptor;
-                callableName = accessor.getCorrespondingVariable().getName();
-            }
-        }
-
-        if (callableName == null) {
-            callableName = descriptor.getName();
-        }
-
-        if (callableName.isSpecial()) {
-            return defaultName;
-        }
-
-        return getLabeledThisName(callableName.asString(), prefix, defaultName);
-    }
-
-    @NotNull
-    public static Type boxType(@NotNull Type type, @NotNull KotlinType kotlinType, @NotNull KotlinTypeMapper typeMapper) {
-        if (InlineClassesUtilsKt.isInlineClassType(kotlinType)) {
-            return typeMapper.mapTypeAsDeclaration(kotlinType);
-        }
-
-        Type boxedPrimitiveType = boxPrimitiveType(type);
-        return boxedPrimitiveType != null ? boxedPrimitiveType : type;
-    }
-
-    public static boolean isPrimitiveNumberClassDescriptor(DeclarationDescriptor descriptor) {
-        if (!(descriptor instanceof ClassDescriptor)) {
-            return false;
-        }
-        return isPrimitiveClass((ClassDescriptor) descriptor) && !isBoolean((ClassDescriptor) descriptor);
-    }
-
-    public static boolean isAbstractMethod(FunctionDescriptor functionDescriptor, OwnerKind kind, JvmDefaultMode jvmDefaultMode) {
-        return (functionDescriptor.getModality() == Modality.ABSTRACT ||
-                (isJvmInterface(functionDescriptor.getContainingDeclaration()) && !JvmAnnotationUtilKt
-                        .isCompiledToJvmDefault(functionDescriptor, jvmDefaultMode)))
-               && !isStaticMethod(kind, functionDescriptor);
-    }
-
-    public static boolean isStaticMethod(OwnerKind kind, CallableMemberDescriptor functionDescriptor) {
-        return isStaticKind(kind) ||
-               KotlinTypeMapper.isStaticAccessor(functionDescriptor) ||
-               CodegenUtilKt.isJvmStaticInObjectOrClassOrInterface(functionDescriptor);
-    }
-
-    public static boolean isStaticKind(OwnerKind kind) {
-        return kind == OwnerKind.PACKAGE || kind == OwnerKind.DEFAULT_IMPLS || kind == OwnerKind.ERASED_INLINE_CLASS;
-    }
-
-    public static int getMethodAsmFlags(FunctionDescriptor functionDescriptor, OwnerKind kind, GenerationState state) {
-        return getMethodAsmFlags(functionDescriptor, kind, state.getDeprecationProvider(), state.getJvmDefaultMode());
-    }
-
-    public static int getMethodAsmFlags(
-            FunctionDescriptor functionDescriptor,
-            OwnerKind kind,
-            DeprecationResolver deprecationResolver,
-            JvmDefaultMode jvmDefaultMode
-    ) {
-        int flags = getCommonCallableFlags(functionDescriptor, kind, deprecationResolver);
-
-        for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.METHOD_FLAGS) {
-            flags |= flagAnnotation.getJvmFlag(functionDescriptor.getOriginal());
-        }
-
-        if (functionDescriptor.getOriginal().isExternal()) {
-            flags |= Opcodes.ACC_NATIVE;
-        }
-
-        if (CodegenUtilKt.isJvmStaticInCompanionObject(functionDescriptor)) {
-            // Native method will be a member of the class, the companion object method will be delegated to it
-            flags &= ~Opcodes.ACC_NATIVE;
-        }
-
-        if (functionDescriptor.getModality() == Modality.FINAL && !(functionDescriptor instanceof ConstructorDescriptor)) {
-            DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration();
-            if (!(containingDeclaration instanceof ClassDescriptor) ||
-                ((ClassDescriptor) containingDeclaration).getKind() != ClassKind.INTERFACE) {
-                flags |= ACC_FINAL;
-            }
-        }
-
-        if (isStaticMethod(kind, functionDescriptor)) {
-            flags |= ACC_STATIC;
-        }
-
-        if (isAbstractMethod(functionDescriptor, kind, jvmDefaultMode)) {
-            flags |= ACC_ABSTRACT;
-        }
-
-        if (KotlinTypeMapper.isAccessor(functionDescriptor) ||
-            hasJvmSyntheticAnnotation(functionDescriptor) ||
-            isInlineClassWrapperConstructor(functionDescriptor, kind) ||
-            InlineClassDescriptorResolver.isSynthesizedBoxMethod(functionDescriptor) ||
-            InlineClassDescriptorResolver.isSynthesizedUnboxMethod(functionDescriptor)
-        ) {
-            flags |= ACC_SYNTHETIC;
-        }
-
-        return flags;
-    }
-
-    private static boolean isInlineClassWrapperConstructor(@NotNull FunctionDescriptor functionDescriptor, @Nullable OwnerKind kind) {
-        if (!(functionDescriptor instanceof ConstructorDescriptor)) return false;
-        ClassDescriptor classDescriptor = ((ConstructorDescriptor) functionDescriptor).getConstructedClass();
-        return classDescriptor.isInline() && kind == OwnerKind.IMPLEMENTATION;
-    }
-
-    public static int getCommonCallableFlags(FunctionDescriptor functionDescriptor, @NotNull GenerationState state) {
-        return getCommonCallableFlags(functionDescriptor, null, state.getDeprecationProvider());
-    }
-
-    private static int getCommonCallableFlags(
-            FunctionDescriptor functionDescriptor,
-            @Nullable OwnerKind kind,
-            @NotNull DeprecationResolver deprecationResolver
-    ) {
-        int flags = getVisibilityAccessFlag(functionDescriptor, kind);
-        flags |= getVarargsFlag(functionDescriptor);
-        flags |= getDeprecatedAccessFlag(functionDescriptor);
-        if (deprecationResolver.isDeprecatedHidden(functionDescriptor) ||
-            isInlineWithReified(functionDescriptor) ||
-            functionDescriptor.isSuspend() && functionDescriptor.getVisibility().equals(DescriptorVisibilities.PRIVATE)) {
-            flags |= ACC_SYNTHETIC;
-        }
-        return flags;
-    }
-
-    public static int getVisibilityAccessFlag(@NotNull MemberDescriptor descriptor) {
-        return getVisibilityAccessFlag(descriptor, null);
-    }
-
-    private static int getVisibilityAccessFlag(@NotNull MemberDescriptor descriptor, @Nullable OwnerKind kind) {
-        Integer specialCase = specialCaseVisibility(descriptor, kind);
-        if (specialCase != null) {
-            return specialCase;
-        }
-        DescriptorVisibility visibility = descriptor.getVisibility();
-        Integer defaultMapping = getVisibilityAccessFlag(visibility);
-        if (defaultMapping == null) {
-            throw new IllegalStateException(visibility + " is not a valid visibility in backend for " + DescriptorRenderer.DEBUG_TEXT.render(descriptor));
-        }
-        return defaultMapping;
-    }
-
-    @Nullable
-    public static Integer getVisibilityAccessFlag(DescriptorVisibility visibility) {
-        return AsmUtil.getVisibilityAccessFlag(visibility.getDelegate());
-    }
-
-    /*
-        Use this method to get visibility flag for class to define it in byte code (v.defineClass method).
-        For other cases use getVisibilityAccessFlag(MemberDescriptor descriptor)
-        Classes in byte code should be public or package private
-     */
-    public static int getVisibilityAccessFlagForClass(@NotNull ClassDescriptor descriptor) {
-        if (descriptor instanceof SyntheticClassDescriptorForLambda) {
-            return getVisibilityAccessFlagForAnonymous(descriptor);
-        }
-        if (descriptor.getKind() == ClassKind.ENUM_ENTRY) {
-            return NO_FLAG_PACKAGE_PRIVATE;
-        }
-        if (descriptor.getVisibility() == DescriptorVisibilities.PUBLIC ||
-            descriptor.getVisibility() == DescriptorVisibilities.PROTECTED ||
-            // TODO: should be package private, but for now Kotlin's reflection can't access members of such classes
-            descriptor.getVisibility() == DescriptorVisibilities.LOCAL ||
-            descriptor.getVisibility() == DescriptorVisibilities.INTERNAL) {
-            return ACC_PUBLIC;
-        }
-        return NO_FLAG_PACKAGE_PRIVATE;
-    }
-
-    private static int getVisibilityAccessFlagForAnonymous(@NotNull ClassDescriptor descriptor) {
-        return InlineUtil.isInlineOrContainingInline(descriptor.getContainingDeclaration()) ? ACC_PUBLIC : NO_FLAG_PACKAGE_PRIVATE;
-    }
-
-    public static int getSyntheticAccessFlagForLambdaClass(@NotNull ClassDescriptor descriptor) {
-        return descriptor instanceof SyntheticClassDescriptorForLambda &&
-               ((SyntheticClassDescriptorForLambda) descriptor).isCallableReference() ? ACC_SYNTHETIC : 0;
-    }
-
-    public static int calculateInnerClassAccessFlags(@NotNull ClassDescriptor innerClass) {
-        int visibility =
-                innerClass instanceof SyntheticClassDescriptorForLambda
-                ? getVisibilityAccessFlagForAnonymous(innerClass)
-                : innerClass.getVisibility() == DescriptorVisibilities.LOCAL
-                  ? ACC_PUBLIC
-                  : getVisibilityAccessFlag(innerClass);
-        return visibility |
-               getSyntheticAccessFlagForLambdaClass(innerClass) |
-               innerAccessFlagsForModalityAndKind(innerClass) |
-               (innerClass.isInner() ? 0 : ACC_STATIC);
-    }
-
-    private static int innerAccessFlagsForModalityAndKind(@NotNull ClassDescriptor innerClass) {
-        switch (innerClass.getKind()) {
-            case INTERFACE:
-                return ACC_ABSTRACT | ACC_INTERFACE;
-            case ENUM_CLASS:
-                return ACC_FINAL | ACC_ENUM;
-            case ANNOTATION_CLASS:
-                return ACC_ABSTRACT | ACC_ANNOTATION | ACC_INTERFACE;
-            default:
-                Modality modality = innerClass.getModality();
-                if (modality == Modality.FINAL) {
-                    return ACC_FINAL;
-                }
-                else if (modality == Modality.ABSTRACT || modality == Modality.SEALED) {
-                    return ACC_ABSTRACT;
-                }
-        }
-        return 0;
-    }
-
-    public static int getDeprecatedAccessFlag(@NotNull MemberDescriptor descriptor) {
-        if (descriptor instanceof PropertyAccessorDescriptor) {
-            return KotlinBuiltIns.isDeprecated(descriptor)
-                   ? ACC_DEPRECATED
-                   : getDeprecatedAccessFlag(((PropertyAccessorDescriptor) descriptor).getCorrespondingProperty());
-        }
-        else if (KotlinBuiltIns.isDeprecated(descriptor)) {
-            return ACC_DEPRECATED;
-        }
-        return 0;
-    }
-
-    private static int getVarargsFlag(FunctionDescriptor functionDescriptor) {
-        if (!functionDescriptor.getValueParameters().isEmpty()
-            && functionDescriptor.getValueParameters().get(functionDescriptor.getValueParameters().size() - 1)
-                       .getVarargElementType() != null) {
-            return ACC_VARARGS;
-        }
-        return 0;
-    }
-
-    @Nullable
-    private static Integer specialCaseVisibility(@NotNull MemberDescriptor memberDescriptor, @Nullable OwnerKind kind) {
-        DeclarationDescriptor containingDeclaration = memberDescriptor.getContainingDeclaration();
-        DescriptorVisibility memberVisibility = memberDescriptor.getVisibility();
-
-        if (JvmCodegenUtil.isNonIntrinsicPrivateCompanionObjectInInterface(memberDescriptor)) {
-            return ACC_PUBLIC;
-        }
-
-        if (memberDescriptor instanceof FunctionDescriptor &&
-            isInlineClassWrapperConstructor((FunctionDescriptor) memberDescriptor, kind)) {
-            return ACC_PRIVATE;
-        }
-
-        if (kind != OwnerKind.ERASED_INLINE_CLASS &&
-            memberDescriptor instanceof ConstructorDescriptor &&
-            !(memberDescriptor instanceof AccessorForConstructorDescriptor) &&
-            InlineClassManglingRulesKt.shouldHideConstructorDueToInlineClassTypeValueParameters((ConstructorDescriptor) memberDescriptor)
-        ) {
-            return ACC_PRIVATE;
-        }
-
-        if (isInlineOnlyPrivateInBytecode(memberDescriptor)) {
-            return ACC_PRIVATE;
-        }
-
-        if (memberVisibility == DescriptorVisibilities.LOCAL && memberDescriptor instanceof CallableMemberDescriptor) {
-            return ACC_PUBLIC;
-        }
-
-        if (isEnumEntry(memberDescriptor)) {
-            return NO_FLAG_PACKAGE_PRIVATE;
-        }
-
-        if (isToArrayFromCollection(memberDescriptor)) {
-            return ACC_PUBLIC;
-        }
-
-        if (memberDescriptor instanceof ConstructorDescriptor && isAnonymousObject(memberDescriptor.getContainingDeclaration())) {
-            return getVisibilityAccessFlagForAnonymous((ClassDescriptor) memberDescriptor.getContainingDeclaration());
-        }
-
-        if (memberDescriptor instanceof SyntheticJavaPropertyDescriptor) {
-            return getVisibilityAccessFlag(((SyntheticJavaPropertyDescriptor) memberDescriptor).getGetMethod());
-        }
-        if (memberDescriptor instanceof PropertyAccessorDescriptor) {
-            PropertyDescriptor property = ((PropertyAccessorDescriptor) memberDescriptor).getCorrespondingProperty();
-            if (property instanceof SyntheticJavaPropertyDescriptor) {
-                FunctionDescriptor method = memberDescriptor == property.getGetter()
-                                            ? ((SyntheticJavaPropertyDescriptor) property).getGetMethod()
-                                            : ((SyntheticJavaPropertyDescriptor) property).getSetMethod();
-                assert method != null : "No get/set method in SyntheticJavaPropertyDescriptor: " + property;
-                return getVisibilityAccessFlag(method);
-            }
-        }
-
-        if (memberDescriptor instanceof CallableDescriptor && memberVisibility == DescriptorVisibilities.PROTECTED) {
-            for (CallableDescriptor overridden : DescriptorUtils.getAllOverriddenDescriptors((CallableDescriptor) memberDescriptor)) {
-                if (isJvmInterface(overridden.getContainingDeclaration())) {
-                    return ACC_PUBLIC;
-                }
-            }
-        }
-
-        if (!DescriptorVisibilities.isPrivate(memberVisibility)) {
-            return null;
-        }
-
-        if (memberDescriptor instanceof FunctionDescriptor && ((FunctionDescriptor) memberDescriptor).isSuspend()) {
-            return NO_FLAG_PACKAGE_PRIVATE;
-        }
-
-        if (memberDescriptor instanceof AccessorForCompanionObjectInstanceFieldDescriptor) {
-            return NO_FLAG_PACKAGE_PRIVATE;
-        }
-
-        if (memberDescriptor instanceof ConstructorDescriptor && isEnumEntry(containingDeclaration)) {
-            return NO_FLAG_PACKAGE_PRIVATE;
-        }
-
-        return null;
-    }
-
-    public static void genClosureFields(
-            @NotNull CalculatedClosure closure,
-            ClassBuilder v,
-            KotlinTypeMapper typeMapper,
-            @NotNull LanguageVersionSettings languageVersionSettings
-    ) {
-        List<Pair<String, Type>> allFields = new ArrayList<>();
-
-        ClassifierDescriptor captureThis = closure.getCapturedOuterClassDescriptor();
-        if (captureThis != null) {
-            allFields.add(Pair.create(CAPTURED_THIS_FIELD, typeMapper.mapType(captureThis)));
-        }
-
-        KotlinType captureReceiverType = closure.getCapturedReceiverFromOuterContext();
-        if (captureReceiverType != null && !CallableReferenceUtilKt.isForCallableReference(closure)) {
-            String fieldName = closure.getCapturedReceiverFieldName(typeMapper.getBindingContext(), languageVersionSettings);
-            allFields.add(Pair.create(fieldName, typeMapper.mapType(captureReceiverType)));
-        }
-
-        allFields.addAll(closure.getRecordedFields());
-        genClosureFields(allFields, v);
-    }
-
-    public static void genClosureFields(List<Pair<String, Type>> allFields, ClassBuilder builder) {
-        int access = NO_FLAG_PACKAGE_PRIVATE | ACC_SYNTHETIC | ACC_FINAL;
-        for (Pair<String, Type> field : allFields) {
-            builder.newField(JvmDeclarationOrigin.NO_ORIGIN, access, field.first, field.second.getDescriptor(), null, null);
-        }
-    }
-
-    public static int genAssignInstanceFieldFromParam(FieldInfo info, int index, InstructionAdapter iv) {
-        return genAssignInstanceFieldFromParam(info, index, iv, 0, false);
-    }
-
-    public static int genAssignInstanceFieldFromParam(
-            FieldInfo info,
-            int index,
-            InstructionAdapter iv,
-            int ownerIndex,
-            boolean cast
-    ) {
-        assert !info.isStatic();
-        Type fieldType = info.getFieldType();
-        KotlinType fieldKotlinType = info.getFieldKotlinType();
-        KotlinType nullableAny;
-        if (fieldKotlinType != null) {
-            nullableAny = fieldKotlinType.getConstructor().getBuiltIns().getNullableAnyType();
-        } else {
-            nullableAny = null;
-        }
-
-        iv.load(ownerIndex, info.getOwnerType());//this
-        if (cast) {
-            iv.load(index, AsmTypes.OBJECT_TYPE); //param
-            StackValue.coerce(AsmTypes.OBJECT_TYPE, nullableAny, fieldType, fieldKotlinType, iv);
-        } else {
-            iv.load(index, fieldType); //param
-        }
-        iv.visitFieldInsn(PUTFIELD, info.getOwnerInternalName(), info.getFieldName(), fieldType.getDescriptor());
-        index += fieldType.getSize();
-        return index;
-    }
-
-    public static void genInvokeAppendMethod(@NotNull InstructionAdapter v, @NotNull Type type, @Nullable KotlinType kotlinType) {
-        genInvokeAppendMethod(v, type, kotlinType, null);
-    }
-
-    public static void genInvokeAppendMethod(
-            @NotNull InstructionAdapter v,
-            @NotNull Type type,
-            @Nullable KotlinType kotlinType,
-            @Nullable KotlinTypeMapper typeMapper
-    ) {
-        Type appendParameterType;
-
-        CallableMethod specializedToString = getSpecializedToStringCallableMethodOrNull(kotlinType, typeMapper);
-        if (specializedToString != null) {
-            specializedToString.genInvokeInstruction(v);
-            appendParameterType = AsmTypes.JAVA_STRING_TYPE;
-        }
-        else if (kotlinType != null && InlineClassesUtilsKt.isInlineClassType(kotlinType)) {
-            appendParameterType = OBJECT_TYPE;
-            SimpleType nullableAnyType = kotlinType.getConstructor().getBuiltIns().getNullableAnyType();
-            StackValue.coerce(type, kotlinType, appendParameterType, nullableAnyType, v);
-        }
-        else {
-            appendParameterType = stringBuilderAppendType(type);
-        }
-
-        v.invokevirtual("java/lang/StringBuilder", "append", "(" + appendParameterType.getDescriptor() + ")Ljava/lang/StringBuilder;", false);
-    }
-
-    private static Type stringBuilderAppendType(Type type) {
-        switch (type.getSort()) {
-            case Type.OBJECT:
-                return STRING_BUILDER_OBJECT_APPEND_ARG_TYPES.contains(type) ? type : OBJECT_TYPE;
-            case Type.ARRAY:
-                return OBJECT_TYPE;
-            case Type.BYTE:
-            case Type.SHORT:
-                return Type.INT_TYPE;
-            default:
-                return type;
-        }
-    }
-
-    public static StackValue genToString(
-            @NotNull StackValue receiver,
-            @NotNull Type receiverType,
-            @Nullable KotlinType receiverKotlinType,
-            @Nullable KotlinTypeMapper typeMapper
-    ) {
-        return StackValue.operation(JAVA_STRING_TYPE, v -> {
-            CallableMethod specializedToString = getSpecializedToStringCallableMethodOrNull(receiverKotlinType, typeMapper);
-            if (specializedToString != null) {
-                receiver.put(receiverType, receiverKotlinType, v);
-                specializedToString.genInvokeInstruction(v);
-                return null;
-            }
-
-            Type type;
-            KotlinType kotlinType;
-            if (receiverKotlinType != null && InlineClassesUtilsKt.isInlineClassType(receiverKotlinType)) {
-                type = OBJECT_TYPE;
-                kotlinType = receiverKotlinType.getConstructor().getBuiltIns().getNullableAnyType();
-            }
-            else {
-                type = stringValueOfType(receiverType);
-                kotlinType = null;
-            }
-
-            receiver.put(type, kotlinType, v);
-            v.invokestatic("java/lang/String", "valueOf", "(" + type.getDescriptor() + ")Ljava/lang/String;", false);
-            return null;
-        });
-    }
-
-    @Nullable
-    private static CallableMethod getSpecializedToStringCallableMethodOrNull(
-            @Nullable KotlinType receiverKotlinType,
-            @Nullable KotlinTypeMapper typeMapper
-    ) {
-        if (typeMapper == null) return null;
-
-        if (receiverKotlinType == null) return null;
-        if (!InlineClassesUtilsKt.isInlineClassType(receiverKotlinType)) return null;
-        if (receiverKotlinType.isMarkedNullable()) return null;
-
-        DeclarationDescriptor receiverTypeDescriptor = receiverKotlinType.getConstructor().getDeclarationDescriptor();
-        assert receiverTypeDescriptor instanceof ClassDescriptor && ((ClassDescriptor) receiverTypeDescriptor).isInline() :
-                "Inline class type expected: " + receiverKotlinType;
-        ClassDescriptor receiverClassDescriptor = (ClassDescriptor) receiverTypeDescriptor;
-        FunctionDescriptor toStringDescriptor = receiverClassDescriptor.getUnsubstitutedMemberScope()
-                .getContributedFunctions(Name.identifier("toString"), NoLookupLocation.FROM_BACKEND)
-                .stream()
-                .filter(
-                        f -> f.getValueParameters().size() == 0
-                             && KotlinBuiltIns.isString(f.getReturnType())
-                             && f.getDispatchReceiverParameter() != null
-                             && f.getExtensionReceiverParameter() == null
-                )
-                .findFirst()
-                .orElseThrow(() -> new AssertionError("'toString' not found in member scope of " + receiverClassDescriptor));
-
-        return typeMapper.mapToCallableMethod(toStringDescriptor, false, OwnerKind.ERASED_INLINE_CLASS);
-    }
-
-    public static void genHashCode(MethodVisitor mv, InstructionAdapter iv, Type type, JvmTarget jvmTarget) {
-        if (type.getSort() == Type.ARRAY) {
-            Type elementType = correctElementType(type);
-            if (elementType.getSort() == Type.OBJECT || elementType.getSort() == Type.ARRAY) {
-                iv.invokestatic("java/util/Arrays", "hashCode", "([Ljava/lang/Object;)I", false);
-            }
-            else {
-                iv.invokestatic("java/util/Arrays", "hashCode", "(" + type.getDescriptor() + ")I", false);
-            }
-        }
-        else if (type.getSort() == Type.OBJECT) {
-            iv.invokevirtual("java/lang/Object", "hashCode", "()I", false);
-        }
-        else if (type.getSort() == Type.BOOLEAN) {
-            Label end = new Label();
-            iv.dup();
-            iv.ifeq(end);
-            iv.pop();
-            iv.iconst(1);
-            iv.mark(end);
-        }
-        else {
-            if (JvmTarget.JVM_1_6 == jvmTarget) {
-                if (type.getSort() == Type.LONG) {
-                    genLongHashCode(mv, iv);
-                }
-                else if (type.getSort() == Type.DOUBLE) {
-                    iv.invokestatic("java/lang/Double", "doubleToLongBits", "(D)J", false);
-                    genLongHashCode(mv, iv);
-                }
-                else if (type.getSort() == Type.FLOAT) {
-                    iv.invokestatic("java/lang/Float", "floatToIntBits", "(F)I", false);
-                }
-                else { // byte short char int
-                    // do nothing
-                }
-            } else {
-                HashCode.Companion.invokeHashCode(iv, type);
-            }
-        }
-    }
-
-    private static void genLongHashCode(MethodVisitor mv, InstructionAdapter iv) {
-        iv.dup2();
-        iv.iconst(32);
-        iv.ushr(Type.LONG_TYPE);
-        iv.xor(Type.LONG_TYPE);
-        mv.visitInsn(L2I);
-    }
-
-    @NotNull
-    public static StackValue genEqualsForExpressionsOnStack(
-            @NotNull IElementType opToken,
-            @NotNull StackValue left,
-            @NotNull StackValue right
-    ) {
-        Type leftType = left.type;
-        Type rightType = right.type;
-        if (isPrimitive(leftType) && leftType == rightType) {
-            return StackValue.cmp(opToken, leftType, left, right);
-        }
-
-        return StackValue.operation(Type.BOOLEAN_TYPE, v -> {
-            left.put(AsmTypes.OBJECT_TYPE, left.kotlinType, v);
-            right.put(AsmTypes.OBJECT_TYPE, right.kotlinType, v);
-            return genAreEqualCall(v, opToken);
-        });
-    }
-
-    @NotNull
-    public static BranchedValue genTotalOrderEqualsForExpressionOnStack(
-            @NotNull StackValue left,
-            @NotNull StackValue right,
-            @NotNull Type asmType
-    ) {
-        return new BranchedValue(left, right, asmType, Opcodes.IFEQ) {
-            @Override
-            public void condJump(@NotNull Label jumpLabel, @NotNull InstructionAdapter iv, boolean jumpIfFalse) {
-                if (asmType.getSort() == Type.FLOAT) {
-                    left.put(asmType, kotlinType, iv);
-                    right.put(asmType, kotlinType, iv);
-                    iv.invokestatic("java/lang/Float", "compare", "(FF)I", false);
-                    iv.visitJumpInsn(patchOpcode(jumpIfFalse ? Opcodes.IFNE : Opcodes.IFEQ, iv), jumpLabel);
-                } else if (asmType.getSort() == Type.DOUBLE) {
-                    left.put(asmType, kotlinType, iv);
-                    right.put(asmType, kotlinType, iv);
-                    iv.invokestatic("java/lang/Double", "compare", "(DD)I", false);
-                    iv.visitJumpInsn(patchOpcode(jumpIfFalse ? Opcodes.IFNE : Opcodes.IFEQ, iv), jumpLabel);
-                } else {
-                    StackValue value = genEqualsForExpressionsOnStack(KtTokens.EQEQ, left, right);
-                    BranchedValue.Companion.condJump(value, jumpLabel, jumpIfFalse, iv);
-                }
-            }
-        };
-    }
-
-    @NotNull
-    public static StackValue genEqualsBoxedOnStack(@NotNull IElementType opToken) {
-        return StackValue.operation(Type.BOOLEAN_TYPE, v -> genAreEqualCall(v, opToken));
-    }
-
-    public static void genAreEqualCall(InstructionAdapter v) {
-        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", "(Ljava/lang/Object;Ljava/lang/Object;)Z", false);
-    }
-
-    @NotNull
-    private static Unit genAreEqualCall(InstructionAdapter v, @NotNull IElementType opToken) {
-        genAreEqualCall(v);
-
-        if (opToken == KtTokens.EXCLEQ || opToken == KtTokens.EXCLEQEQEQ) {
-            genInvertBoolean(v);
-        }
-
-        return Unit.INSTANCE;
-    }
-
-    public static void genIEEE754EqualForNullableTypesCall(InstructionAdapter v, Type left, Type right) {
-        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", "(" + left.getDescriptor() + right.getDescriptor() + ")Z", false);
-    }
-
-    public static void genIncrement(Type baseType, int myDelta, InstructionAdapter v) {
-        Type operationType = numberFunctionOperandType(baseType);
-        numConst(myDelta, operationType, v);
-        v.add(operationType);
-        StackValue.coerce(operationType, baseType, v);
-    }
-
-    static void genNotNullAssertionsForParameters(
-            @NotNull InstructionAdapter v,
-            @NotNull GenerationState state,
-            @NotNull FunctionDescriptor descriptor,
-            @NotNull FrameMap frameMap
-    ) {
-        if (state.isParamAssertionsDisabled()) return;
-        // currently when resuming a suspend function we pass default values instead of real arguments (i.e. nulls for references)
-        if (descriptor.isSuspend()) return;
-
-        if (getVisibilityAccessFlag(descriptor) == ACC_PRIVATE) {
-            // Private method is not accessible from other classes, no assertions needed,
-            // unless we have a private operator function, in which we should generate a parameter assertion for an extension receiver.
-
-            // HACK: this provides "fail fast" behavior for operator functions.
-            // Such functions can be invoked in operator conventions desugaring,
-            // which is currently done on ad hoc basis in ExpressionCodegen.
-
-            if (state.isReceiverAssertionsDisabled()) return;
-            if (descriptor.isOperator()) {
-                ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
-                if (receiverParameter != null) {
-                    String name = getNameForReceiverParameter(descriptor, state.getBindingContext(), state.getLanguageVersionSettings());
-                    genParamAssertion(v, state, frameMap, receiverParameter, name, descriptor);
-                }
-            }
-            return;
-        }
-
-        ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
-        if (receiverParameter != null) {
-            String name = getNameForReceiverParameter(descriptor, state.getBindingContext(), state.getLanguageVersionSettings());
-            genParamAssertion(v, state, frameMap, receiverParameter, name, descriptor);
-        }
-
-        for (ValueParameterDescriptor parameter : descriptor.getValueParameters()) {
-            genParamAssertion(v, state, frameMap, parameter, parameter.getName().asString(), descriptor);
-        }
-    }
-
-    private static void genParamAssertion(
-            @NotNull InstructionAdapter v,
-            @NotNull GenerationState state,
-            @NotNull FrameMap frameMap,
-            @NotNull ParameterDescriptor parameter,
-            @NotNull String name,
-            @NotNull FunctionDescriptor containingDeclaration
-    ) {
-        KotlinType type = parameter.getType();
-        if (isNullableType(type) || InlineClassesUtilsKt.isNullableUnderlyingType(type)) return;
-
-        Type asmType = state.getTypeMapper().mapType(type);
-        if (asmType.getSort() == Type.OBJECT || asmType.getSort() == Type.ARRAY) {
-            StackValue value;
-            if (JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(containingDeclaration) ||
-                JvmCodegenUtil.isDeclarationOfBigArityCreateCoroutineMethod(containingDeclaration)) {
-                int index = getIndexOfParameterInVarargInvokeArray(parameter);
-                value = StackValue.arrayElement(
-                        OBJECT_TYPE, null, StackValue.local(1, getArrayType(OBJECT_TYPE)), StackValue.constant(index)
-                );
-            }
-            else {
-                int index = frameMap.getIndex(parameter);
-                value = StackValue.local(index, asmType);
-            }
-            value.put(asmType, v);
-            v.visitLdcInsn(name);
-            String methodName = state.getUnifiedNullChecks() ? "checkNotNullParameter" : "checkParameterIsNotNull";
-            v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false);
-        }
-    }
-
-    @NotNull
-    public static StackValue genNotNullAssertions(
-            @NotNull GenerationState state,
-            @NotNull StackValue stackValue,
-            @Nullable RuntimeAssertionInfo runtimeAssertionInfo
-    ) {
-        if (state.isCallAssertionsDisabled()) return stackValue;
-        if (runtimeAssertionInfo == null || !runtimeAssertionInfo.getNeedNotNullAssertion()) return stackValue;
-
-        return new StackValue(stackValue.type, stackValue.kotlinType) {
-            @Override
-            public void putSelector(@NotNull Type type, @Nullable KotlinType kotlinType, @NotNull InstructionAdapter v) {
-                Type innerType = stackValue.type;
-                KotlinType innerKotlinType = stackValue.kotlinType;
-                stackValue.put(innerType, innerKotlinType, v);
-                if (innerType.getSort() == Type.OBJECT || innerType.getSort() == Type.ARRAY) {
-                    v.dup();
-                    v.visitLdcInsn(runtimeAssertionInfo.getMessage());
-                    String methodName = state.getUnifiedNullChecks() ? "checkNotNullExpressionValue" : "checkExpressionValueIsNotNull";
-                    v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false);
-                }
-                StackValue.coerce(innerType, innerKotlinType, type, kotlinType, v);
-            }
-        };
-    }
-
-    private static int getIndexOfParameterInVarargInvokeArray(@NotNull ParameterDescriptor parameter) {
-        if (parameter instanceof ReceiverParameterDescriptor) return 0;
-
-        DeclarationDescriptor container = parameter.getContainingDeclaration();
-        assert parameter instanceof ValueParameterDescriptor : "Non-extension-receiver parameter must be a value parameter: " + parameter;
-        int extensionShift = ((CallableDescriptor) container).getExtensionReceiverParameter() == null ? 0 : 1;
-
-        return extensionShift + ((ValueParameterDescriptor) parameter).getIndex();
-    }
-
-    // At the beginning of the vararg invoke of a function with big arity N, generates an assert that the vararg parameter has N elements
-    public static void generateVarargInvokeArityAssert(InstructionAdapter v, int functionArity) {
-        Label start = new Label();
-        v.load(1, getArrayType(OBJECT_TYPE));
-        v.arraylength();
-        v.iconst(functionArity);
-        v.ificmpeq(start);
-        v.visitLdcInsn("Vararg argument must contain " + functionArity + " elements.");
-        v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "throwIllegalArgument", "(Ljava/lang/String;)V", false);
-        v.visitLabel(start);
-    }
-
-    public static boolean isInstancePropertyWithStaticBackingField(@NotNull PropertyDescriptor propertyDescriptor) {
-        return propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE &&
-               isObject(propertyDescriptor.getContainingDeclaration());
-    }
-
-    public static int getVisibilityForBackingField(@NotNull PropertyDescriptor propertyDescriptor, boolean isDelegate) {
-        boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
-        if (isDelegate || isExtensionProperty) {
-            return ACC_PRIVATE;
-        }
-        else {
-            return propertyDescriptor.isLateInit() || isConstOrHasJvmFieldAnnotation(propertyDescriptor)
-                   ? getVisibilityAccessFlag(descriptorForVisibility(propertyDescriptor))
-                   : ACC_PRIVATE;
-        }
-    }
-
-    private static MemberDescriptor descriptorForVisibility(@NotNull PropertyDescriptor propertyDescriptor) {
-        if (!propertyDescriptor.isVar()) {
-            return propertyDescriptor;
-        }
-        else {
-            return propertyDescriptor.getSetter() != null ? propertyDescriptor.getSetter() : propertyDescriptor;
-        }
-    }
-
-    public static boolean isPropertyWithBackingFieldCopyInOuterClass(@NotNull PropertyDescriptor propertyDescriptor) {
-        DeclarationDescriptor propertyContainer = propertyDescriptor.getContainingDeclaration();
-        return propertyDescriptor.isConst()
-               && isCompanionObject(propertyContainer) && isJvmInterface(propertyContainer.getContainingDeclaration())
-               && getVisibilityForBackingField(propertyDescriptor, false) == ACC_PUBLIC;
-    }
-
-    public static void writeAnnotationData(
-            @NotNull AnnotationVisitor av,
-            @NotNull DescriptorSerializer serializer,
-            @NotNull MessageLite message
-    ) {
-        writeAnnotationData(av, message, (JvmStringTable) serializer.getStringTable());
-    }
-
-    public static void writeAnnotationData(
-            @NotNull AnnotationVisitor av, @NotNull MessageLite message, @NotNull JvmStringTable stringTable
-    ) {
-        AsmUtil.writeAnnotationData(av, JvmProtoBufUtil.writeData(message, stringTable), ArrayUtil.toStringArray(stringTable.getStrings()));
-    }
-
-    public static void putJavaLangClassInstance(
-            @NotNull InstructionAdapter v,
-            @NotNull Type type,
-            @Nullable KotlinType kotlinType,
-            @NotNull KotlinTypeMapper typeMapper
-    ) {
-        if (kotlinType != null && InlineClassesUtilsKt.isInlineClassType(kotlinType)) {
-            v.aconst(boxType(type, kotlinType, typeMapper));
-        }
-        else if (isPrimitive(type)) {
-            v.getstatic(AsmUtil.boxType(type).getInternalName(), "TYPE", "Ljava/lang/Class;");
-        }
-        else {
-            v.aconst(type);
-        }
-    }
-
-    public static int getReceiverIndex(@NotNull CodegenContext context, @NotNull CallableMemberDescriptor descriptor) {
-        OwnerKind kind = context.getContextKind();
-        //Trait always should have this descriptor
-        return kind != OwnerKind.DEFAULT_IMPLS && isStaticMethod(kind, descriptor) ? 0 : 1;
-    }
-}

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.genTotalOrderEqualsForExpressionOnStack
+import org.jetbrains.kotlin.codegen.AsmUtil.genTotalOrderEqualsForExpressionOnStack
 import org.jetbrains.kotlin.codegen.context.ClassContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper

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

@@ -51,9 +51,9 @@ import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.KtTokens;
-import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
-import org.jetbrains.kotlin.load.kotlin.DescriptorBasedTypeSignatureMappingKt;
+import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.kotlin.MethodSignatureMappingKt;
+import org.jetbrains.kotlin.load.kotlin.TypeSignatureMappingKt;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
@@ -97,11 +97,8 @@ import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isInt;
-import static org.jetbrains.kotlin.codegen.AsmUtil.boxType;
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.*;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.boxType;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.*;
@@ -176,7 +173,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return null;
     }
 
-    public static class BlockStackElement {
+    static class BlockStackElement {
     }
 
     static class LoopBlockStackElement extends BlockStackElement {
@@ -315,8 +312,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
             stackValue = suspendFunctionTypeWrapperIfNeeded(selector, stackValue);
 
-            stackValue = coerceAndBoxInlineClassIfNeeded(selector, stackValue);
-
             RuntimeAssertionInfo runtimeAssertionInfo = null;
             if (selector instanceof KtExpression) {
                 KtExpression expression = (KtExpression) selector;
@@ -365,53 +360,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         return stackValue;
     }
 
-    private StackValue coerceAndBoxInlineClassIfNeeded(KtElement selector, StackValue stackValue) {
-        ResolvedCall<? extends CallableDescriptor> resolvedCall = CallUtilKt.getResolvedCall(selector, bindingContext);
-        if (resolvedCall == null) return stackValue;
-        CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
-        if (!(descriptor instanceof FunctionDescriptor)) return stackValue;
-        FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
-        if (!functionDescriptor.isSuspend()) return stackValue;
-
-        KotlinType unboxedInlineClass = CoroutineCodegenUtilKt
-                .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(functionDescriptor, typeMapper);
-
-        StackValue stackValueToWrap = stackValue;
-        KotlinType originalKotlinType;
-        if (unboxedInlineClass != null) {
-            originalKotlinType = unboxedInlineClass;
-        } else {
-            originalKotlinType = stackValueToWrap.kotlinType;
-        }
-        Type originalType;
-        if (unboxedInlineClass != null) {
-            originalType = typeMapper.mapType(unboxedInlineClass);
-        } else {
-            originalType = stackValueToWrap.type;
-        }
-
-        stackValue = new StackValue(originalType, originalKotlinType) {
-            @Override
-            public void putSelector(
-                    @NotNull Type type, @Nullable KotlinType kotlinType, @NotNull InstructionAdapter v
-            ) {
-                if (((originalKotlinType != null && InlineClassesUtilsKt.isInlineClassType(originalKotlinType)) ||
-                    (kotlinType != null && InlineClassesUtilsKt.isInlineClassType(kotlinType)))
-                ) {
-                    stackValueToWrap.put(v);
-                    // Suspend functions always return Ljava/lang/Object;, so, before inline-class boxing/unboxing we need to generate CHECKCAST
-                    StackValue.coerce(OBJECT_TYPE, originalType, v);
-                    // Box/unbox inline class
-                    StackValue.coerce(originalType, originalKotlinType, type, kotlinType, v);
-                } else {
-                    // No inline class -> usual coerce is enough
-                    stackValueToWrap.put(type, kotlinType, v);
-                }
-            }
-        };
-        return stackValue;
-    }
-
     public StackValue gen(KtElement expr) {
         StackValue tempVar = tempVariables.get(expr);
         return tempVar != null ? tempVar : genQualified(StackValue.none(), expr);
@@ -1528,7 +1476,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             assert !functionIndex.isEmpty();
 
             String localVariableName = AsmUtil.LOCAL_FUNCTION_VARIABLE_PREFIX
-                    + CommonVariableAsmNameManglingUtils.mangleNameIfNeeded(functionDescriptor.getName().asString())
+                    + VariableAsmNameManglingUtils.mangleNameIfNeeded(functionDescriptor.getName().asString())
                     + "$" + functionIndex;
 
             v.visitLocalVariable(localVariableName, type.getDescriptor(), null, scopeStart, blockEnd, index);
@@ -1706,32 +1654,12 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             Type returnType;
             KotlinType returnKotlinType;
             if (isNonLocalReturn) {
-                // This is inline lambda. Find inline-site and check, whether it is suspend functions returning unboxed inline class
-                CodegenContext<?> inlineSiteContext = this.context.getFirstCrossInlineOrNonInlineContext();
-                KotlinType originalInlineClass = null;
-                if (inlineSiteContext instanceof MethodContext) {
-                     originalInlineClass = CoroutineCodegenUtilKt
-                            .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
-                                    ((MethodContext) inlineSiteContext).getFunctionDescriptor(), typeMapper);
-                }
-                if (originalInlineClass != null) {
-                    returnType = typeMapper.mapType(originalInlineClass);
-                    returnKotlinType = originalInlineClass;
-                } else {
-                    returnType = nonLocalReturn.returnType.getType();
-                    returnKotlinType = nonLocalReturn.returnType.getKotlinType();
-                }
+                returnType = nonLocalReturn.returnType.getType();
+                returnKotlinType = nonLocalReturn.returnType.getKotlinType();
             }
             else {
-                KotlinType originalInlineClass = CoroutineCodegenUtilKt
-                        .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(context.getFunctionDescriptor(), typeMapper);
-                if (originalInlineClass != null) {
-                    returnType = typeMapper.mapType(originalInlineClass);
-                    returnKotlinType = originalInlineClass;
-                } else {
-                    returnType = this.returnType;
-                    returnKotlinType = this.context.getFunctionDescriptor().getReturnType();
-                }
+                returnType = this.returnType;
+                returnKotlinType = typeMapper.getReturnValueType(this.context.getFunctionDescriptor());
             }
             StackValue valueToReturn = returnedExpression != null ? gen(returnedExpression) : StackValue.none();
 
@@ -1786,7 +1714,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
                     return new NonLocalReturnInfo(
                             new JvmKotlinType(
                                     typeMapper.mapReturnType(containingFunction),
-                                    containingFunction.getReturnType()
+                                    typeMapper.getReturnValueType(containingFunction)
                             ),
                             FIRST_FUN_LABEL
                     );
@@ -1816,27 +1744,18 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         FunctionDescriptor originalSuspendLambdaDescriptor = getOriginalSuspendLambdaDescriptorFromContext(context);
         boolean isVoidCoroutineLambda =
-                originalSuspendLambdaDescriptor != null && DescriptorBasedTypeSignatureMappingKt
-                        .hasVoidReturnType(originalSuspendLambdaDescriptor);
-
-        KotlinType originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass =
-                CoroutineCodegenUtilKt.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
-                        context.getFunctionDescriptor(), typeMapper);
+                originalSuspendLambdaDescriptor != null && TypeSignatureMappingKt.hasVoidReturnType(originalSuspendLambdaDescriptor);
 
         // If generating body for named block-bodied function or Unit-typed coroutine lambda, generate it as sequence of statements
         Type typeForExpression =
                 isBlockedNamedFunction || isVoidCoroutineLambda
                 ? Type.VOID_TYPE
-                : originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass != null
-                  ? typeMapper.mapType(originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass)
-                  : returnType;
+                : returnType;
 
         KotlinType kotlinTypeForExpression =
                 isBlockedNamedFunction || isVoidCoroutineLambda
                 ? null
-                : originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass != null
-                  ? originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass
-                  : context.getFunctionDescriptor().getReturnType();
+                : typeMapper.getReturnValueType(context.getFunctionDescriptor());
 
         gen(expr, typeForExpression, kotlinTypeForExpression);
 
@@ -2255,14 +2174,14 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
 
-        boolean isBackingFieldMovedFromCompanion = DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
+        boolean isBackingFieldMovedFromCompanion = JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
         AccessorKind fieldAccessorKind;
         if (skipLateinitAssertion) {
             fieldAccessorKind = AccessorKind.LATEINIT_INTRINSIC;
         }
         else if (isBackingFieldMovedFromCompanion &&
                  (forceField ||
-                  (DescriptorVisibilities.isPrivate(propertyDescriptor.getVisibility()) &&
+                  (Visibilities.isPrivate(propertyDescriptor.getVisibility()) &&
                    isDefaultAccessor(propertyDescriptor.getGetter()) && isDefaultAccessor(propertyDescriptor.getSetter())))) {
             fieldAccessorKind = JvmCodegenUtil.isDebuggerContext(context) ? AccessorKind.NORMAL : AccessorKind.IN_CLASS_COMPANION;
         }
@@ -2275,7 +2194,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             fieldAccessorKind = AccessorKind.NORMAL;
         }
         boolean isStaticBackingField = DescriptorUtils.isStaticDeclaration(propertyDescriptor) ||
-                                       DescriptorAsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor);
+                                       AsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor);
         boolean isSuper = superCallTarget != null;
         boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
 
@@ -2288,7 +2207,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         CodegenContext<?> backingFieldContext = getBackingFieldContext(fieldAccessorKind, containingDeclaration);
         boolean isPrivateProperty =
                 fieldAccessorKind != AccessorKind.NORMAL &&
-                (DescriptorAsmUtil.getVisibilityForBackingField(propertyDescriptor, isDelegatedProperty) & ACC_PRIVATE) != 0;
+                (AsmUtil.getVisibilityForBackingField(propertyDescriptor, isDelegatedProperty) & ACC_PRIVATE) != 0;
         DeclarationDescriptor ownerDescriptor;
         boolean skipPropertyAccessors;
 
@@ -2305,9 +2224,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
             if (!skipPropertyAccessors) {
                 if (isBackingFieldMovedFromCompanion && context.getContextDescriptor() instanceof AccessorForPropertyBackingField) {
-                    CodegenContext<?> parentContext = backingFieldContext.getParentContext();
-                    propertyDescriptor =
-                            parentContext.getAccessor(propertyDescriptor, AccessorKind.IN_CLASS_COMPANION, delegateType, superCallTarget);
+                    propertyDescriptor = (PropertyDescriptor) backingFieldContext.getParentContext()
+                            .getAccessor(propertyDescriptor, AccessorKind.IN_CLASS_COMPANION, delegateType, superCallTarget);
                 }
                 else {
                     propertyDescriptor =
@@ -2335,7 +2253,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             skipPropertyAccessors = forceField;
 
             if (JvmCodegenUtil.isDebuggerContext(context)
-                && DescriptorVisibilities.isPrivate(propertyDescriptor.getVisibility())
+                && Visibilities.isPrivate(propertyDescriptor.getVisibility())
                 && bindingContext.get(BACKING_FIELD_REQUIRED, propertyDescriptor) == Boolean.TRUE
             ) {
                 skipPropertyAccessors = true;
@@ -2694,7 +2612,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         SuspensionPointKind suspensionPointKind =
                 CoroutineCodegenUtilKt.isSuspensionPoint(resolvedCall, this, state.getLanguageVersionSettings());
-        boolean maybeSuspensionPoint = suspensionPointKind != SuspensionPointKind.NEVER && !insideCallableReference();
+        boolean maybeSuspensionPoint = suspensionPointKind != SuspensionPointKind.NEVER;
         boolean isConstructor = resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor;
         if (!(callableMethod instanceof IntrinsicWithSpecialReceiver)) {
             putReceiverAndInlineMarkerIfNeeded(callableMethod, resolvedCall, receiver, maybeSuspensionPoint, isConstructor);
@@ -2738,23 +2656,11 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         callGenerator.genCall(callableMethod, resolvedCall, defaultMaskWasGenerated, this);
 
         if (maybeSuspensionPoint) {
-            // The order is important! Do not reorder!
-            // CoroutineTransformerMethodVisitor expects the marker exactly in this order.
             addReturnsUnitMarkerIfNecessary(v, resolvedCall);
             addSuspendMarker(v, false, suspensionPointKind == SuspensionPointKind.NOT_INLINE);
-            addUnboxInlineClassMarkersIfNeeded(v, resolvedCall.getResultingDescriptor(), typeMapper);
             addInlineMarker(v, false);
         }
 
-        // If a suspend function returns unboxed inline class, we should check for COROUTINE_SUSPENDED and only then box the inline class.
-        if (insideCallableReference() && resolvedCall.getResultingDescriptor() instanceof FunctionDescriptor) {
-            KotlinType unboxedInlineClass = CoroutineCodegenUtilKt.originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(
-                    (FunctionDescriptor) resolvedCall.getResultingDescriptor(), typeMapper);
-            if (unboxedInlineClass != null) {
-                CoroutineCodegenUtilKt.generateCoroutineSuspendedCheck(v, state.getLanguageVersionSettings());
-            }
-        }
-
         KotlinType returnType = resolvedCall.getResultingDescriptor().getReturnType();
         if (returnType != null && KotlinBuiltIns.isNothing(returnType)) {
             if (state.getUseKotlinNothingValueException()) {
@@ -2768,10 +2674,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         }
     }
 
-    private boolean insideCallableReference() {
-        return (parentCodegen instanceof ClosureCodegen) && ((ClosureCodegen) parentCodegen).isCallableReference();
-    }
-
     private void putReceiverAndInlineMarkerIfNeeded(
             @NotNull Callable callableMethod,
             @NotNull ResolvedCall<?> resolvedCall,
@@ -2933,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;
@@ -3034,7 +2936,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             return null;
         }
 
-        int accessFlag = DescriptorAsmUtil.getVisibilityAccessFlag(companionObjectDescriptor);
+        int accessFlag = AsmUtil.getVisibilityAccessFlag(companionObjectDescriptor);
 
         CodegenContext context = contextBeforeInline.getFirstCrossInlineOrNonInlineContext();
         boolean isInlineMethodContext = context.isInlineMethodContext();
@@ -4004,7 +3906,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         Type rightType = right754Type.isNullable ? AsmUtil.boxType(right754Type.type) : right754Type.type;
         gen(right, rightType);
 
-        DescriptorAsmUtil.genIEEE754EqualForNullableTypesCall(v, leftType, rightType);
+        AsmUtil.genIEEE754EqualForNullableTypesCall(v, leftType, rightType);
 
         if (opToken == KtTokens.EXCLEQ) {
             genInvertBoolean(v);
@@ -4201,14 +4103,15 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         TypeAndNullability right754Type = calcTypeForIeee754ArithmeticIfNeeded(right, getRightOperandType(primitiveNumericComparisonInfo));
         boolean isSame754ArithmeticTypes = left754Type != null && right754Type != null && left754Type.type.equals(right754Type.type);
         boolean properIeee754Comparisons = shouldUseProperIeee754Comparisons();
-        boolean isStandardCompareTo = primitiveNumericComparisonInfo != null;
 
-        if (properIeee754Comparisons && isStandardCompareTo && left754Type != null && right754Type != null) {
+        if (properIeee754Comparisons && left754Type != null && right754Type != null) {
             type = comparisonOperandType(left754Type.type, right754Type.type);
+            //type = comparisonOperandType(leftType, rightType);
             leftValue = gen(left);
             rightValue = gen(right);
         }
-        else if (!properIeee754Comparisons && isStandardCompareTo &&
+        else if (!properIeee754Comparisons &&
+                 state.getIntrinsics().getIntrinsic((FunctionDescriptor) resolvedCall.getResultingDescriptor()) instanceof CompareTo &&
                  ((isPrimitive(leftType) && isPrimitive(rightType)) || isSame754ArithmeticTypes)) {
             type = isSame754ArithmeticTypes ? left754Type.type : comparisonOperandType(leftType, rightType);
             leftValue = gen(left);
@@ -5148,9 +5051,7 @@ The "returned" value of try expression with no finally is either the last expres
                 return Unit.INSTANCE;
             }
 
-            CodegenUtilKt.generateAsCast(
-                    v, rightKotlinType, boxedRightType, safeAs, state.getLanguageVersionSettings(), state.getUnifiedNullChecks()
-            );
+            CodegenUtilKt.generateAsCast(v, rightKotlinType, boxedRightType, safeAs, state.getLanguageVersionSettings());
 
             return Unit.INSTANCE;
         });

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.CompanionObjectMapping;
-import org.jetbrains.kotlin.builtins.CompanionObjectMappingUtilsKt;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.load.java.JvmAbi;
@@ -25,7 +24,7 @@ public class FieldInfo {
             throw new UnsupportedOperationException("Can't create singleton field for class: " + classDescriptor);
         }
 
-        if (isNonCompanionObject(classDescriptor) || CompanionObjectMappingUtilsKt.isMappedIntrinsicCompanionObject(CompanionObjectMapping.INSTANCE, classDescriptor)) {
+        if (isNonCompanionObject(classDescriptor) || CompanionObjectMapping.INSTANCE.isMappedIntrinsicCompanionObject(classDescriptor)) {
             return createSingletonViaInstance(classDescriptor, typeMapper, JvmAbi.INSTANCE_FIELD);
         }
 

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;
@@ -67,15 +70,13 @@ import java.io.StringWriter;
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
-import static org.jetbrains.kotlin.codegen.AsmUtil.boxType;
+import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.generateBridgeForMainFunctionIfNecessary;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
 import static org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.isAccessor;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION;
-import static org.jetbrains.kotlin.descriptors.ModalityUtilsKt.isOverridable;
+import static org.jetbrains.kotlin.descriptors.ModalityKt.isOverridable;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.getSourceFromDescriptor;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
@@ -85,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;
@@ -194,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
@@ -206,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()
@@ -220,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) {
@@ -288,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)) {
@@ -305,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
@@ -506,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;
 
@@ -523,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();
@@ -536,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());
             }
         }
     }
@@ -611,7 +598,7 @@ public class FunctionCodegen {
         else if (isCompatibilityStubInDefaultImpls(functionDescriptor, context, jvmDefaultMode)) {
             FunctionDescriptor compatibility = ((DefaultImplsClassContext) context.getParentContext()).getInterfaceContext()
                     .getAccessorForJvmDefaultCompatibility(functionDescriptor);
-            int flags = DescriptorAsmUtil.getMethodAsmFlags(functionDescriptor, OwnerKind.DEFAULT_IMPLS, context.getState());
+            int flags = AsmUtil.getMethodAsmFlags(functionDescriptor, OwnerKind.DEFAULT_IMPLS, context.getState());
             assert (flags & Opcodes.ACC_ABSTRACT) == 0 : "Interface method with body should be non-abstract" + functionDescriptor;
             CallableMethod method = typeMapper.mapToCallableMethod(compatibility, false);
 
@@ -619,7 +606,7 @@ public class FunctionCodegen {
                     true, mv,
                     method.getAsmMethod(),
                     method.getOwner().getInternalName(),
-                    true, signature.getReturnType());
+                    true);
             methodEnd = new Label();
         }
         else {
@@ -723,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(
@@ -763,7 +752,7 @@ public class FunctionCodegen {
         generateLocalVariablesForParameters(mv,
                                             jvmMethodSignature, functionDescriptor,
                                             thisType, methodBegin, methodEnd, functionDescriptor.getValueParameters(),
-                                            DescriptorAsmUtil.isStaticMethod(ownerKind, functionDescriptor), state
+                                            AsmUtil.isStaticMethod(ownerKind, functionDescriptor), state
         );
     }
 
@@ -811,7 +800,7 @@ public class FunctionCodegen {
                             : nameForDestructuredParameter;
                     break;
                 case RECEIVER:
-                    parameterName = DescriptorAsmUtil.getNameForReceiverParameter(
+                    parameterName = AsmUtil.getNameForReceiverParameter(
                             functionDescriptor, typeMapper.getBindingContext(), state.getLanguageVersionSettings());
                     break;
                 case OUTER:
@@ -860,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();
@@ -883,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(
@@ -923,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) {
@@ -1062,7 +1037,7 @@ public class FunctionCodegen {
         // or all return types are supertypes of inline class (and can't be inline classes).
 
         for (DescriptorBasedFunctionHandleForJvm handle : bridge.getOriginalFunctions()) {
-            return handle.getDescriptor().getReturnType();
+            return state.getTypeMapper().getReturnValueType(handle.getDescriptor());
         }
 
         if (state.getClassBuilderMode().mightBeIncorrectCode) {
@@ -1154,7 +1129,7 @@ public class FunctionCodegen {
         // $default methods are never private to be accessible from other class files (e.g. inner) without the need of synthetic accessors
         // $default methods are never protected to be accessible from subclass nested classes
         int visibilityFlag =
-                DescriptorVisibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor)
+                Visibilities.isPrivate(functionDescriptor.getVisibility()) || isInlineOnlyPrivateInBytecode(functionDescriptor)
                 ? AsmUtil.NO_FLAG_PACKAGE_PRIVATE : Opcodes.ACC_PUBLIC;
         int flags = visibilityFlag | getDeprecatedAccessFlag(functionDescriptor) | ACC_SYNTHETIC;
         if (!(functionDescriptor instanceof ConstructorDescriptor &&
@@ -1413,7 +1388,7 @@ public class FunctionCodegen {
         if (isVarargInvoke) {
             assert argTypes.length == 1 && argTypes[0].equals(AsmUtil.getArrayType(OBJECT_TYPE)) :
                     "Vararg invoke must have one parameter of type [Ljava/lang/Object;: " + bridge;
-            DescriptorAsmUtil.generateVarargInvokeArityAssert(iv, originalArgTypes.length);
+            AsmUtil.generateVarargInvokeArityAssert(iv, originalArgTypes.length);
         }
         else {
             assert argTypes.length == originalArgTypes.length :
@@ -1459,7 +1434,7 @@ public class FunctionCodegen {
             }
         }
 
-        KotlinType returnValueType = descriptor.getReturnType();
+        KotlinType returnValueType = state.getTypeMapper().getReturnValueType(descriptor);
         StackValue.coerce(delegateTo.getReturnType(), returnValueType, bridge.getReturnType(), bridgeReturnType, iv);
         iv.areturn(bridge.getReturnType());
 
@@ -1618,7 +1593,7 @@ public class FunctionCodegen {
                         }
 
                         //noinspection ConstantConditions
-                        StackValue stackValue = DescriptorAsmUtil.genNotNullAssertions(
+                        StackValue stackValue = AsmUtil.genNotNullAssertions(
                                 state,
                                 StackValue.onStack(delegateToMethod.getReturnType(), delegatedTo.getReturnType()),
                                 RuntimeAssertionInfo.create(
@@ -1681,13 +1656,11 @@ 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;
-                case IMPLEMENTATION: return !DescriptorVisibilities.isPrivate(memberDescriptor.getVisibility()) && !isDefault && !isSynthetic;
+                case IMPLEMENTATION: return !Visibilities.isPrivate(memberDescriptor.getVisibility()) && !isDefault && !isSynthetic;
                 default: return false;
             }
         }

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

@@ -11,12 +11,12 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.FunctionsFromAnyGenerator;
 import org.jetbrains.kotlin.codegen.context.FieldOwnerContext;
 import org.jetbrains.kotlin.codegen.context.MethodContext;
-import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 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;
@@ -30,12 +30,10 @@ import org.jetbrains.org.objectweb.asm.Label;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
-import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.List;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.*;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_STRING_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
@@ -48,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,
@@ -70,28 +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);
-        String toStringMethodDesc = getToStringDesc();
-        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), toStringMethodName, toStringMethodDesc, null, null);
+        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());
@@ -141,14 +133,6 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         iv.areturn(JAVA_STRING_TYPE);
 
         FunctionCodegen.endVisit(mv, toStringMethodName, getDeclaration());
-
-        recordMethodForFunctionIfRequired(function, toStringMethodName, toStringMethodDesc);
-    }
-
-    private void recordMethodForFunctionIfRequired(@NotNull FunctionDescriptor function, @NotNull String name, @NotNull String desc) {
-        if (isInErasedInlineClass) {
-            v.getSerializationBindings().put(JvmSerializationBindings.METHOD_FOR_FUNCTION, function, new Method(name, desc));
-        }
     }
 
     @Override
@@ -158,10 +142,9 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String hashCodeMethodName = mapFunctionName(function);
-        String hashCodeMethodDesc = getHashCodeDesc();
-        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), hashCodeMethodName, hashCodeMethodDesc, null, null);
+        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;
         }
@@ -215,8 +198,6 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         mv.visitInsn(IRETURN);
 
         FunctionCodegen.endVisit(mv, hashCodeMethodName, getDeclaration());
-
-        recordMethodForFunctionIfRequired(function, hashCodeMethodName, hashCodeMethodDesc);
     }
 
     private String mapFunctionName(@NotNull FunctionDescriptor functionDescriptor) {
@@ -230,17 +211,17 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         MethodContext context = fieldOwnerContext.intoFunction(function);
         JvmDeclarationOrigin methodOrigin = JvmDeclarationOriginKt.OtherOrigin(function);
         String equalsMethodName = mapFunctionName(function);
-        String equalsMethodDesc = getEqualsDesc();
-        MethodVisitor mv = v.newMethod(methodOrigin, getAccess(), equalsMethodName, equalsMethodDesc, null, null);
+        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());
@@ -282,8 +263,6 @@ public class FunctionsFromAnyGeneratorImpl extends FunctionsFromAnyGenerator {
         iv.areturn(Type.INT_TYPE);
 
         FunctionCodegen.endVisit(mv, equalsMethodName, getDeclaration());
-
-        recordMethodForFunctionIfRequired(function, equalsMethodName, equalsMethodDesc);
     }
 
     private static void visitEndForAnnotationVisitor(@Nullable AnnotationVisitor annotation) {

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

@@ -62,18 +62,13 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.builtins.StandardNames.ENUM_VALUES;
-import static org.jetbrains.kotlin.builtins.StandardNames.ENUM_VALUE_OF;
-import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD;
+import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isGenericToArray;
 import static org.jetbrains.kotlin.codegen.CodegenUtilKt.isNonGenericToArray;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.getDelegatedLocalVariableMetadata;
-import static org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil.*;
-import static org.jetbrains.kotlin.load.java.JvmAbi.HIDDEN_INSTANCE_FIELD;
-import static org.jetbrains.kotlin.load.java.JvmAbi.INSTANCE_FIELD;
+import static org.jetbrains.kotlin.load.java.JvmAbi.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_GET;
 import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_SET;
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull;
@@ -776,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;
         }
 
@@ -819,17 +812,14 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         }
         if (properVisibilityForCompanionObjectInstanceField &&
             JvmCodegenUtil.isCompanionObjectInInterfaceNotIntrinsic(companionObjectDescriptor) &&
-            DescriptorVisibilities.isPrivate(companionObjectDescriptor.getVisibility())) {
+            Visibilities.isPrivate(companionObjectDescriptor.getVisibility())) {
             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.*
 
@@ -65,7 +65,7 @@ class InterfaceImplBodyCodegen(
             if (memberDescriptor !is CallableMemberDescriptor) continue
 
             if (memberDescriptor.kind.isReal) continue
-            if (memberDescriptor.visibility == DescriptorVisibilities.INVISIBLE_FAKE) continue
+            if (memberDescriptor.visibility == Visibilities.INVISIBLE_FAKE) continue
             if (memberDescriptor.modality == Modality.ABSTRACT) continue
 
             val implementation = findImplementationFromInterface(memberDescriptor) ?: continue

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMapper
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
@@ -42,7 +42,7 @@ class JvmBackendClassResolverForModuleWithDependencies(
 
         val platformClass = moduleDescriptor.findClassAcrossModuleDependencies(type.classId) ?: return emptyList()
 
-        return JavaToKotlinClassMapper.mapPlatformClass(platformClass) + platformClass
+        return JavaToKotlinClassMap.mapPlatformClass(platformClass) + platformClass
     }
 }
 
@@ -54,4 +54,4 @@ val Type.classId: ClassId
         val classRelativeNameWithDollars = if (lastDotIndex >= 0) className.substring(lastDotIndex + 1) else className
         val classFQN = FqName(classRelativeNameWithDollars.replace('$', '.'))
         return ClassId(packageFQN, classFQN, false)
-    }
+    }

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/JvmCodegenUtil.java

@@ -12,8 +12,6 @@ import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.CodegenUtil;
-import org.jetbrains.kotlin.builtins.StandardNames;
-import org.jetbrains.kotlin.builtins.functions.BuiltInFunctionArity;
 import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor;
 import org.jetbrains.kotlin.codegen.binding.CalculatedClosure;
 import org.jetbrains.kotlin.codegen.context.CodegenContext;
@@ -29,7 +27,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
-import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
+import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor;
 import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor;
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityUtilsKt;
@@ -108,7 +106,7 @@ public class JvmCodegenUtil {
         boolean isDelegate = descriptor.getKind() == CallableMemberDescriptor.Kind.DELEGATION;
 
         DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration().getOriginal();
-        if (DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(descriptor)) {
+        if (JvmAbi.isPropertyWithBackingFieldInOuterClass(descriptor)) {
             // For property with backed field, check if the access is done in the same class containing the backed field and
             // not the class that declared the field.
             containingDeclaration = containingDeclaration.getContainingDeclaration();
@@ -221,7 +219,7 @@ public class JvmCodegenUtil {
         if (DescriptorPsiUtilsKt.hasBody(accessor)) return false;
 
         // If the accessor is private or final, it can't be overridden in the subclass and thus we can use direct access
-        return DescriptorVisibilities.isPrivate(accessor.getVisibility()) || accessor.getModality() == FINAL;
+        return Visibilities.isPrivate(accessor.getVisibility()) || accessor.getModality() == FINAL;
     }
 
     public static boolean isDebuggerContext(@NotNull CodegenContext context) {
@@ -340,12 +338,12 @@ public class JvmCodegenUtil {
     public static boolean isCompanionObjectInInterfaceNotIntrinsic(@NotNull DeclarationDescriptor companionObject) {
         return isCompanionObject(companionObject) &&
                isJvmInterface(companionObject.getContainingDeclaration()) &&
-               !DescriptorsJvmAbiUtil.isMappedIntrinsicCompanionObject((ClassDescriptor) companionObject);
+               !JvmAbi.isMappedIntrinsicCompanionObject((ClassDescriptor) companionObject);
     }
 
     public static boolean isNonIntrinsicPrivateCompanionObjectInInterface(@NotNull DeclarationDescriptorWithVisibility companionObject) {
         return isCompanionObjectInInterfaceNotIntrinsic(companionObject) &&
-               DescriptorVisibilities.isPrivate(companionObject.getVisibility());
+               Visibilities.isPrivate(companionObject.getVisibility());
     }
 
     public static boolean isDeclarationOfBigArityFunctionInvoke(@Nullable DeclarationDescriptor descriptor) {
@@ -354,7 +352,7 @@ public class JvmCodegenUtil {
 
     public static boolean isDeclarationOfBigArityCreateCoroutineMethod(@Nullable DeclarationDescriptor descriptor) {
         return descriptor instanceof SimpleFunctionDescriptor && descriptor.getName().asString().equals(SUSPEND_FUNCTION_CREATE_METHOD_NAME) &&
-               ((SimpleFunctionDescriptor) descriptor).getValueParameters().size() >= BuiltInFunctionArity.BIG_ARITY - 1 &&
+               ((SimpleFunctionDescriptor) descriptor).getValueParameters().size() >= FunctionInvokeDescriptor.BIG_ARITY - 1 &&
                descriptor.getContainingDeclaration() instanceof AnonymousFunctionDescriptor && ((AnonymousFunctionDescriptor) descriptor.getContainingDeclaration()).isSuspend();
     }
 
@@ -406,7 +404,7 @@ public class JvmCodegenUtil {
         // The Result class is the only inline class in the standard library without special rules for equality.
         // We only call Result.equals-impl0 if we are compiling for Kotlin 1.4 or later. Otherwise, the code
         // might well be running against an older version of the standard library.
-        if (DescriptorUtils.getFqNameSafe(classDescriptor).equals(StandardNames.RESULT_FQ_NAME)) {
+        if (DescriptorUtils.getFqNameSafe(classDescriptor).equals(DescriptorUtils.RESULT_FQ_NAME)) {
             return state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_4) >= 0;
         } else {
             return ((DeserializedClassDescriptor) descriptor).getMetadataVersion().isAtLeast(1, 1, 16);

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,
@@ -86,7 +84,7 @@ class JvmRuntimeTypes(
             packageFragment, classKind, false, false, Name.identifier(name), SourceElement.NO_SOURCE, LockBasedStorageManager.NO_LOCKS
         ).apply {
             modality = Modality.FINAL
-            visibility = DescriptorVisibilities.PUBLIC
+            visibility = Visibilities.PUBLIC
             setTypeParameterDescriptors(emptyList())
             createTypeConstructor()
         }
@@ -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,
@@ -162,7 +152,7 @@ class JvmRuntimeTypes(
             referencedFunction.isSuspend || isSuspendConversion
         )
 
-        val suspendFunctionType = if (referencedFunction.isSuspend || isSuspendConversion) suspendFunctionInterface?.defaultType else null
+        val suspendFunctionType = if (referencedFunction.isSuspend) suspendFunctionInterface?.defaultType else null
         val superClass = when {
             generateOptimizedCallableReferenceSuperClasses -> when {
                 isAdaptedCallableReference || isSuspendConversion -> adaptedFunctionReference

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

@@ -25,8 +25,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotatedImpl;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
-import org.jetbrains.kotlin.load.java.JavaDescriptorVisibilities;
+import org.jetbrains.kotlin.load.java.JavaVisibilities;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
@@ -57,8 +56,8 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.*;
 
+import static org.jetbrains.kotlin.codegen.AsmUtil.calculateInnerClassAccessFlags;
 import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.calculateInnerClassAccessFlags;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isNonDefaultInterfaceMember;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtilsKt.getInlineName;
 import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED;
@@ -258,7 +257,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
             @NotNull Method syntheticMethod,
             @NotNull Annotations annotations
     ) {
-        int flags = ACC_DEPRECATED | ACC_STATIC | ACC_SYNTHETIC | DescriptorAsmUtil.getVisibilityAccessFlag(descriptor);
+        int flags = ACC_DEPRECATED | ACC_STATIC | ACC_SYNTHETIC | AsmUtil.getVisibilityAccessFlag(descriptor);
         MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(descriptor), flags, syntheticMethod.getName(),
                                        syntheticMethod.getDescriptor(), null, null);
         AnnotationCodegen.forMethod(mv, this, state).genAnnotations(new AnnotatedImpl(annotations), Type.VOID_TYPE, null);
@@ -469,7 +468,7 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                 Name.special("<clinit>"), SYNTHESIZED, KotlinSourceElementKt.toSourceElement(element));
         clInit.initialize(null, null, Collections.emptyList(), Collections.emptyList(),
                           DescriptorUtilsKt.getModule(descriptor).getBuiltIns().getUnitType(),
-                          Modality.FINAL, DescriptorVisibilities.PRIVATE);
+                          Modality.FINAL, Visibilities.PRIVATE);
         return clInit;
     }
 
@@ -727,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;
     }
@@ -878,11 +877,11 @@ public abstract class MemberCodegen<T extends KtPureElement/* TODO: & KtDeclarat
                     AccessorKind fieldAccessorKind = accessor instanceof AccessorForPropertyBackingField
                                                           ? accessor.getAccessorKind() : null;
                     boolean syntheticBackingField = fieldAccessorKind == AccessorKind.FIELD_FROM_LOCAL;
-                    boolean forceFieldForCompanionProperty = DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(original) &&
+                    boolean forceFieldForCompanionProperty = JvmAbi.isPropertyWithBackingFieldInOuterClass(original) &&
                                                              !isCompanionObject(accessor.getContainingDeclaration());
                     boolean forceField = forceFieldForCompanionProperty ||
                                          syntheticBackingField ||
-                                         original.getVisibility() == JavaDescriptorVisibilities.PROTECTED_STATIC_VISIBILITY;
+                                         original.getVisibility() == JavaVisibilities.PROTECTED_STATIC_VISIBILITY;
                     StackValue property = codegen.intermediateValueForProperty(
                             original, forceField, syntheticBackingField, accessor.getSuperCallTarget(),
                             forceFieldForCompanionProperty, StackValue.none(), null,

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

@@ -224,8 +224,8 @@ class MultifileClassCodegenImpl(
     }
 
     private fun shouldGenerateInFacade(descriptor: MemberDescriptor): Boolean {
-        if (DescriptorVisibilities.isPrivate(descriptor.visibility)) return false
-        if (DescriptorAsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE) return false
+        if (Visibilities.isPrivate(descriptor.visibility)) return false
+        if (AsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE) return false
 
         if (!state.classBuilderMode.generateBodies) return true
 

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

@@ -97,7 +97,7 @@ class MultifileClassPartCodegen(
         val extraFlags = if (shouldGeneratePartHierarchy) JvmAnnotationNames.METADATA_MULTIFILE_PARTS_INHERIT_FLAG else 0
 
         writeKotlinMetadata(v, state, KotlinClassHeader.Kind.MULTIFILE_CLASS_PART, extraFlags) { av ->
-            DescriptorAsmUtil.writeAnnotationData(av, serializer, packageProto)
+            AsmUtil.writeAnnotationData(av, serializer, packageProto)
             av.visit(JvmAnnotationNames.METADATA_MULTIFILE_CLASS_NAME_FIELD_NAME, facadeClassType.internalName)
 
             val kotlinPackageFqName = element.packageFqName

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

@@ -43,7 +43,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.writeAnnotationData;
+import static org.jetbrains.kotlin.codegen.AsmUtil.writeAnnotationData;
 import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.METADATA_PACKAGE_NAME_FIELD_NAME;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -44,8 +43,8 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.List;
 
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getDeprecatedAccessFlag;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.getVisibilityForBackingField;
+import static org.jetbrains.kotlin.codegen.AsmUtil.getDeprecatedAccessFlag;
+import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityForBackingField;
 import static org.jetbrains.kotlin.codegen.FunctionCodegen.processInterfaceMethod;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConstOrHasJvmFieldAnnotation;
 import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
@@ -160,7 +159,7 @@ public class PropertyCodegen {
 
     private void genBackingFieldAndAnnotations(@NotNull PropertyDescriptor descriptor) {
         // Fields and '$annotations' methods for non-private const properties are generated in the multi-file facade
-        boolean isBackingFieldOwner = descriptor.isConst() && !DescriptorVisibilities.isPrivate(descriptor.getVisibility())
+        boolean isBackingFieldOwner = descriptor.isConst() && !Visibilities.isPrivate(descriptor.getVisibility())
                                       ? !(context instanceof MultifileClassPartContext)
                                       : CodegenContextUtil.isImplementationOwner(context, descriptor);
 
@@ -211,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
@@ -218,7 +218,7 @@ public class PropertyCodegen {
         // and setter, in this case, the property can always be accessed through the accessor 'access<property name>$cp' and avoid some
         // useless indirection by using others accessors.
         if (isCompanionObject(descriptor.getContainingDeclaration())) {
-            if (DescriptorVisibilities.isPrivate(descriptor.getVisibility()) && isDefaultGetterAndSetter) {
+            if (Visibilities.isPrivate(descriptor.getVisibility()) && isDefaultGetterAndSetter) {
                 return false;
             }
             return true;
@@ -228,14 +228,14 @@ public class PropertyCodegen {
         if (isTopLevelInJvmMultifileClass(descriptor)) return true;
 
         // Private class properties have accessors only in cases when those accessors are non-trivial
-        if (DescriptorVisibilities.isPrivate(descriptor.getVisibility())) {
+        if (Visibilities.isPrivate(descriptor.getVisibility())) {
             return !isDefaultAccessor;
         }
 
         // Non-private properties with private setter should not be generated for trivial properties
         // as the class will use direct field access instead
         //noinspection ConstantConditions
-        if (accessor != null && accessor.isSetter() && DescriptorVisibilities.isPrivate(descriptor.getSetter().getVisibility())) {
+        if (accessor != null && accessor.isSetter() && Visibilities.isPrivate(descriptor.getSetter().getVisibility())) {
             return !isDefaultAccessor;
         }
 
@@ -254,12 +254,12 @@ public class PropertyCodegen {
         if (hasJvmFieldAnnotation(descriptor)) return false;
         if (kind == OwnerKind.ERASED_INLINE_CLASS) return false;
 
-        DescriptorVisibility visibility = descriptor.getVisibility();
+        Visibility visibility = descriptor.getVisibility();
         if (InlineClassesUtilsKt.isInlineClass(descriptor.getContainingDeclaration())) {
             return visibility.isPublicAPI();
         }
         else {
-            return !DescriptorVisibilities.isPrivate(visibility);
+            return !Visibilities.isPrivate(visibility);
         }
     }
 
@@ -337,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))) {
@@ -354,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
@@ -408,10 +411,10 @@ public class PropertyCodegen {
         ClassBuilder builder = v;
 
         FieldOwnerContext backingFieldContext = context;
-        if (DescriptorAsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor) ) {
+        if (AsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor) ) {
             modifiers |= ACC_STATIC;
 
-            if (DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor)) {
+            if (JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor)) {
                 ImplementationBodyCodegen codegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
                 builder = codegen.v;
                 backingFieldContext = codegen.context;
@@ -419,7 +422,7 @@ public class PropertyCodegen {
         }
         modifiers |= getVisibilityForBackingField(propertyDescriptor, isDelegate);
 
-        if (DescriptorAsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
+        if (AsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
             ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
             parentBodyCodegen.addCompanionObjectPropertyToCopy(propertyDescriptor, defaultValue);
         }
@@ -435,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());
             }
         }
@@ -512,14 +509,16 @@ public class PropertyCodegen {
 
     private void generateAccessor(@Nullable KtPropertyAccessor accessor, @NotNull PropertyAccessorDescriptor descriptor) {
         if (context instanceof MultifileClassFacadeContext &&
-            (DescriptorVisibilities.isPrivate(descriptor.getVisibility()) ||
-             DescriptorAsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE)) {
+            (Visibilities.isPrivate(descriptor.getVisibility()) ||
+             AsmUtil.getVisibilityAccessFlag(descriptor) == Opcodes.ACC_PRIVATE)) {
             return;
         }
 
         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/PropertyReferenceCodegen.kt

@@ -92,8 +92,8 @@ class PropertyReferenceCodegen(
             element,
             state.classFileVersion,
             ACC_FINAL or ACC_SUPER or
-                    DescriptorAsmUtil.getVisibilityAccessFlagForClass(classDescriptor) or
-                    DescriptorAsmUtil.getSyntheticAccessFlagForLambdaClass(classDescriptor),
+                    AsmUtil.getVisibilityAccessFlagForClass(classDescriptor) or
+                    AsmUtil.getSyntheticAccessFlagForLambdaClass(classDescriptor),
             asmType.internalName,
             null,
             superAsmType.internalName,
@@ -108,7 +108,7 @@ class PropertyReferenceCodegen(
         if (JvmCodegenUtil.isConst(closure)) {
             generateConstInstance(asmType, wrapperMethod.returnType)
         } else {
-            DescriptorAsmUtil.genClosureFields(closure, v, typeMapper, state.languageVersionSettings)
+            AsmUtil.genClosureFields(closure, v, typeMapper, state.languageVersionSettings)
         }
 
         generateConstructor()

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

@@ -46,9 +46,7 @@ import org.jetbrains.org.objectweb.asm.commons.Method;
 import java.util.Collections;
 import java.util.Map;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.NO_FLAG_PACKAGE_PRIVATE;
-import static org.jetbrains.kotlin.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
-import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.genAreEqualCall;
+import static org.jetbrains.kotlin.codegen.AsmUtil.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
@@ -108,7 +106,7 @@ public class SamWrapperCodegen {
         SimpleFunctionDescriptor erasedInterfaceFunction = samType.getOriginalAbstractMethod().copy(
                 classDescriptor,
                 Modality.FINAL,
-                DescriptorVisibilities.PUBLIC,
+                Visibilities.PUBLIC,
                 CallableMemberDescriptor.Kind.SYNTHESIZED,
                 /*copyOverrides=*/ false
         );
@@ -270,12 +268,12 @@ public class SamWrapperCodegen {
             if (!(descriptor instanceof CallableMemberDescriptor)) continue;
             CallableMemberDescriptor member = (CallableMemberDescriptor) descriptor;
             if (member.getModality() == Modality.ABSTRACT ||
-                DescriptorVisibilities.isPrivate(member.getVisibility()) ||
-                member.getVisibility() == DescriptorVisibilities.INVISIBLE_FAKE ||
+                Visibilities.isPrivate(member.getVisibility()) ||
+                member.getVisibility() == Visibilities.INVISIBLE_FAKE ||
                 DescriptorUtils.isMethodOfAny(member)) continue;
 
             for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.INSTANCE.copyFunctions(
-                    member, member, classDescriptor, Modality.OPEN, DescriptorVisibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, false
+                    member, member, classDescriptor, Modality.OPEN, Visibilities.PUBLIC, CallableMemberDescriptor.Kind.DECLARATION, false
             ).entrySet()) {
                 ClassBodyCodegen.generateDelegationToDefaultImpl(entry.getKey(), entry.getValue(), receiverType, functionCodegen, state, false);
             }

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.codegen
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.codegen.AsmUtil.writeAnnotationData
 import org.jetbrains.kotlin.codegen.context.CodegenContext
 import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.context.ScriptContext
@@ -70,7 +71,7 @@ class ScriptCodegen private constructor(
         val serializer = DescriptorSerializer.create(scriptDescriptor, JvmSerializerExtension(v.serializationBindings, state), null)
         val classProto = serializer.classProto(scriptDescriptor).build()
         writeKotlinMetadata(v, state, KotlinClassHeader.Kind.CLASS, JvmAnnotationNames.METADATA_SCRIPT_FLAG) { av ->
-            DescriptorAsmUtil.writeAnnotationData(av, serializer, classProto)
+            writeAnnotationData(av, serializer, classProto)
         }
     }
 

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/StackValue.java

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor;
-import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
 import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.KtExpression;
@@ -1544,7 +1543,7 @@ public abstract class StackValue {
 
                 //TODO: try to don't generate defaults at all in CollectionElementReceiver
 
-                List<ResolvedValueArgument> getterArguments = new ArrayList<>(collectionElementReceiver.valueArguments);
+                List<ResolvedValueArgument> getterArguments = new ArrayList(collectionElementReceiver.valueArguments);
                 List<ResolvedValueArgument> getterDefaults = CollectionsKt.takeLastWhile(getterArguments,
                                                                                          argument -> argument instanceof DefaultValueArgument);
 
@@ -1762,7 +1761,7 @@ public abstract class StackValue {
                 // is from a different context), the assertion will be generated on each access, see KT-28331.
                 if (descriptor instanceof AccessorForPropertyBackingField) {
                     PropertyDescriptor property = ((AccessorForPropertyBackingField) descriptor).getCalleeDescriptor();
-                    if (!skipLateinitAssertion && property.isLateInit() && DescriptorsJvmAbiUtil.isPropertyWithBackingFieldInOuterClass(property) &&
+                    if (!skipLateinitAssertion && property.isLateInit() && JvmAbi.isPropertyWithBackingFieldInOuterClass(property) &&
                         !JvmCodegenUtil.couldUseDirectAccessToProperty(property, true, false, codegen.context, false)) {
                         genNonNullAssertForLateinit(v, property.getName().asString());
                     }

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.resolve.jvm.checkers.isValidDalvikCharacter
 
 const val DESTRUCTURED_LAMBDA_ARGUMENT_VARIABLE_PREFIX = "\$dstr\$"
 
@@ -25,3 +26,25 @@ fun getNameForDestructuredParameterOrNull(valueParameterDescriptor: ValueParamet
         )
     }
 }
+
+fun mangleNameIfNeeded(name: String): String {
+    if (name.all { it.isValidCharacter() }) {
+        return name
+    }
+
+    return buildString {
+        for (c in name) {
+            if (c.isValidCharacter()) {
+                append(c)
+            } else {
+                val hexString = Integer.toHexString(c.toInt())
+                assert(hexString.length <= 4)
+                append("_u").append(hexString)
+            }
+        }
+    }
+}
+
+private fun Char.isValidCharacter(): Boolean {
+    return this != '$' && this != '-' && isValidDalvikCharacter(this)
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenAnnotatingVisitor.java

@@ -616,7 +616,7 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         String nameForClassOrPackageMember = getNameForClassOrPackageMember(functionDescriptor);
 
         if (functionDescriptor instanceof SimpleFunctionDescriptor && functionDescriptor.isSuspend() &&
-            !functionDescriptor.getVisibility().equals(DescriptorVisibilities.LOCAL)) {
+            !functionDescriptor.getVisibility().equals(Visibilities.LOCAL)) {
 
             if (nameForClassOrPackageMember != null) {
                 nameStack.push(nameForClassOrPackageMember);
@@ -821,17 +821,20 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
 
         Map<ValueParameterDescriptor, ResolvedValueArgument> arguments = newResolvedCall.getValueArguments();
         for (ValueParameterDescriptor valueParameter : arguments.keySet()) {
+            SamType samType = SamType.createByValueParameter(valueParameter);
+            if (samType == null) continue;
+
             ResolvedValueArgument argument = arguments.get(valueParameter);
             if (argument instanceof ExpressionValueArgument) {
                 ValueArgument valueArgument = ((ExpressionValueArgument) argument).getValueArgument();
                 if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                    recordSamTypeOnArgumentExpression(valueParameter, valueArgument);
+                    recordSamTypeOnArgumentExpression(samType, valueArgument);
                 }
             } else if (argument instanceof VarargValueArgument) {
                 VarargValueArgument varargValueArgument = (VarargValueArgument) argument;
                 for (ValueArgument valueArgument : varargValueArgument.getArguments()) {
                     if (valueArgument != null && newResolvedCall.getExpectedTypeForSamConvertedArgument(valueArgument) != null) {
-                        recordSamTypeOnArgumentExpression(valueParameter, valueArgument);
+                        recordSamTypeOnArgumentExpression(samType, valueArgument);
                     }
                 }
             }
@@ -869,13 +872,6 @@ class CodegenAnnotatingVisitor extends KtVisitorVoid {
         }
     }
 
-    private void recordSamTypeOnArgumentExpression(ValueParameterDescriptor valueParameter, ValueArgument valueArgument) {
-        SamType samType = SamType.createByValueParameter(valueParameter);
-        if (samType == null) return;
-
-        recordSamTypeOnArgumentExpression(samType, valueArgument);
-    }
-
     private void recordSamTypeOnArgumentExpression(SamType samType, ValueArgument valueArgument) {
         KtExpression argumentExpression = valueArgument.getArgumentExpression();
         assert argumentExpression != null : valueArgument.asElement().getText();

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/MutableClosure.java

@@ -20,7 +20,6 @@ import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.AsmUtil;
-import org.jetbrains.kotlin.codegen.DescriptorAsmUtil;
 import org.jetbrains.kotlin.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
@@ -114,7 +113,7 @@ public final class MutableClosure implements CalculatedClosure {
                 return AsmUtil.CAPTURED_RECEIVER_FIELD;
             }
 
-            String labeledThis = DescriptorAsmUtil.getNameForCapturedReceiverField(
+            String labeledThis = AsmUtil.getNameForCapturedReceiverField(
                     enclosingFunWithReceiverDescriptor, bindingContext, languageVersionSettings);
 
             return AsmUtil.getCapturedFieldName(labeledThis);

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

@@ -87,7 +87,7 @@ fun InstructionAdapter.generateClosureFieldsInitializationFromParameters(
             k += fieldInfo.fieldType.size
             continue
         }
-        k = DescriptorAsmUtil.genAssignInstanceFieldFromParam(fieldInfo, k, this)
+        k = AsmUtil.genAssignInstanceFieldFromParam(fieldInfo, k, this)
     }
 
     return boundReferenceReceiverFieldInfo?.let { Pair(boundReferenceReceiverParameterIndex, it) }
@@ -122,7 +122,7 @@ internal fun generateCallableReferenceDeclarationContainerClass(
             // TODO: would it work for arrays?
             val containerKotlinType = container.defaultType
             val containerType = typeMapper.mapClass(container)
-            DescriptorAsmUtil.putJavaLangClassInstance(iv, containerType, containerKotlinType, typeMapper)
+            AsmUtil.putJavaLangClassInstance(iv, containerType, containerKotlinType, typeMapper)
         }
         container is PackageFragmentDescriptor -> {
             iv.aconst(typeMapper.mapOwner(descriptor))
@@ -211,4 +211,4 @@ private fun getSignatureString(callable: CallableDescriptor, state: GenerationSt
             state.typeMapper.mapAsmMethod(declaration)
     }
     return method.name + method.descriptor
-}
+}

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

@@ -19,13 +19,14 @@ import org.jetbrains.kotlin.codegen.inline.ReificationArgument
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
+import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.deserialization.PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.SpecialSignatureInfo
-import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil
+import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -97,12 +98,11 @@ fun generateAsCast(
     kotlinType: KotlinType,
     asmType: Type,
     isSafe: Boolean,
-    languageVersionSettings: LanguageVersionSettings,
-    unifiedNullChecks: Boolean,
+    languageVersionSettings: LanguageVersionSettings
 ) {
     if (!isSafe) {
         if (!TypeUtils.isNullableType(kotlinType)) {
-            generateNullCheckForNonSafeAs(v, kotlinType, unifiedNullChecks)
+            generateNullCheckForNonSafeAs(v, kotlinType, languageVersionSettings)
         }
     } else {
         with(v) {
@@ -122,13 +122,15 @@ fun generateAsCast(
 private fun generateNullCheckForNonSafeAs(
     v: InstructionAdapter,
     type: KotlinType,
-    unifiedNullChecks: Boolean,
+    languageVersionSettings: LanguageVersionSettings
 ) {
     with(v) {
         dup()
         val nonnull = Label()
         ifnonnull(nonnull)
-        val exceptionClass = if (unifiedNullChecks) "java/lang/NullPointerException" else "kotlin/TypeCastException"
+        val exceptionClass =
+            if (languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4) "java/lang/NullPointerException"
+            else "kotlin/TypeCastException"
         AsmUtil.genThrow(
             v,
             exceptionClass,
@@ -152,7 +154,7 @@ fun populateCompanionBackingFieldNamesToOuterContextIfNeeded(
         return
     }
 
-    if (!DescriptorsJvmAbiUtil.isClassCompanionObjectWithBackingFieldsInOuter(descriptor)) {
+    if (!JvmAbi.isClassCompanionObjectWithBackingFieldsInOuter(descriptor)) {
         return
     }
     val properties = companion.declarations.filterIsInstance<KtProperty>()
@@ -588,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
     )
@@ -683,4 +685,4 @@ internal fun LabelNode.linkWithLabel(): LabelNode {
     return this
 }
 
-fun linkedLabel(): Label = LabelNode().linkWithLabel().label
+fun linkedLabel(): Label = LabelNode().linkWithLabel().label