JVM IR: Avoid getTopLevelClass in JvmSymbols

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt

@@ -47,8 +47,7 @@ class JvmBackendContext(
     override val irBuiltIns: IrBuiltIns,
     irModuleFragment: IrModuleFragment,
     symbolTable: SymbolTable,
-    val phaseConfig: PhaseConfig,
-    private val firMode: Boolean
+    val phaseConfig: PhaseConfig
 ) : CommonBackendContext {
     override val transformedFunction: MutableMap<IrFunctionSymbol, IrSimpleFunctionSymbol>
         get() = TODO("not implemented")
@@ -143,7 +142,7 @@ class JvmBackendContext(
         irModuleFragment: IrModuleFragment,
         symbolTable: ReferenceSymbolTable
     ) : Ir<JvmBackendContext>(this, irModuleFragment) {
-        override val symbols = JvmSymbols(this@JvmBackendContext, symbolTable, firMode)
+        override val symbols = JvmSymbols(this@JvmBackendContext, symbolTable)
 
         override fun unfoldInlineClassType(irType: IrType): IrType? {
             return InlineClassAbi.unboxType(irType)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt

@@ -60,11 +60,10 @@ object JvmBackendFacade {
         irModuleFragment: IrModuleFragment,
         symbolTable: SymbolTable,
         sourceManager: PsiSourceManager,
-        phaseConfig: PhaseConfig,
-        firMode: Boolean = false
+        phaseConfig: PhaseConfig
     ) {
         val context = JvmBackendContext(
-            state, sourceManager, irModuleFragment.irBuiltins, irModuleFragment, symbolTable, phaseConfig, firMode
+            state, sourceManager, irModuleFragment.irBuiltins, irModuleFragment, symbolTable, phaseConfig
         )
         state.irBasedMapAsmMethod = { descriptor ->
             context.methodSignatureMapper.mapAsmMethod(context.referenceFunction(descriptor).owner)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -43,9 +43,7 @@ class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory
         symbolTable: SymbolTable,
         sourceManager: PsiSourceManager
     ) {
-        JvmBackendFacade.doGenerateFilesInternal(
-            state, errorHandler, irModuleFragment, symbolTable, sourceManager, phaseConfig, firMode = true
-        )
+        JvmBackendFacade.doGenerateFilesInternal(state, errorHandler, irModuleFragment, symbolTable, sourceManager, phaseConfig)
     }
 
     override fun createPackageCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName): PackageCodegen {

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt

@@ -33,8 +33,7 @@ import org.jetbrains.kotlin.types.Variance
 
 class JvmSymbols(
     context: JvmBackendContext,
-    private val symbolTable: ReferenceSymbolTable,
-    firMode: Boolean
+    private val symbolTable: ReferenceSymbolTable
 ) : Symbols<JvmBackendContext>(context, symbolTable) {
     private val storageManager = LockBasedStorageManager(this::class.java.simpleName)
     private val kotlinPackage: IrPackageFragment = createPackage(FqName("kotlin"))
@@ -123,24 +122,19 @@ class JvmSymbols(
     val intrinsicStringPlus: IrFunctionSymbol =
         intrinsicsClass.functions.single { it.owner.name.asString() == "stringPlus" }
 
-    private val firStringBuilder =
-        if (firMode) {
-            createClass(FqName("java.lang.StringBuilder")) { klass ->
-                klass.addConstructor()
-                klass.addFunction("toString", returnType = irBuiltIns.stringType, modality = Modality.OPEN).apply {
-                    dispatchReceiverParameter = any.owner.thisReceiver!!.copyTo(this)
-                    overriddenSymbols += any.functionByName("toString")
-                }
-                klass.addFunction("append", returnType = klass.defaultType).apply {
-                    addValueParameter("value", type = irBuiltIns.anyNType)
-                }
-            }
-        } else {
-            null
+    override val stringBuilder: IrClassSymbol = createClass(FqName("java.lang.StringBuilder")) { klass ->
+        klass.addConstructor()
+        klass.addFunction("toString", irBuiltIns.stringType).apply {
+            overriddenSymbols += any.functionByName("toString")
         }
 
-    override val stringBuilder: IrClassSymbol
-        get() = firStringBuilder ?: context.getTopLevelClass(FqName("java.lang.StringBuilder"))
+        val appendTypes = with(irBuiltIns) { listOf(anyNType, stringType, booleanType, charType, intType, longType, floatType, doubleType) }
+        for (type in appendTypes) {
+            klass.addFunction("append", klass.defaultType).apply {
+                addValueParameter("value", type)
+            }
+        }
+    }
 
     override val defaultConstructorMarker: IrClassSymbol =
         createClass(FqName("kotlin.jvm.internal.DefaultConstructorMarker"))
@@ -170,16 +164,19 @@ class JvmSymbols(
         get() = TODO("not implemented")
 
     val javaLangClass: IrClassSymbol =
-        if (firMode) createClass(FqName("java.lang.Class")) else context.getTopLevelClass(FqName("java.lang.Class"))
+        createClass(FqName("java.lang.Class")) { klass ->
+            klass.addTypeParameter("T", irBuiltIns.anyNType, Variance.INVARIANT)
+            klass.addFunction("desiredAssertionStatus", irBuiltIns.booleanType)
+        }
 
     private val javaLangAssertionError: IrClassSymbol =
-        if (firMode) createClass(FqName("java.lang.AssertionError")) else context.getTopLevelClass(FqName("java.lang.AssertionError"))
-
-    val assertionErrorConstructor by lazy<IrConstructorSymbol> {
-        javaLangAssertionError.constructors.single {
-            it.owner.valueParameters.size == 1 && it.owner.valueParameters[0].type.isNullableAny()
+        createClass(FqName("java.lang.AssertionError")) { klass ->
+            klass.addConstructor().apply {
+                addValueParameter("detailMessage", irBuiltIns.anyNType)
+            }
         }
-    }
+
+    val assertionErrorConstructor = javaLangAssertionError.constructors.single()
 
     val continuationClass: IrClassSymbol =
         createClass(DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_RELEASE, ClassKind.INTERFACE) { klass ->
@@ -494,14 +491,16 @@ class JvmSymbols(
         }.symbol
 
     private val javaLangString: IrClassSymbol =
-        if (firMode) {
-            createClass(FqName("java.lang.String")) { klass ->
-                klass.addFunction("valueOf", returnType = irBuiltIns.stringType, isStatic = true).apply {
-                    addValueParameter("value", irBuiltIns.anyNType)
+        createClass(FqName("java.lang.String")) { klass ->
+            val valueOfTypes = with(irBuiltIns) {
+                listOf(anyNType, booleanType, charType, intType, longType, floatType, doubleType)
+            }
+
+            for (type in valueOfTypes) {
+                klass.addFunction("valueOf", irBuiltIns.stringType, isStatic = true).apply {
+                    addValueParameter("value", type)
                 }
             }
-        } else {
-            context.getTopLevelClass(FqName("java.lang.String"))
         }
 
     private val defaultValueOfFunction = javaLangString.functions.single {
@@ -509,7 +508,7 @@ class JvmSymbols(
     }
 
     private val valueOfFunctions: Map<IrType, IrSimpleFunctionSymbol?> =
-        (context.irBuiltIns.primitiveIrTypes + context.irBuiltIns.stringType).associateWith { type ->
+        context.irBuiltIns.primitiveIrTypes.associateWith { type ->
             javaLangString.functions.singleOrNull {
                 it.owner.name.asString() == "valueOf" && it.owner.valueParameters.singleOrNull()?.type == type
             }