Introduce GetScriptingClassByClassLoader interface

It is needed to override default JVM behaviour

.bunch

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

.idea/runConfigurations/Generate_Compiler_Tests.xml

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

build.gradle.kts

@@ -188,7 +188,7 @@ 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.30-dev-17395"
+    extra["versions.kotlin-native"] = "1.4.30-dev-17200"
 }
 
 val intellijUltimateEnabled by extra(project.kotlinBuildProperties.intellijUltimateEnabled)
@@ -293,7 +293,6 @@ extra["compilerModules"] = arrayOf(
     ":compiler:fir:checkers",
     ":compiler:fir:entrypoint",
     ":compiler:fir:analysis-tests",
-    ":compiler:fir:analysis-tests:legacy-fir-tests",
     ":wasm:wasm.ir"
 )
 
@@ -468,7 +467,7 @@ allprojects {
     }
 
     tasks.withType<Test> {
-        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KTI-112") { !isTestDistributionEnabled() }
+        outputs.doNotCacheIf("https://youtrack.jetbrains.com/issue/KT-37089") { true }
     }
 
     normalization {
@@ -570,7 +569,7 @@ val dist = tasks.register("dist") {
 }
 
 val syncMutedTests = tasks.register("syncMutedTests") {
-    dependsOn(":compiler:tests-mutes:tc-integration:run")
+    dependsOn(":compiler:tests-mutes:run")
 }
 
 val copyCompilerToIdeaPlugin by task<Copy> {
@@ -631,7 +630,6 @@ tasks {
         dependsOn("dist")
         dependsOn(
             ":compiler:test",
-            ":compiler:tests-common-new:test",
             ":compiler:container:test",
             ":compiler:tests-java8:test",
             ":compiler:tests-spec:test",
@@ -668,7 +666,6 @@ tasks {
         dependsOn(":compiler:fir:raw-fir:psi2fir:test")
         dependsOn(":compiler:fir:raw-fir:light-tree2fir:test")
         dependsOn(":compiler:fir:analysis-tests:test")
-        dependsOn(":compiler:fir:analysis-tests:legacy-fir-tests:test")
         dependsOn(":compiler:fir:fir2ir:test")
     }
 
@@ -678,7 +675,6 @@ tasks {
             ":compiler:fir:raw-fir:psi2fir:test",
             ":compiler:fir:raw-fir:light-tree2fir:test",
             ":compiler:fir:analysis-tests:test",
-            ":compiler:fir:analysis-tests:legacy-fir-tests:test",
             ":compiler:fir:fir2ir:test",
             ":plugins:fir:fir-plugin-prototype:test"
         )
@@ -714,6 +710,7 @@ tasks {
     }
 
     register("miscCompilerTest") {
+        dependsOn("wasmCompilerTest")
         dependsOn("nativeCompilerTest")
         dependsOn("firCompilerTest")
 
@@ -857,8 +854,6 @@ tasks {
 
     register("kaptIdeTest") {
         dependsOn(":kotlin-annotation-processing:test")
-        dependsOn(":kotlin-annotation-processing-base:test")
-        dependsOn(":kotlin-annotation-processing-cli:test")
     }
 
     register("gradleIdeTest") {
@@ -873,7 +868,6 @@ tasks {
             ":idea:idea-gradle:test",
             ":idea:test",
             ":compiler:test",
-            ":compiler:container:test",
             ":js:js.tests:test"
         )
 

buildSrc/build.gradle.kts

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

buildSrc/src/main/kotlin/CommonUtil.kt

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

buildSrc/src/main/kotlin/pluginMarkers.kt

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

buildSrc/src/main/kotlin/tasks.kt

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

buildSrc/src/main/kotlin/testDistribution.kt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -54,7 +54,6 @@ import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.load.java.DescriptorsJvmAbiUtil;
-import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor;
 import org.jetbrains.kotlin.load.kotlin.DescriptorBasedTypeSignatureMappingKt;
 import org.jetbrains.kotlin.load.kotlin.MethodSignatureMappingKt;
 import org.jetbrains.kotlin.name.Name;
@@ -2405,14 +2404,9 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             fieldName = KotlinTypeMapper.mapDefaultFieldName(propertyDescriptor, isDelegatedProperty);
         }
 
-        KotlinType propertyType = propertyDescriptor.getOriginal().getType();
-        if (propertyDescriptor instanceof JavaPropertyDescriptor && InlineClassesUtilsKt.isInlineClassType(propertyType)) {
-            propertyType = TypeUtils.makeNullable(propertyType);
-        }
-
         return StackValue.property(
                 propertyDescriptor, backingFieldOwner,
-                typeMapper.mapType(isDelegatedProperty && forceField ? delegateType : propertyType),
+                typeMapper.mapType(isDelegatedProperty && forceField ? delegateType : propertyDescriptor.getOriginal().getType()),
                 isStaticBackingField, fieldName, callableGetter, callableSetter, receiver, this, resolvedCall, skipLateinitAssertion,
                 isDelegatedProperty && forceField ? delegateType : null
         );
@@ -4381,10 +4375,6 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         Type exprType = expressionType(expr);
         KotlinType exprKotlinType = kotlinType(expr);
-        if (exprKotlinType != null && InlineClassesUtilsKt.isInlineClassType(exprKotlinType) &&
-            FlexibleTypesKt.isNullabilityFlexible(exprKotlinType)) {
-            exprKotlinType = TypeUtils.makeNullable(exprKotlinType);
-        }
         StackValue value;
         if (compileTimeConstant != null) {
             value = StackValue.constant(compileTimeConstant.getValue(), exprType, exprKotlinType);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -201,7 +201,7 @@ class GenerationState private constructor(
 
     val target = configuration.get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT
     val runtimeStringConcat =
-        if (target.majorVersion >= JvmTarget.JVM_9.majorVersion)
+        if (target.bytecodeVersion >= JvmTarget.JVM_9.bytecodeVersion)
             configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INLINE
         else JvmStringConcat.INLINE
 
@@ -272,10 +272,7 @@ class GenerationState private constructor(
 
     val rootContext: CodegenContext<*> = RootContext(this)
 
-    val classFileVersion: Int = run {
-        val minorVersion = if (configuration.getBoolean(JVMConfigurationKeys.ENABLE_JVM_PREVIEW)) 0xffff else 0
-        (minorVersion shl 16) + target.majorVersion
-    }
+    val classFileVersion: Int = target.bytecodeVersion
 
     val generateParametersMetadata: Boolean = configuration.getBoolean(JVMConfigurationKeys.PARAMETERS_METADATA)
 
@@ -298,7 +295,7 @@ class GenerationState private constructor(
             ?: if (languageVersionSettings.languageVersion >= LanguageVersion.LATEST_STABLE) JvmMetadataVersion.INSTANCE
             else JvmMetadataVersion(1, 1, 18)
 
-    val abiStability = configuration.get(JVMConfigurationKeys.ABI_STABILITY)
+    val isIrWithStableAbi = configuration.getBoolean(JVMConfigurationKeys.IS_IR_WITH_STABLE_ABI)
 
     val globalSerializationBindings = JvmSerializationBindings()
     var mapInlineClass: (ClassDescriptor) -> Type = { descriptor -> typeMapper.mapType(descriptor.defaultType) }

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

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

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

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

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

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

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

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

compiler/build.gradle.kts

@@ -46,7 +46,7 @@ dependencies {
     testCompile(projectTests(":compiler:fir:raw-fir:psi2fir"))
     testCompile(projectTests(":compiler:fir:raw-fir:light-tree2fir"))
     testCompile(projectTests(":compiler:fir:fir2ir"))
-    testCompile(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testCompile(projectTests(":compiler:fir:analysis-tests"))
     testCompile(projectTests(":compiler:visualizer"))
     testCompile(projectTests(":generators:test-generator"))
     testCompile(project(":compiler:ir.ir2cfg"))
@@ -98,6 +98,6 @@ projectTest(parallel = true) {
     }
 }
 
-val generateTestData by generator("org.jetbrains.kotlin.generators.tests.GenerateCompilerTestDataKt")
+val generateTests by generator("org.jetbrains.kotlin.generators.tests.GenerateCompilerTestsKt")
 
 testsJar()

compiler/cli/bin/kotlinc.bat

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

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

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

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

@@ -95,20 +95,18 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     var irCheckLocalNames: Boolean by FreezableVar(false)
 
     @Argument(
-        value = "-Xallow-unstable-dependencies",
-        description = "Do not report errors on classes in dependencies, which were compiled by an unstable version of the Kotlin compiler"
+        value = "-Xallow-jvm-ir-dependencies",
+        description = "When not using the IR backend, do not report errors on those classes in dependencies, " +
+                "which were compiled by the IR backend"
     )
-    var allowUnstableDependencies: Boolean by FreezableVar(false)
+    var allowJvmIrDependencies: Boolean by FreezableVar(false)
 
     @Argument(
-        value = "-Xabi-stability",
-        valueDescription = "{stable|unstable}",
-        description = "When using unstable compiler features such as FIR, use 'stable' to mark generated class files as stable\n" +
-                "to prevent diagnostics from stable compilers at the call site.\n" +
-                "When using the JVM IR backend, conversely, use 'unstable' to mark generated class files as unstable\n" +
-                "to force diagnostics to be reported."
+        value = "-Xir-binary-with-stable-abi",
+        description = "When using the IR backend, produce binaries which can be read by non-IR backend.\n" +
+                "The author is responsible for verifying that the resulting binaries do indeed have the correct ABI"
     )
-    var abiStability: String? by FreezableVar(null)
+    var isIrWithStableAbi: Boolean by FreezableVar(false)
 
     @Argument(
         value = "-Xir-do-not-clear-binding-context",
@@ -420,13 +418,6 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var useOldInlineClassesManglingScheme: Boolean by FreezableVar(false)
 
-    @Argument(
-        value = "-Xjvm-enable-preview",
-        description = "Allow using features from Java language that are in preview phase.\n" +
-                "Works as `--enable-preview` in Java. All class files are marked as preview-generated thus it won't be possible to use them in release environment"
-    )
-    var enableJvmPreview: Boolean by FreezableVar(false)
-
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         val result = super.configureAnalysisFlags(collector)
         result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics
@@ -447,8 +438,7 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
         result[JvmAnalysisFlags.sanitizeParentheses] = sanitizeParentheses
         result[JvmAnalysisFlags.suppressMissingBuiltinsError] = suppressMissingBuiltinsError
         result[JvmAnalysisFlags.irCheckLocalNames] = irCheckLocalNames
-        result[JvmAnalysisFlags.enableJvmPreview] = enableJvmPreview
-        result[AnalysisFlags.allowUnstableDependencies] = allowUnstableDependencies || useFir
+        result[AnalysisFlags.reportErrorsOnIrDependencies] = !useIR && !useFir && !allowJvmIrDependencies
         result[JvmAnalysisFlags.disableUltraLightClasses] = disableUltraLightClasses
         return result
     }

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

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

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.common.messages
+
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
+
+/**
+ * This class behaviour is the same as [MessageCollector.report] in [AnalyzerWithCompilerReport.reportDiagnostic].
+ */
+class DefaultDiagnosticReporter(override val messageCollector: MessageCollector) : MessageCollectorBasedReporter
+
+interface MessageCollectorBasedReporter : DiagnosticMessageReporter {
+    val messageCollector: MessageCollector
+
+    override fun report(diagnostic: Diagnostic, file: PsiFile, render: String) = messageCollector.report(
+        AnalyzerWithCompilerReport.convertSeverity(diagnostic.severity),
+        render,
+        MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumn(diagnostic))
+    )
+}

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

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

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.common.messages;
+
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
+import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils;
+
+import static com.intellij.openapi.util.io.FileUtil.toSystemDependentName;
+
+public class MessageUtil {
+    private MessageUtil() {}
+
+    @Nullable
+    public static CompilerMessageLocation psiElementToMessageLocation(@Nullable PsiElement element) {
+        if (element == null) return null;
+        PsiFile file = element.getContainingFile();
+        return psiFileToMessageLocation(file, "<no path>", DiagnosticUtils.getLineAndColumnInPsiFile(file, element.getTextRange()));
+    }
+
+    @Nullable
+    public static CompilerMessageLocation psiFileToMessageLocation(
+            @NotNull PsiFile file,
+            @Nullable String defaultValue,
+            @NotNull PsiDiagnosticUtils.LineAndColumn lineAndColumn
+    ) {
+        VirtualFile virtualFile = file.getVirtualFile();
+        String path = virtualFile != null ? virtualFileToPath(virtualFile) : defaultValue;
+        return CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn(), lineAndColumn.getLineContent());
+    }
+
+    @NotNull
+    public static String virtualFileToPath(@NotNull VirtualFile virtualFile) {
+        return toSystemDependentName(virtualFile.getPath());
+    }
+}

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

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

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

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

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

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

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

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

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

@@ -40,6 +40,7 @@ public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnviron
         registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
 
         registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler.class);
 
         registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
 
@@ -51,4 +52,4 @@ public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnviron
     protected VirtualFileSystem createJrtFileSystem() {
         return new CoreJrtFileSystem();
     }
-}
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.cli.jvm.compiler;
+
+import com.intellij.DynamicBundle;
+import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.runner.JavaMainMethodProvider;
+import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.lang.MetaLanguage;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.meta.MetaDataContributor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
+
+public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+        registerExtensionPoints();
+        return environment;
+    }
+
+    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        super(parentDisposable, unitTestMode);
+    }
+
+    private static void registerExtensionPoints() {
+        registerApplicationExtensionPoint(DynamicBundle.LanguageBundleEP.EP_NAME, DynamicBundle.LanguageBundleEP.class);
+        registerApplicationExtensionPoint(FileContextProvider.EP_NAME, FileContextProvider.class);
+
+        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
+        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.getInstance().EP_NAME, ClassFileDecompilers.Decompiler.class);
+
+        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
+
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+    }
+
+    @Nullable
+    @Override
+    protected VirtualFileSystem createJrtFileSystem() {
+        return new CoreJrtFileSystem();
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+package org.jetbrains.kotlin.cli.jvm.compiler;
+
+import com.intellij.DynamicBundle;
+import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.runner.JavaMainMethodProvider;
+import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.lang.MetaLanguage;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.meta.MetaDataContributor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
+
+public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+        registerExtensionPoints();
+        return environment;
+    }
+
+    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        super(parentDisposable, unitTestMode);
+    }
+
+    private static void registerExtensionPoints() {
+        registerApplicationExtensionPoint(DynamicBundle.LanguageBundleEP.EP_NAME, DynamicBundle.LanguageBundleEP.class);
+        registerApplicationExtensionPoint(FileContextProvider.EP_NAME, FileContextProvider.class);
+
+        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
+        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+
+        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
+
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+    }
+
+    @Nullable
+    @Override
+    protected VirtualFileSystem createJrtFileSystem() {
+        return new CoreJrtFileSystem();
+    }
+}

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

@@ -33,16 +33,13 @@ import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.extensions.ExtensionsArea
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.LanguageLevelProjectExtension
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtilRt
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.*
 import com.intellij.openapi.vfs.impl.ZipHandler
-import com.intellij.pom.java.LanguageLevel
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
-import com.intellij.psi.compiled.ClassFileDecompilers
 import com.intellij.psi.impl.JavaClassSupersImpl
 import com.intellij.psi.impl.PsiElementFinderImpl
 import com.intellij.psi.impl.PsiTreeChangePreprocessor
@@ -252,8 +249,6 @@ class KotlinCoreEnvironment private constructor(
         project.putUserData(APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY, fun(roots: List<File>) {
             updateClasspath(roots.map { JavaSourceRoot(it, null) })
         })
-
-        project.setupHighestLanguageLevel()
     }
 
     private fun collectAdditionalSources(project: MockProject) {
@@ -458,20 +453,6 @@ class KotlinCoreEnvironment private constructor(
             return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs)
         }
 
-        @TestOnly
-        @JvmStatic
-        fun createForTests(
-            projectEnvironment: ProjectEnvironment, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
-        ): KotlinCoreEnvironment {
-            return KotlinCoreEnvironment(projectEnvironment, initialConfiguration, extensionConfigs)
-        }
-
-        @TestOnly
-        fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment {
-            val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            return ProjectEnvironment(parentDisposable, appEnv)
-        }
-
         // used in the daemon for jar cache cleanup
         val applicationEnvironment: KotlinCoreApplicationEnvironment? get() = ourApplicationEnvironment
 
@@ -528,11 +509,6 @@ class KotlinCoreEnvironment private constructor(
             val applicationEnvironment = KotlinCoreApplicationEnvironment.create(parentDisposable, unitTestMode)
 
             registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/compiler.xml")
-            // FIX ME WHEN BUNCH 202 REMOVED: this code is required to support compiler bundled to both 202 and 203.
-            // Please, remove "com.intellij.psi.classFileDecompiler" EP registration once 202 is no longer supported by the compiler
-            if (!Extensions.getRootArea().hasExtensionPoint("com.intellij.psi.classFileDecompiler")) {
-                registerApplicationExtensionPointsAndExtensionsFrom(configuration, "extensions/core.xml")
-            }
 
             registerApplicationServicesForCLI(applicationEnvironment)
             registerApplicationServices(applicationEnvironment)
@@ -716,4 +692,4 @@ class KotlinCoreEnvironment private constructor(
             }
         }
     }
-}
+}

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

