From 481d4d72b90ed92d1d016a5c17323ddb0d903cb9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Steven=20Sch=C3=A4fer?= Date: Mon, 4 Nov 2019 11:31:38 +0100 Subject: [PATCH] JVM IR: Avoid getTopLevelClass in JvmSymbols --- .../kotlin/backend/jvm/JvmBackendContext.kt | 5 +- .../kotlin/backend/jvm/JvmBackendFacade.kt | 5 +- .../kotlin/backend/jvm/JvmIrCodegenFactory.kt | 4 +- .../kotlin/backend/jvm/JvmSymbols.kt | 63 +++++++++---------- 4 files changed, 36 insertions(+), 41 deletions(-) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index 78fe33f2065..ed3a05a4f02 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/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 get() = TODO("not implemented") @@ -143,7 +142,7 @@ class JvmBackendContext( irModuleFragment: IrModuleFragment, symbolTable: ReferenceSymbolTable ) : Ir(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) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt index 0100f50248c..5127de29f92 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt +++ b/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) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt index 3d623f97f3b..15d3437898d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt +++ b/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, fqName: FqName): PackageCodegen { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt index 47efb0579ba..f0e9da5b01c 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt +++ b/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(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 { - 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 = - (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 }