@@ -456,20 +456,6 @@ class KotlinCoreEnvironment private constructor(
             return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs)
         }
 
-        @TestOnly
-        @JvmStatic
-        fun createForTests(
-            projectEnvironment: ProjectEnvironment, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles
-        ): KotlinCoreEnvironment {
-            return KotlinCoreEnvironment(projectEnvironment, initialConfiguration, extensionConfigs)
-        }
-
-        @TestOnly
-        fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment {
-            val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true)
-            return ProjectEnvironment(parentDisposable, appEnv)
-        }
-
         // used in the daemon for jar cache cleanup
         val applicationEnvironment: KotlinCoreApplicationEnvironment? get() = ourApplicationEnvironment
 
@@ -700,4 +686,4 @@ class KotlinCoreEnvironment private constructor(
             }
         }
     }
-}
+}

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

@@ -52,10 +52,10 @@ import org.jetbrains.kotlin.codegen.state.GenerationStateEventCallback
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
-import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
+import org.jetbrains.kotlin.fir.backend.jvm.FirMetadataSerializer
 import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo
@@ -389,8 +389,10 @@ object KotlinToJVMBytecodeCompiler {
             performanceManager?.notifyIRGenerationStarted()
             generationState.beforeCompile()
             codegenFactory.generateModuleInFrontendIRMode(
-                generationState, moduleFragment, symbolTable, sourceManager, extensions, FirJvmBackendExtension(session, components)
-            )
+                generationState, moduleFragment, symbolTable, sourceManager, extensions
+            ) { context, irClass, _, serializationBindings, parent ->
+                FirMetadataSerializer(session, context, irClass, serializationBindings, parent)
+            }
             CodegenFactory.doCheckCancelled(generationState)
             generationState.factory.done()
 
@@ -461,10 +463,6 @@ object KotlinToJVMBytecodeCompiler {
                 environment.updateClasspath(result.additionalJavaRoots.map { JavaSourceRoot(it, null) })
             }
 
-            if (result.additionalClassPathRoots.isNotEmpty()) {
-                environment.updateClasspath(result.additionalClassPathRoots.map { JvmClasspathRoot(it, false) })
-            }
-
             if (result.additionalKotlinRoots.isNotEmpty()) {
                 environment.addKotlinSourceRoots(result.additionalKotlinRoots)
             }
@@ -474,8 +472,8 @@ object KotlinToJVMBytecodeCompiler {
             // Clear all diagnostic messages
             configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY]?.clear()
 
-            // Repeat analysis with additional source roots generated by compiler plugins.
-            return repeatAnalysisIfNeeded(analyze(environment), environment)
+            // Repeat analysis with additional Java roots (kapt generated sources)
+            return analyze(environment)
         }
 
         return result
@@ -570,6 +568,8 @@ object KotlinToJVMBytecodeCompiler {
         sourceFiles: List<KtFile>,
         module: Module?
     ): GenerationState {
+        val isIR = (configuration.getBoolean(JVMConfigurationKeys.IR) ||
+                configuration.getBoolean(CommonConfigurationKeys.USE_FIR))
         val generationState = GenerationState.Builder(
             environment.project,
             ClassBuilderFactories.BINARIES,
@@ -579,12 +579,13 @@ object KotlinToJVMBytecodeCompiler {
             configuration
         )
             .codegenFactory(
-                if (configuration.getBoolean(JVMConfigurationKeys.IR)) JvmIrCodegenFactory(
+                if (isIR) JvmIrCodegenFactory(
                     configuration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases)
                 ) else DefaultCodegenFactory
             )
             .withModule(module)
             .onIndependentPartCompilationEnd(createOutputFilesFlushingCallbackIfPossible(configuration))
+            .isIrBackend(isIR)
             .build()
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()

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

@@ -90,12 +90,11 @@ object TopDownAnalyzerFacadeForJVM {
         packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
         declarationProviderFactory: (StorageManager, Collection<KtFile>) -> DeclarationProviderFactory = ::FileBasedDeclarationProviderFactory,
         sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files),
-        klibList: List<KotlinLibrary> = emptyList(),
-        explicitModuleDependencyList: List<ModuleDescriptorImpl> = emptyList()
+        klibList: List<KotlinLibrary> = emptyList()
     ): AnalysisResult {
         val container = createContainer(
             project, files, trace, configuration, packagePartProvider, declarationProviderFactory, CompilerEnvironment,
-            sourceModuleSearchScope, klibList, explicitModuleDependencyList = explicitModuleDependencyList
+            sourceModuleSearchScope, klibList
         )
 
         val module = container.get<ModuleDescriptor>()
@@ -128,7 +127,6 @@ object TopDownAnalyzerFacadeForJVM {
         return AnalysisResult.success(trace.bindingContext, module)
     }
 
-    @OptIn(ExperimentalStdlibApi::class)
     fun createContainer(
         project: Project,
         files: Collection<KtFile>,
@@ -139,8 +137,7 @@ object TopDownAnalyzerFacadeForJVM {
         targetEnvironment: TargetEnvironment = CompilerEnvironment,
         sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files),
         klibList: List<KotlinLibrary> = emptyList(),
-        implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null,
-        explicitModuleDependencyList: List<ModuleDescriptorImpl> = emptyList()
+        implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null
     ): ComponentProvider {
         val jvmTarget = configuration.get(JVMConfigurationKeys.JVM_TARGET, JvmTarget.DEFAULT)
         val languageVersionSettings = configuration.languageVersionSettings
@@ -255,16 +252,8 @@ object TopDownAnalyzerFacadeForJVM {
         val klibModules = getKlibModules(klibList, dependencyModule)
 
         // TODO: remove dependencyModule from friends
-        val dependencies = buildList {
-            add(module)
-            dependencyModule?.let { add(it) }
-            add(fallbackBuiltIns)
-            addAll(klibModules)
-            @Suppress("UNCHECKED_CAST")
-            addAll(explicitModuleDependencyList)
-        }
         module.setDependencies(
-            dependencies,
+            listOfNotNull(module, dependencyModule, fallbackBuiltIns) + klibModules,
             if (dependencyModule != null) setOf(dependencyModule) else emptySet()
         )
         module.initialize(

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

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

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

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

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.getLibraryFromHome
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.JvmModulePathRoot
@@ -20,6 +19,9 @@ import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
 fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArguments) {
+
+    val messageCollector = getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+
     put(JVMConfigurationKeys.INCLUDE_RUNTIME, arguments.includeRuntime)
 
     putIfNotNull(JVMConfigurationKeys.FRIEND_PATHS, arguments.friendPaths?.asList())
@@ -37,7 +39,7 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
     }
 
     val jvmTarget = get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.DEFAULT
-    if (jvmTarget.majorVersion < JvmTarget.JVM_1_8.majorVersion) {
+    if (jvmTarget.bytecodeVersion < JvmTarget.JVM_1_8.bytecodeVersion) {
         val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)
         if (jvmDefaultMode.forAllMethodsWithBody) {
             messageCollector.report(
@@ -51,7 +53,7 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
         val runtimeStringConcat = JvmStringConcat.fromString(arguments.stringConcat!!)
         if (runtimeStringConcat != null) {
             put(JVMConfigurationKeys.STRING_CONCAT, runtimeStringConcat)
-            if (jvmTarget.majorVersion < JvmTarget.JVM_9.majorVersion && runtimeStringConcat != JvmStringConcat.INLINE) {
+            if (jvmTarget.bytecodeVersion < JvmTarget.JVM_9.bytecodeVersion && runtimeStringConcat != JvmStringConcat.INLINE) {
                 messageCollector.report(
                     WARNING,
                     "`-Xstring-concat=${arguments.stringConcat}` does nothing with JVM target `${jvmTarget.description}`."
@@ -69,6 +71,9 @@ fun CompilerConfiguration.setupJvmSpecificArguments(arguments: K2JVMCompilerArgu
 }
 
 fun CompilerConfiguration.configureJdkHome(arguments: K2JVMCompilerArguments): Boolean {
+
+    val messageCollector = getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+
     if (arguments.noJdk) {
         put(JVMConfigurationKeys.NO_JDK, true)
 
@@ -79,7 +84,7 @@ fun CompilerConfiguration.configureJdkHome(arguments: K2JVMCompilerArguments): B
     }
 
     if (arguments.jdkHome != null) {
-        val jdkHome = File(arguments.jdkHome!!)
+        val jdkHome = File(arguments.jdkHome)
         if (!jdkHome.exists()) {
             messageCollector.report(ERROR, "JDK home directory does not exist: $jdkHome")
             return false
@@ -109,6 +114,7 @@ fun CompilerConfiguration.configureExplicitContentRoots(arguments: K2JVMCompiler
 }
 
 fun CompilerConfiguration.configureStandardLibs(paths: KotlinPaths?, arguments: K2JVMCompilerArguments) {
+    val messageCollector = getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
     val isModularJava = isModularJava()
 
     fun addRoot(moduleName: String, libraryName: String, getLibrary: (KotlinPaths) -> File, noLibraryArgument: String) {
@@ -165,23 +171,8 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
 
     put(JVMConfigurationKeys.PARAMETERS_METADATA, arguments.javaParameters)
 
-    val useIR = (arguments.useIR && !arguments.noUseIR) || arguments.useFir
-    put(JVMConfigurationKeys.IR, useIR)
-
-    val abiStability = JvmAbiStability.fromStringOrNull(arguments.abiStability)
-    if (arguments.abiStability != null) {
-        if (abiStability == null) {
-            messageCollector.report(
-                ERROR,
-                "Unknown ABI stability mode: ${arguments.abiStability}, supported modes: ${JvmAbiStability.values().map { it.description }}"
-            )
-        } else if (!useIR && abiStability == JvmAbiStability.UNSTABLE) {
-            messageCollector.report(ERROR, "-Xabi-stability=unstable is not supported in the old JVM backend")
-        } else {
-            put(JVMConfigurationKeys.ABI_STABILITY, abiStability)
-        }
-    }
-
+    put(JVMConfigurationKeys.IR, arguments.useIR && !arguments.noUseIR)
+    put(JVMConfigurationKeys.IS_IR_WITH_STABLE_ABI, arguments.isIrWithStableAbi)
     put(JVMConfigurationKeys.DO_NOT_CLEAR_BINDING_CONTEXT, arguments.doNotClearBindingContext)
     put(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, arguments.noCallAssertions)
     put(JVMConfigurationKeys.DISABLE_RECEIVER_ASSERTIONS, arguments.noReceiverAssertions)
@@ -198,45 +189,49 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
     put(JVMConfigurationKeys.NO_UNIFIED_NULL_CHECKS, arguments.noUnifiedNullChecks)
 
     if (!JVMConstructorCallNormalizationMode.isSupportedValue(arguments.constructorCallNormalizationMode)) {
-        messageCollector.report(
+        getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(
             ERROR,
             "Unknown constructor call normalization mode: ${arguments.constructorCallNormalizationMode}, " +
                     "supported modes: ${JVMConstructorCallNormalizationMode.values().map { it.description }}"
         )
     }
 
-    val constructorCallNormalizationMode = JVMConstructorCallNormalizationMode.fromStringOrNull(arguments.constructorCallNormalizationMode)
+    val constructorCallNormalizationMode =
+        JVMConstructorCallNormalizationMode.fromStringOrNull(arguments.constructorCallNormalizationMode)
     if (constructorCallNormalizationMode != null) {
-        put(JVMConfigurationKeys.CONSTRUCTOR_CALL_NORMALIZATION_MODE, constructorCallNormalizationMode)
+        put(
+            JVMConfigurationKeys.CONSTRUCTOR_CALL_NORMALIZATION_MODE,
+            constructorCallNormalizationMode
+        )
     }
 
     val assertionsMode =
         JVMAssertionsMode.fromStringOrNull(arguments.assertionsMode)
     if (assertionsMode == null) {
-        messageCollector.report(
+        getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(
             ERROR,
-            "Unknown assertions mode: ${arguments.assertionsMode}, supported modes: ${JVMAssertionsMode.values().map { it.description }}"
+            "Unknown assertions mode: ${arguments.assertionsMode}, " +
+                    "supported modes: ${JVMAssertionsMode.values().map { it.description }}"
         )
     }
-    put(JVMConfigurationKeys.ASSERTIONS_MODE, assertionsMode ?: JVMAssertionsMode.DEFAULT)
+    put(
+        JVMConfigurationKeys.ASSERTIONS_MODE,
+        assertionsMode ?: JVMAssertionsMode.DEFAULT
+    )
 
     put(JVMConfigurationKeys.USE_TYPE_TABLE, arguments.useTypeTable)
     put(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK, arguments.skipRuntimeVersionCheck)
     put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, arguments.useOldClassFilesReading)
 
     if (arguments.useOldClassFilesReading) {
-        messageCollector.report(INFO, "Using the old java class files reading implementation")
+        getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+            .report(INFO, "Using the old java class files reading implementation")
     }
 
     put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
     put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
     put(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS, arguments.useOldSpilledVarTypeAnalysis)
     put(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME, arguments.useOldInlineClassesManglingScheme)
-    put(JVMConfigurationKeys.ENABLE_JVM_PREVIEW, arguments.enableJvmPreview)
-
-    if (arguments.enableJvmPreview) {
-        messageCollector.report(INFO, "Using preview Java language features")
-    }
 
     arguments.declarationsOutputPath?.let { put(JVMConfigurationKeys.DECLARATIONS_JSON_PATH, it) }
 }
@@ -247,7 +242,4 @@ fun CompilerConfiguration.configureKlibPaths(arguments: K2JVMCompilerArguments)
         ?.toTypedArray()
         ?.filterNot { it.isEmpty() }
         ?.let { put(JVMConfigurationKeys.KLIB_PATHS, it) }
-}
-
-private val CompilerConfiguration.messageCollector: MessageCollector
-    get() = getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+}

compiler/compiler-runner/src/org/jetbrains/kotlin/compilerRunner/CompilerOutputParser.kt

@@ -30,7 +30,6 @@ import org.xml.sax.SAXException
 import org.xml.sax.helpers.DefaultHandler
 import java.io.IOException
 import java.io.Reader
-import java.util.*
 import javax.xml.parsers.SAXParserFactory
 
 object CompilerOutputParser {
@@ -125,7 +124,7 @@ object CompilerOutputParser {
                 // We're directly inside the root tag: <MESSAGES>
                 return
             }
-            val qNameLowerCase = qName.toLowerCase(Locale.US)
+            val qNameLowerCase = qName.toLowerCase()
             var category: CompilerMessageSeverity? = CATEGORIES[qNameLowerCase]
             if (category == null) {
                 messageCollector.report(ERROR, "Unknown compiler message tag: $qName")

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

@@ -117,8 +117,8 @@ public class JVMConfigurationKeys {
     public static final CompilerConfigurationKey<List<String>> KLIB_PATHS =
             CompilerConfigurationKey.create("Paths to .klib libraries");
 
-    public static final CompilerConfigurationKey<JvmAbiStability> ABI_STABILITY =
-            CompilerConfigurationKey.create("ABI stability of class files produced by JVM IR and/or FIR");
+    public static final CompilerConfigurationKey<Boolean> IS_IR_WITH_STABLE_ABI =
+            CompilerConfigurationKey.create("Is IR with stable ABI");
 
     public static final CompilerConfigurationKey<Boolean> DO_NOT_CLEAR_BINDING_CONTEXT =
             CompilerConfigurationKey.create("When using the IR backend, do not clear BindingContext between psi2ir and lowerings");
@@ -140,7 +140,4 @@ public class JVMConfigurationKeys {
 
     public static final CompilerConfigurationKey<Boolean> USE_OLD_INLINE_CLASSES_MANGLING_SCHEME =
             CompilerConfigurationKey.create("Use old, 1.4 version of inline classes mangling scheme");
-
-    public static final CompilerConfigurationKey<Boolean> ENABLE_JVM_PREVIEW =
-            CompilerConfigurationKey.create("Enable Java language preview features");
 }

compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAbiStability.kt

@@ -1,17 +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.config
-
-enum class JvmAbiStability(val description: String) {
-    STABLE("stable"),
-    UNSTABLE("unstable"),
-    ;
-
-    companion object {
-        fun fromStringOrNull(string: String?): JvmAbiStability? =
-            values().find { it.description == string }
-    }
-}

compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt

@@ -33,9 +33,6 @@ object JvmAnalysisFlags {
     @JvmStatic
     val disableUltraLightClasses by AnalysisFlag.Delegates.Boolean
 
-    @JvmStatic
-    val enableJvmPreview by AnalysisFlag.Delegates.Boolean
-
     private object Delegates {
         object JavaTypeEnhancementStateWarnByDefault {
             operator fun provideDelegate(instance: Any?, property: KProperty<*>): AnalysisFlag.Delegate<JavaTypeEnhancementState> =

compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmTarget.kt

@@ -19,21 +19,32 @@ package org.jetbrains.kotlin.config
 import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.org.objectweb.asm.Opcodes
 
-enum class JvmTarget(
-    override val description: String,
-    val majorVersion: Int,
-) : TargetPlatformVersion {
-    JVM_1_6("1.6", Opcodes.V1_6),
-    JVM_1_8("1.8", Opcodes.V1_8),
-    JVM_9("9", Opcodes.V9),
-    JVM_10("10", Opcodes.V10),
-    JVM_11("11", Opcodes.V11),
-    JVM_12("12", Opcodes.V12),
-    JVM_13("13", Opcodes.V12 + 1),
-    JVM_14("14", Opcodes.V12 + 2),
-    JVM_15("15", Opcodes.V12 + 3),
+enum class JvmTarget(override val description: String) : TargetPlatformVersion {
+    JVM_1_6("1.6"),
+    JVM_1_8("1.8"),
+    JVM_9("9"),
+    JVM_10("10"),
+    JVM_11("11"),
+    JVM_12("12"),
+    JVM_13("13"),
+    JVM_14("14"),
+    JVM_15("15"),
     ;
 
+    val bytecodeVersion: Int by lazy {
+        when (this) {
+            JVM_1_6 -> Opcodes.V1_6
+            JVM_1_8 -> Opcodes.V1_8
+            JVM_9 -> Opcodes.V9
+            JVM_10 -> Opcodes.V10
+            JVM_11 -> Opcodes.V11
+            JVM_12 -> Opcodes.V12
+            JVM_13 -> Opcodes.V12 + 1
+            JVM_14 -> Opcodes.V12 + 2
+            JVM_15 -> Opcodes.V12 + 3
+        }
+    }
+
     companion object {
         @JvmField
         val DEFAULT = JVM_1_6
@@ -41,14 +52,14 @@ enum class JvmTarget(
         @JvmStatic
         fun fromString(string: String) = values().find { it.description == string }
 
-        fun getDescription(majorVersion: Int): String {
-            val platformDescription = values().find { it.majorVersion == majorVersion }?.description ?: when (majorVersion) {
+        fun getDescription(bytecodeVersion: Int): String {
+            val platformDescription = values().find { it.bytecodeVersion == bytecodeVersion }?.description ?: when (bytecodeVersion) {
                 Opcodes.V1_7 -> "1.7"
                 else -> null
             }
 
             return if (platformDescription != null) "JVM target $platformDescription"
-            else "JVM bytecode version $majorVersion"
+            else "JVM bytecode version $bytecodeVersion"
         }
     }
 }

compiler/config.jvm/src/org/jetbrains/kotlin/platform/jvm/JvmPlatform.kt

@@ -18,7 +18,7 @@ abstract class JvmPlatform : SimplePlatform("JVM") {
 
 @Suppress("DEPRECATION_ERROR")
 object JvmPlatforms {
-    private val UNSPECIFIED_SIMPLE_JVM_PLATFORM = JdkPlatform(JvmTarget.DEFAULT)
+    private val UNSPECIFIED_SIMPLE_JVM_PLATFORM = JdkPlatform(JvmTarget.JVM_1_6)
     private val jvmTargetToJdkPlatform: Map<JvmTarget, TargetPlatform> =
         JvmTarget.values().map { it to JdkPlatform(it).toTargetPlatform() }.toMap()
 

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

@@ -46,7 +46,7 @@ object AnalysisFlags {
     val ideMode by AnalysisFlag.Delegates.Boolean
 
     @JvmStatic
-    val allowUnstableDependencies by AnalysisFlag.Delegates.Boolean
+    val reportErrorsOnIrDependencies by AnalysisFlag.Delegates.Boolean
 
     @JvmStatic
     val libraryToSourceAnalysis by AnalysisFlag.Delegates.Boolean

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/FileSystemUtils.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.daemon.common
 
-import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import java.io.File
 
 enum class OSKind {
@@ -26,7 +25,7 @@ enum class OSKind {
     Unknown;
 
     companion object {
-        val current: OSKind = System.getProperty("os.name").toLowerCaseAsciiOnly().let {
+        val current: OSKind = System.getProperty("os.name").toLowerCase().let {
             when {
                 // partly taken from http://www.code4copy.com/java/post/detecting-os-type-in-java
                 it.startsWith("windows") -> Windows

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.daemon
 
 import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -30,16 +30,13 @@ import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull
-import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.PrintStream
 import java.net.URLClassLoader
 import java.nio.file.Path
-import kotlin.io.path.ExperimentalPathApi
-import kotlin.io.path.createTempFile
-import kotlin.io.path.deleteIfExists
+import kotlin.io.path.*
 
 @OptIn(ExperimentalPathApi::class)
 class CompilerApiTest : KotlinIntegrationTestBase() {
@@ -86,8 +83,8 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
         return code to outputs
     }
 
-    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
-    private fun getSimpleScriptBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/simpleScript"
+    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getSimpleScriptBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/simpleScript"
 
     private fun run(baseDir: String, logName: String, vararg args: String): Int = runJava(baseDir, logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.daemon.client.*
 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus
-import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.utils.KotlinPaths
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -95,8 +95,8 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
             assertEquals("build results differ", AbstractCliTest.removePerfOutput(res1.out), AbstractCliTest.removePerfOutput(res2.out))
     }
 
-    private fun getTestBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
-    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getTestBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
+    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
 
     private fun run(logName: String, vararg args: String): Int = runJava(getTestBaseDir(), logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.daemon.experimental.integration
 import com.intellij.openapi.application.ApplicationManager
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.test.IgnoreAll
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull
-import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.junit.Assert
 import org.junit.runner.RunWith
 import java.io.File
@@ -32,8 +31,7 @@ import java.net.URLClassLoader
 import java.nio.file.Path
 import java.util.logging.LogManager
 import java.util.logging.Logger
-import kotlin.io.path.ExperimentalPathApi
-import kotlin.io.path.createTempFile
+import kotlin.io.path.*
 
 private val logFiles = arrayListOf<String>()
 
@@ -152,8 +150,8 @@ class CompilerApiTest : KotlinIntegrationTestBase() {
         code to outputs
     }
 
-    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
-    private fun getSimpleScriptBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/simpleScript"
+    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getSimpleScriptBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/simpleScript"
 
     private fun run(baseDir: String, logName: String, vararg args: String): Int = runJava(baseDir, logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.daemon.common.experimental.findCallbackServerSocket
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.progress.experimental.CompilationCanceledStatus
 import org.jetbrains.kotlin.test.IgnoreAll
-import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.utils.KotlinPaths
 import org.junit.runner.RunWith
 import java.io.ByteArrayOutputStream
@@ -157,8 +157,8 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() {
         }
     }
 
-    private fun getTestBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
-    private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp"
+    private fun getTestBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true)
+    private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp"
 
     private fun run(logName: String, vararg args: String): Int = runJava(getTestBaseDir(), logName, *args)
 

compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.daemon.experimental.CompileServiceServerSideImpl
 import org.jetbrains.kotlin.daemon.loggerCompatiblePath
 import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase
 import org.jetbrains.kotlin.test.IgnoreAll
-import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.junit.runner.RunWith
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -36,9 +36,7 @@ import java.util.*
 import java.util.logging.LogManager
 import java.util.logging.Logger
 import kotlin.concurrent.schedule
-import kotlin.io.path.ExperimentalPathApi
-import kotlin.io.path.createTempFile
-import kotlin.io.path.deleteIfExists
+import kotlin.io.path.*
 
 @OptIn(ExperimentalPathApi::class)
 @RunWith(IgnoreAll::class)
@@ -366,7 +364,7 @@ class ConnectionsTest : KotlinIntegrationTestBase() {
                                 CompileService.NO_SESSION,
                                 arrayOf(
                                     "-include-runtime",
-                                    File(KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp", "hello.kt").absolutePath,
+                                    File(KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp", "hello.kt").absolutePath,
                                     "-d",
                                     jar
                                 ),

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

@@ -14,59 +14,21 @@ dependencies {
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 
     testApi(intellijDep())
-    testApi(projectTests(":compiler:test-infrastructure"))
-    testApi(projectTests(":compiler:test-infrastructure-utils"))
-    testApi(projectTests(":compiler:tests-compiler-utils"))
-    testApi(projectTests(":compiler:tests-common-new"))
-    testApi(project(":compiler:cli"))
+
+    testApi(commonDep("junit:junit"))
+    testCompileOnly(project(":kotlin-test:kotlin-test-jvm"))
+    testCompileOnly(project(":kotlin-test:kotlin-test-junit"))
+    testApi(projectTests(":compiler:tests-common"))
     testApi(project(":compiler:fir:checkers"))
     testApi(project(":compiler:fir:entrypoint"))
     testApi(project(":compiler:frontend"))
 
-    testApi(platform("org.junit:junit-bom:5.7.0"))
-    testApi("org.junit.jupiter:junit-jupiter")
-    testApi("org.junit.platform:junit-platform-commons:1.7.0")
-
     testCompileOnly(project(":kotlin-reflect-api"))
-    testRuntimeOnly(project(":kotlin-reflect"))
-    testRuntimeOnly(project(":core:descriptors.runtime"))
+    testRuntime(project(":kotlin-reflect"))
+    testRuntime(project(":core:descriptors.runtime"))
 
-    testImplementation(intellijCoreDep()) { includeJars("intellij-core") }
-    testImplementation(intellijDep()) {
-        // This dependency is needed only for FileComparisonFailure
-        includeJars("idea_rt", rootProject = rootProject)
-        isTransitive = false
-    }
-
-    // This is needed only for using FileComparisonFailure, which relies on JUnit 3 classes
-    testRuntimeOnly(commonDep("junit:junit"))
-    testRuntimeOnly(intellijDep()) {
-        includeJars(
-            "jps-model",
-            "extensions",
-            "util",
-            "platform-api",
-            "platform-impl",
-            "idea",
-            "guava",
-            "trove4j",
-            "asm-all",
-            "log4j",
-            "jdom",
-            "streamex",
-            "bootstrap",
-            "jna",
-            rootProject = rootProject
-        )
-    }
-
-    Platform[202] {
-        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-1") }
-    }
-    Platform[203].orHigher {
-        testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-3") }
-    }
-    testRuntimeOnly(toolsJar())
+    testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 
 val generationRoot = projectDir.resolve("tests-gen")
@@ -86,13 +48,11 @@ if (kotlinBuildProperties.isInJpsBuildIdeaSync) {
     }
 }
 
-projectTest(parallel = true, jUnit5Enabled = true) {
+projectTest(parallel = true) {
     dependsOn(":dist")
     workingDir = rootDir
     jvmArgs!!.removeIf { it.contains("-Xmx") }
     maxHeapSize = "3g"
-
-    useJUnitPlatform()
 }
 
 testsJar()

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

@@ -1,58 +0,0 @@
-import org.jetbrains.kotlin.ideaExt.idea
-
-/*
- * Copyright 2000-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.
- */
-
-plugins {
-    kotlin("jvm")
-    id("jps-compatible")
-}
-
-dependencies {
-    compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
-
-    testApi(intellijDep())
-
-    testApi(commonDep("junit:junit"))
-    testCompileOnly(project(":kotlin-test:kotlin-test-jvm"))
-    testCompileOnly(project(":kotlin-test:kotlin-test-junit"))
-    testApi(projectTests(":compiler:tests-common"))
-    testApi(project(":compiler:fir:checkers"))
-    testApi(project(":compiler:fir:entrypoint"))
-    testApi(project(":compiler:frontend"))
-
-    testCompileOnly(project(":kotlin-reflect-api"))
-    testRuntimeOnly(project(":kotlin-reflect"))
-    testRuntimeOnly(project(":core:descriptors.runtime"))
-
-    testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
-}
-
-val generationRoot = projectDir.resolve("tests-gen")
-
-sourceSets {
-    "main" { none() }
-    "test" {
-        projectDefault()
-        this.java.srcDir(generationRoot.name)
-    }
-}
-
-if (kotlinBuildProperties.isInJpsBuildIdeaSync) {
-    apply(plugin = "idea")
-    idea {
-        this.module.generatedSourceDirs.add(generationRoot)
-    }
-}
-
-projectTest(parallel = true) {
-    dependsOn(":dist")
-    workingDir = rootDir
-    jvmArgs!!.removeIf { it.contains("-Xmx") }
-    maxHeapSize = "3g"
-}
-
-testsJar()

compiler/fir/analysis-tests/testData/enhancement/jsr305/NonNullNever.fir.txt

@@ -1,4 +1,4 @@
-@R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/meta/TypeQualifierNickname|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) public abstract annotation class MyNullable : R|kotlin/Annotation| {
+@R|java/lang/annotation/Documented|() @R|javax/annotation/meta/TypeQualifierNickname|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.NEVER|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) public abstract annotation class MyNullable : R|kotlin/Annotation| {
     public constructor(): R|MyNullable|
 
 }

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/FieldsAreNullable.fir.txt

@@ -10,7 +10,7 @@
     public constructor(): R|A|
 
 }
-@R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/CheckForNull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.FIELD|())) public abstract annotation class FieldsAreNullable : R|kotlin/Annotation| {
+@R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|javax/annotation/CheckForNull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.FIELD|())) public abstract annotation class FieldsAreNullable : R|kotlin/Annotation| {
     public constructor(): R|FieldsAreNullable|
 
 }

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/ForceFlexibility.fir.txt

@@ -6,19 +6,19 @@
     public constructor(): R|A|
 
 }
-@R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|spr/UnknownNullability|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class ForceFlexibility : R|kotlin/Annotation| {
+@R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|spr/UnknownNullability|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class ForceFlexibility : R|kotlin/Annotation| {
     public constructor(): R|spr/ForceFlexibility|
 
 }
-@R|kotlin/annotation/Target|(<implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.CLASS|(), R|kotlin/annotation/AnnotationTarget.FILE|())) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/Nonnull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class NonNullApi : R|kotlin/Annotation| {
+@R|java/lang/annotation/Target|(R|java/lang/annotation/ElementType.TYPE|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|javax/annotation/Nonnull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class NonNullApi : R|kotlin/Annotation| {
     public constructor(): R|spr/NonNullApi|
 
 }
-@R|kotlin/annotation/Target|(<implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.VALUE_PARAMETER|(), R|kotlin/annotation/AnnotationTarget.FUNCTION|(), R|kotlin/annotation/AnnotationTarget.PROPERTY_GETTER|(), R|kotlin/annotation/AnnotationTarget.PROPERTY_SETTER|())) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.MAYBE|()) @R|javax/annotation/meta/TypeQualifierNickname|() public abstract annotation class Nullable : R|kotlin/Annotation| {
+@R|java/lang/annotation/Target|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.MAYBE|()) @R|javax/annotation/meta/TypeQualifierNickname|() public abstract annotation class Nullable : R|kotlin/Annotation| {
     public constructor(): R|spr/Nullable|
 
 }
-@R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/meta/TypeQualifierNickname|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) public abstract annotation class UnknownNullability : R|kotlin/Annotation| {
+@R|java/lang/annotation/Documented|() @R|javax/annotation/meta/TypeQualifierNickname|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) public abstract annotation class UnknownNullability : R|kotlin/Annotation| {
     public constructor(): R|spr/UnknownNullability|
 
 }

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/ForceFlexibleOverOverrides.fir.txt

@@ -20,15 +20,15 @@ public abstract interface B : R|kotlin/Any| {
     public abstract fun foobar(@R|javax/annotation/Nonnull|() x: R|@EnhancedNullability kotlin/String|): R|kotlin/Unit|
 
 }
-@R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|spr/UnknownNullability|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class ForceFlexibility : R|kotlin/Annotation| {
+@R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|spr/UnknownNullability|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class ForceFlexibility : R|kotlin/Annotation| {
     public constructor(): R|spr/ForceFlexibility|
 
 }
-@R|kotlin/annotation/Target|(<implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.CLASS|(), R|kotlin/annotation/AnnotationTarget.FILE|())) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/Nonnull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class NonNullApi : R|kotlin/Annotation| {
+@R|java/lang/annotation/Target|(R|java/lang/annotation/ElementType.TYPE|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|javax/annotation/Nonnull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|())) public abstract annotation class NonNullApi : R|kotlin/Annotation| {
     public constructor(): R|spr/NonNullApi|
 
 }
-@R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/meta/TypeQualifierNickname|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) public abstract annotation class UnknownNullability : R|kotlin/Annotation| {
+@R|java/lang/annotation/Documented|() @R|javax/annotation/meta/TypeQualifierNickname|() @R|javax/annotation/Nonnull|(R|javax/annotation/meta/When.UNKNOWN|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) public abstract annotation class UnknownNullability : R|kotlin/Annotation| {
     public constructor(): R|spr/UnknownNullability|
 
 }

compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault/NullabilityFromOverridden.fir.txt

@@ -54,11 +54,11 @@
     public constructor(): R|C|
 
 }
-@R|kotlin/annotation/Target|(<implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.CLASS|(), R|kotlin/annotation/AnnotationTarget.FILE|())) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/Nonnull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|(), R|java/lang/annotation/ElementType.FIELD|())) public abstract annotation class NonNullApi : R|kotlin/Annotation| {
+@R|java/lang/annotation/Target|(R|java/lang/annotation/ElementType.TYPE|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|javax/annotation/Nonnull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|(), R|java/lang/annotation/ElementType.FIELD|())) public abstract annotation class NonNullApi : R|kotlin/Annotation| {
     public constructor(): R|NonNullApi|
 
 }
-@R|kotlin/annotation/Target|(<implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.CLASS|(), R|kotlin/annotation/AnnotationTarget.FILE|())) @R|kotlin/annotation/Retention|(R|kotlin/annotation/AnnotationRetention.RUNTIME|()) @R|kotlin/annotation/MustBeDocumented|() @R|javax/annotation/CheckForNull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|(), R|java/lang/annotation/ElementType.FIELD|())) public abstract annotation class NullableApi : R|kotlin/Annotation| {
+@R|java/lang/annotation/Target|(R|java/lang/annotation/ElementType.TYPE|()) @R|java/lang/annotation/Retention|(R|java/lang/annotation/RetentionPolicy.RUNTIME|()) @R|java/lang/annotation/Documented|() @R|javax/annotation/CheckForNull|() @R|javax/annotation/meta/TypeQualifierDefault|(<implicitArrayOf>(R|java/lang/annotation/ElementType.METHOD|(), R|java/lang/annotation/ElementType.PARAMETER|(), R|java/lang/annotation/ElementType.FIELD|())) public abstract annotation class NullableApi : R|kotlin/Annotation| {
     public constructor(): R|NullableApi|
 
 }