From b32241c967b762dfb6bfcd9bf83d44bd596dc49e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 26 Mar 2019 18:19:16 +0100 Subject: [PATCH] JVM IR: build all needed stdlib symbols in JvmSymbols manually This removes the mandatory dependency of all JVM IR tests on kotlin-stdlib (ConfigurationKind.ALL in all IR test cases) and speeds up tests which don't need kotiln-stdlib by about 20%. Another advantage of this method is that all required dependencies are listed in one file, are easy to grasp, and changes to the related code generation can be done independently of the corresponding changes in the actual library, which may help in bootstrapping the compiler --- .../declarations/declarationBuilders.kt | 92 +++++++- .../kotlin/backend/jvm/JvmBackendContext.kt | 9 - .../kotlin/backend/jvm/JvmSymbols.kt | 220 ++++++++++++++++-- .../backend/jvm/lower/AnnotationLowering.kt | 20 +- .../jvm/lower/CallableReferenceLowering.kt | 47 ++-- .../jvm/lower/PropertyReferenceLowering.kt | 51 ++-- .../declarations/IrPropertyBuilder.kt | 18 ++ .../declarations/IrTypeParameterBuilder.kt | 17 ++ .../kotlin/ir/descriptors/IrBuiltIns.kt | 26 ++- ...bstractIrBlackBoxAgainstJavaCodegenTest.kt | 6 - .../ir/AbstractIrBlackBoxCodegenTest.kt | 11 - .../ir/AbstractIrBlackBoxInlineCodegenTest.kt | 5 +- .../codegen/ir/AbstractIrBytecodeTextTest.kt | 3 - .../AbstractIrCheckLocalVariablesTableTest.kt | 5 - ...bstractIrCompileKotlinAgainstKotlinTest.kt | 5 +- .../codegen/ir/AbstractIrLineNumberTest.kt | 5 - .../kotlin/builtins/KotlinBuiltIns.java | 46 ++++ 17 files changed, 448 insertions(+), 138 deletions(-) create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrPropertyBuilder.kt create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrTypeParameterBuilder.kt diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt index 9263993f615..f9380dfdad1 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt @@ -6,11 +6,16 @@ package org.jetbrains.kotlin.ir.builders.declarations import org.jetbrains.kotlin.backend.common.descriptors.* +import org.jetbrains.kotlin.backend.common.ir.copyTo +import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.* import org.jetbrains.kotlin.ir.symbols.impl.* import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.util.defaultType +import org.jetbrains.kotlin.ir.util.parentAsClass import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.Variance fun IrClassBuilder.buildClass(): IrClass { val wrappedDescriptor = WrappedClassDescriptor() @@ -47,6 +52,29 @@ inline fun buildField(b: IrFieldBuilder.() -> Unit) = buildField() } +fun IrPropertyBuilder.buildProperty(): IrProperty { + val wrappedDescriptor = WrappedPropertyDescriptor() + return IrPropertyImpl( + startOffset, endOffset, origin, + IrPropertySymbolImpl(wrappedDescriptor), + name, visibility, modality, isVar, isConst, isLateinit, isDelegated, isExternal + ).also { + wrappedDescriptor.bind(it) + } +} + +inline fun buildProperty(b: IrPropertyBuilder.() -> Unit) = + IrPropertyBuilder().run { + b() + buildProperty() + } + +inline fun IrDeclarationContainer.addProperty(b: IrPropertyBuilder.() -> Unit): IrProperty = + buildProperty(b).also { property -> + declarations.add(property) + property.parent = this@addProperty + } + fun IrFunctionBuilder.buildFun(): IrSimpleFunction { val wrappedDescriptor = WrappedSimpleFunctionDescriptor() return IrFunctionImpl( @@ -78,12 +106,43 @@ inline fun buildFun(b: IrFunctionBuilder.() -> Unit): IrSimpleFunction = buildFun() } +inline fun IrDeclarationContainer.addFunction(b: IrFunctionBuilder.() -> Unit): IrSimpleFunction = + buildFun(b).also { function -> + declarations.add(function) + function.parent = this@addFunction + } + +fun IrDeclarationContainer.addFunction( + name: String, + returnType: IrType, + modality: Modality = Modality.FINAL, + isStatic: Boolean = false +): IrSimpleFunction = + addFunction { + this.name = Name.identifier(name) + this.returnType = returnType + this.modality = modality + }.apply { + if (!isStatic) { + dispatchReceiverParameter = parentAsClass.thisReceiver!!.copyTo(this) + } + } + inline fun buildConstructor(b: IrFunctionBuilder.() -> Unit): IrConstructor = IrFunctionBuilder().run { b() buildConstructor() } +inline fun IrClass.addConstructor(b: IrFunctionBuilder.() -> Unit = {}): IrConstructor = + buildConstructor { + b() + returnType = defaultType + }.also { constructor -> + declarations.add(constructor) + constructor.parent = this@addConstructor + } + fun IrValueParameterBuilder.build(): IrValueParameter { val wrappedDescriptor = WrappedValueParameterDescriptor() return IrValueParameterImpl( @@ -113,9 +172,40 @@ inline fun IrFunction.addValueParameter(b: IrValueParameterBuilder.() -> Unit): } } -fun IrFunction.addValueParameter(name: String, type: IrType, origin: IrDeclarationOrigin): IrValueParameter = +fun IrFunction.addValueParameter(name: String, type: IrType, origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED): IrValueParameter = addValueParameter { this.name = Name.identifier(name) this.type = type this.origin = origin } + +fun IrTypeParameterBuilder.build(): IrTypeParameter { + val wrappedDescriptor = WrappedTypeParameterDescriptor() + return IrTypeParameterImpl( + startOffset, endOffset, origin, + IrTypeParameterSymbolImpl(wrappedDescriptor), + name, index, isReified, variance + ).also { + wrappedDescriptor.bind(it) + it.superTypes.addAll(superTypes) + } +} + +inline fun IrTypeParametersContainer.addTypeParameter(b: IrTypeParameterBuilder.() -> Unit): IrTypeParameter = + IrTypeParameterBuilder().run { + b() + if (index == UNDEFINED_PARAMETER_INDEX) { + index = typeParameters.size + } + build().also { typeParameter -> + typeParameters.add(typeParameter) + typeParameter.parent = this@addTypeParameter + } + } + +fun IrTypeParametersContainer.addTypeParameter(name: String, upperBound: IrType, variance: Variance = Variance.INVARIANT): IrTypeParameter = + addTypeParameter { + this.name = Name.identifier(name) + this.variance = variance + this.superTypes.add(upperBound) + } 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 9916b7e0bb1..d0b46cee003 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 @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi2ir.PsiSourceManager class JvmBackendContext( @@ -41,20 +40,12 @@ class JvmBackendContext( override val configuration get() = state.configuration - internal fun getJvmInternalClass(name: String): ClassDescriptor { - return getClass(FqName("kotlin.jvm.internal").child(Name.identifier(name))) - } - internal fun getClass(fqName: FqName): ClassDescriptor { return state.module.getPackage(fqName.parent()).memberScope.getContributedClassifier( fqName.shortName(), NoLookupLocation.FROM_BACKEND ) as ClassDescriptor? ?: error("Class is not found: $fqName") } - fun getIrClass(fqName: FqName): IrClassSymbol { - return ir.symbols.externalSymbolTable.referenceClass(getClass(fqName)) - } - override fun log(message: () -> String) { /*TODO*/ if (inVerbosePhase) { 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 aefb42c29fb..efa612cf66b 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 @@ -6,18 +6,37 @@ package org.jetbrains.kotlin.backend.jvm import org.jetbrains.kotlin.backend.common.ir.Symbols +import org.jetbrains.kotlin.backend.common.ir.createImplicitParameterDeclarationWithWrappedDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.incremental.components.NoLookupLocation +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor +import org.jetbrains.kotlin.ir.builders.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin +import org.jetbrains.kotlin.ir.declarations.IrPackageFragment +import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol +import org.jetbrains.kotlin.ir.symbols.impl.IrExternalPackageFragmentSymbolImpl +import org.jetbrains.kotlin.ir.types.defaultType +import org.jetbrains.kotlin.ir.types.typeWith import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable +import org.jetbrains.kotlin.ir.util.functions import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.types.Variance class JvmSymbols( context: JvmBackendContext, private val symbolTable: ReferenceSymbolTable ) : Symbols(context, symbolTable) { + private val storageManager = LockBasedStorageManager(this::class.java.simpleName) + + private val irBuiltIns = context.irBuiltIns + override val ThrowNullPointerException: IrSimpleFunctionSymbol get() = error("Unused in JVM IR") @@ -27,19 +46,40 @@ class JvmSymbols( override val ThrowTypeCastException: IrSimpleFunctionSymbol get() = error("Unused in JVM IR") + private fun createPackage(fqName: FqName): IrPackageFragment = + IrExternalPackageFragmentImpl(IrExternalPackageFragmentSymbolImpl(EmptyPackageFragmentDescriptor(context.state.module, fqName))) + + private val kotlinJvmInternalPackage: IrPackageFragment = createPackage(FqName("kotlin.jvm.internal")) + private val kotlinJvmFunctionsPackage: IrPackageFragment = createPackage(FqName("kotlin.jvm.functions")) + + private fun createClass(fqName: FqName, classKind: ClassKind = ClassKind.CLASS, block: (IrClass) -> Unit): IrClass = + buildClass { + name = fqName.shortName() + kind = classKind + }.apply { + parent = when (fqName.parent().asString()) { + "kotlin.jvm.internal" -> kotlinJvmInternalPackage + "kotlin.jvm.functions" -> kotlinJvmFunctionsPackage + else -> error("Other packages are not supported yet: $fqName") + } + createImplicitParameterDeclarationWithWrappedDescriptor() + block(this) + } + + private val intrinsicsClass: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.Intrinsics")) { klass -> + klass.addFunction("throwUninitializedPropertyAccessException", irBuiltIns.unitType, isStatic = true).apply { + addValueParameter("propertyName", irBuiltIns.stringType) + } + }.symbol + override val ThrowUninitializedPropertyAccessException: IrSimpleFunctionSymbol = - symbolTable.referenceSimpleFunction( - context.getJvmInternalClass("Intrinsics").staticScope.getContributedFunctions( - Name.identifier("throwUninitializedPropertyAccessException"), - NoLookupLocation.FROM_BACKEND - ).single() - ) + intrinsicsClass.functions.single { it.owner.name.asString() == "throwUninitializedPropertyAccessException" } override val stringBuilder: IrClassSymbol get() = symbolTable.referenceClass(context.getClass(FqName("java.lang.StringBuilder"))) override val defaultConstructorMarker: IrClassSymbol = - symbolTable.referenceClass(context.getJvmInternalClass("DefaultConstructorMarker")) + createClass(FqName("kotlin.jvm.internal.DefaultConstructorMarker")) { }.symbol override val copyRangeTo: Map get() = error("Unused in JVM IR") @@ -50,13 +90,165 @@ class JvmSymbols( override val coroutineSuspendedGetter: IrSimpleFunctionSymbol get() = TODO("not implemented") - val lambdaClass: IrClassSymbol = - symbolTable.referenceClass(context.getJvmInternalClass("Lambda")) + val javaLangClass: IrClassSymbol = + symbolTable.referenceClass(context.getClass(FqName("java.lang.Class"))) - val functionReference: IrClassSymbol = - symbolTable.referenceClass(context.getJvmInternalClass("FunctionReference")) + val lambdaClass: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.Lambda")) { klass -> + klass.addConstructor().apply { + addValueParameter("arity", irBuiltIns.intType) + } + }.symbol + + private fun generateCallableReferenceMethods(klass: IrClass) { + klass.addFunction("getSignature", irBuiltIns.stringType, Modality.OPEN) + klass.addFunction("getName", irBuiltIns.stringType, Modality.OPEN) + klass.addFunction("getOwner", irBuiltIns.kDeclarationContainerClass.typeWith(), Modality.OPEN) + } + + val functionReference: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.FunctionReference")) { klass -> + klass.addConstructor().apply { + addValueParameter("arity", irBuiltIns.intType) + addValueParameter("receiver", irBuiltIns.anyNType) + } + + generateCallableReferenceMethods(klass) + }.symbol fun getFunction(parameterCount: Int): IrClassSymbol = - symbolTable.referenceClass(context.builtIns.getFunction(parameterCount)) -} + symbolTable.referenceClass(builtIns.getFunction(parameterCount)) + private val jvmFunctionClasses = storageManager.createMemoizedFunction { n: Int -> + createClass(FqName("kotlin.jvm.functions.Function$n"), ClassKind.INTERFACE) { klass -> + for (i in 1..n) { + klass.addTypeParameter("P$i", irBuiltIns.anyNType, Variance.IN_VARIANCE) + } + val returnType = klass.addTypeParameter("R", irBuiltIns.anyNType, Variance.OUT_VARIANCE) + + klass.addFunction("invoke", returnType.defaultType, Modality.ABSTRACT).apply { + for (i in 1..n) { + addValueParameter("p$i", klass.typeParameters[i - 1].defaultType) + } + } + }.symbol + } + + fun getJvmFunctionClass(parameterCount: Int): IrClassSymbol = + jvmFunctionClasses(parameterCount) + + val functionN: IrClassSymbol = createClass(FqName("kotlin.jvm.functions.FunctionN"), ClassKind.INTERFACE) { klass -> + val returnType = klass.addTypeParameter("R", irBuiltIns.anyNType, Variance.OUT_VARIANCE) + + klass.addFunction("invoke", returnType.defaultType, Modality.ABSTRACT).apply { + addValueParameter { + name = Name.identifier("args") + type = irBuiltIns.arrayClass.typeWith(irBuiltIns.anyNType) + origin = IrDeclarationOrigin.DEFINED + varargElementType = irBuiltIns.anyNType + } + } + }.symbol + + private data class PropertyReferenceKey( + val mutable: Boolean, + val parameterCount: Int, + val impl: Boolean + ) + + private val propertyReferenceClasses = storageManager.createMemoizedFunction { key: PropertyReferenceKey -> + val (mutable, n, impl) = key + val className = buildString { + if (mutable) append("Mutable") + append("PropertyReference") + append(n) + if (impl) append("Impl") + } + createClass(FqName("kotlin.jvm.internal.$className")) { klass -> + if (impl) { + klass.addConstructor().apply { + addValueParameter("owner", irBuiltIns.kDeclarationContainerClass.typeWith()) + addValueParameter("name", irBuiltIns.stringType) + addValueParameter("string", irBuiltIns.stringType) + } + } else { + klass.addConstructor() + + klass.addConstructor().apply { + addValueParameter("receiver", irBuiltIns.anyNType) + } + } + + val receiverFieldName = Name.identifier("receiver") + klass.addProperty { + name = receiverFieldName + }.apply { + backingField = buildField { + name = receiverFieldName + type = irBuiltIns.anyNType + visibility = Visibilities.PROTECTED + }.also { field -> + field.parent = klass + } + } + + generateCallableReferenceMethods(klass) + + // To avoid hassle with generic type parameters, we pretend that PropertyReferenceN.get takes and returns `Any?` + // (similarly with set). This should be enough for the JVM IR backend to generate correct calls and bridges. + klass.addFunction("get", irBuiltIns.anyNType, Modality.ABSTRACT).apply { + for (i in 0 until n) { + addValueParameter("receiver$i", irBuiltIns.anyNType) + } + } + + if (mutable) { + klass.addFunction("set", irBuiltIns.unitType, Modality.ABSTRACT).apply { + for (i in 0 until n) { + addValueParameter("receiver$i", irBuiltIns.anyNType) + } + addValueParameter("value", irBuiltIns.anyNType) + } + } + }.symbol + } + + fun getPropertyReferenceClass(mutable: Boolean, parameterCount: Int, impl: Boolean): IrClassSymbol = + propertyReferenceClasses(PropertyReferenceKey(mutable, parameterCount, impl)) + + val reflection: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.Reflection")) { klass -> + // We use raw types for java.lang.Class and kotlin.reflect.KClass here for simplicity and because this is what's used + // at declaration site at kotlin.jvm.internal.Reflection. + val rawJavaLangClass = javaLangClass.typeWith() + val rawKClass = irBuiltIns.kClassClass.typeWith() + + klass.addFunction("getOrCreateKotlinPackage", irBuiltIns.kDeclarationContainerClass.typeWith(), isStatic = true).apply { + addValueParameter("javaClass", rawJavaLangClass) + addValueParameter("moduleName", irBuiltIns.stringType) + } + + klass.addFunction("getOrCreateKotlinClass", rawKClass, isStatic = true).apply { + addValueParameter("javaClass", rawJavaLangClass) + } + + klass.addFunction("getOrCreateKotlinClasses", irBuiltIns.arrayClass.typeWith(rawKClass), isStatic = true).apply { + addValueParameter("javaClasses", irBuiltIns.arrayClass.typeWith(rawJavaLangClass)) + } + + for (mutable in listOf(false, true)) { + for (n in 0..2) { + val functionName = (if (mutable) "mutableProperty" else "property") + n + klass.addFunction(functionName, irBuiltIns.getKPropertyClass(mutable, n).typeWith(), isStatic = true).apply { + addValueParameter("p", getPropertyReferenceClass(mutable, n, impl = false).typeWith()) + } + } + } + }.symbol + + val getOrCreateKotlinPackage: IrSimpleFunctionSymbol = + reflection.functions.single { it.owner.name.asString() == "getOrCreateKotlinPackage" } + + val getOrCreateKotlinClass: IrSimpleFunctionSymbol = + reflection.functions.single { it.owner.name.asString() == "getOrCreateKotlinClass" } + + val getOrCreateKotlinClasses: IrSimpleFunctionSymbol = + reflection.functions.single { it.owner.name.asString() == "getOrCreateKotlinClasses" } +} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt index a5ab83f5492..09d35971b49 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AnnotationLowering.kt @@ -32,7 +32,6 @@ import org.jetbrains.kotlin.ir.util.isKClass import org.jetbrains.kotlin.ir.util.isNonPrimitiveArray import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.types.Variance internal val annotationPhase = makeIrFilePhase( @@ -138,25 +137,16 @@ private class AnnotationLowering(private val context: JvmBackendContext) : FileL val getField = irBuilder.irGet(field.type, receiver.dispatchReceiver!!, receiver.symbol) if (!wrapIntoKClass) return getField - val functionSymbol = if (wrapIntoArray) getOrCreateKClassesSymbol else getOrCreateKClassSymbol - return irBuilder.irCall(functionSymbol, functionSymbol.owner.returnType).apply { + + return irBuilder.irCall( + if (wrapIntoArray) context.ir.symbols.getOrCreateKotlinClasses else context.ir.symbols.getOrCreateKotlinClass + ).apply { putValueArgument(0, getField) } } - private val javaLangClass = context.getIrClass(FqName("java.lang.Class")) - private val reflectionClass = context.getIrClass(FqName("kotlin.jvm.internal.Reflection")) - - private val getOrCreateKClassSymbol by lazy { - reflectionClass.getFunctionByName("getOrCreateKotlinClass", 1) - } - - private val getOrCreateKClassesSymbol by lazy { - reflectionClass.getFunctionByName("getOrCreateKotlinClasses", 1) - } - private fun javaClassType(typeArguments: List): IrType = - javaLangClass.createType(false, typeArguments) + context.ir.symbols.javaLangClass.createType(false, typeArguments) private fun javaClassArrayType(variance: Variance, typeArguments: List): IrType { val argument = makeTypeProjection(javaClassType(typeArguments), variance) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt index 5c4fb04aa5d..d30822a36a3 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt @@ -103,7 +103,7 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL context.irBuiltIns.anyClass.typeWith(), (0 until argumentsCount).map { i -> expression.getValueArgument(i)!! } ) - val invokeFun = context.getIrClass(FqName("kotlin.jvm.functions.FunctionN")).owner.declarations.single { + val invokeFun = context.ir.symbols.functionN.owner.declarations.single { it is IrSimpleFunction && it.name.asString() == "invoke" } as IrSimpleFunction @@ -154,10 +154,6 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL val functionReferenceConstructor: IrConstructor ) - private val continuationClass = context.getIrClass(FqName("kotlin.coroutines.experimental.Continuation")).owner - - //private val getContinuationSymbol = context.ir.symbols.getContinuation - private inner class FunctionReferenceBuilder( val referenceParent: IrDeclarationParent, val irFunctionReference: IrFunctionReference @@ -193,9 +189,9 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL useVararg = (numberOfParameters > MAX_ARGCOUNT_WITHOUT_VARARG) val functionClassSymbol = if (useVararg) - context.getIrClass(FqName("kotlin.jvm.functions.FunctionN")) + context.ir.symbols.functionN else - context.getIrClass(FqName("kotlin.jvm.functions.Function$numberOfParameters")) + context.ir.symbols.getJvmFunctionClass(numberOfParameters) val functionClass = functionClassSymbol.owner val functionParameterTypes = unboundCalleeParameters.map { it.type } val functionClassTypeParameters = if (useVararg) @@ -211,9 +207,12 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL var suspendFunctionClass: IrClass? = null val lastParameterType = unboundCalleeParameters.lastOrNull()?.type - if ((lastParameterType as? IrSimpleType)?.classifier == continuationClass) { + if (lastParameterType is IrSimpleType && + lastParameterType.classOrNull?.owner?.fqNameWhenAvailable?.asString() == "kotlin.coroutines.experimental.Continuation" + ) { // If the last parameter is Continuation<> inherit from SuspendFunction. - suspendFunctionClass = context.getIrClass(FqName("kotlin.coroutines.SuspendFunction${numberOfParameters - 1}")).owner + val suspendFunctionDescriptor = context.getClass(FqName("kotlin.coroutines.SuspendFunction${numberOfParameters - 1}")) + suspendFunctionClass = context.ir.symbols.externalSymbolTable.referenceClass(suspendFunctionDescriptor).owner val suspendFunctionClassTypeParameters = functionParameterTypes.dropLast(1) + (lastParameterType.arguments.single() as IrTypeProjection).type functionReferenceClassSuperTypes += IrSimpleTypeImpl( @@ -254,7 +253,7 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL val getSignatureMethod = createGetSignatureMethod(functionReferenceOrLambda.owner.functions.find { it.name.asString() == "getSignature"}!!) val getNameMethod = - createGetNameMethod(functionReferenceOrLambda.owner.properties.find { it.name.asString() == "name" }!!) + createGetNameMethod(functionReferenceOrLambda.owner.functions.find { it.name.asString() == "getName" }!!) val getOwnerMethod = createGetOwnerMethod(functionReferenceOrLambda.owner.functions.find { it.name.asString() == "getOwner" }!!) @@ -474,19 +473,18 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL } } - private fun createGetNameMethod(superNameProperty: IrProperty): IrSimpleFunction { - val superGetter = superNameProperty.getter!! - return buildFun { + private fun createGetNameMethod(superFunction: IrSimpleFunction): IrSimpleFunction = + buildFun { setSourceRange(irFunctionReference) origin = JvmLoweredDeclarationOrigin.FUNCTION_REFERENCE_IMPL name = Name.identifier("getName") - returnType = superGetter.returnType - visibility = superGetter.visibility - modality = superGetter.modality + returnType = superFunction.returnType + visibility = superFunction.visibility + modality = superFunction.modality }.apply { val function = this parent = functionReferenceClass - overriddenSymbols.add(superGetter.symbol) + overriddenSymbols.add(superFunction.symbol) dispatchReceiverParameter = functionReferenceClass.thisReceiver?.copyTo(function) val irBuilder = context.createIrBuilder(function.symbol, startOffset, endOffset) @@ -496,7 +494,6 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL ) } } - } private fun createGetOwnerMethod(superFunction: IrSimpleFunction): IrSimpleFunction = buildFun { @@ -544,16 +541,15 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL else -> state.typeMapper.mapOwner(callee.descriptor) } - val clazz = globalContext.getIrClass(FqName("java.lang.Class")).owner + val clazz = globalContext.ir.symbols.javaLangClass val clazzRef = IrClassReferenceImpl( UNDEFINED_OFFSET, UNDEFINED_OFFSET, - clazz.defaultType, - clazz.symbol, + clazz.typeWith(), + clazz, CrIrType(type) ) - val reflectionClass = globalContext.getIrClass(FqName("kotlin.jvm.internal.Reflection")) return if (isContainerPackage) { // Note that this name is not used in reflection. There should be the name of the referenced declaration's module instead, // but there's no nice API to obtain that name here yet @@ -562,15 +558,12 @@ internal class CallableReferenceLowering(val context: JvmBackendContext) : FileL -1, -1, globalContext.irBuiltIns.stringType, state.moduleName ) - val functionSymbol = reflectionClass.functions.find { it.owner.name.asString() == "getOrCreateKotlinPackage" }!! - irCall(functionSymbol, functionSymbol.owner.returnType).apply { + irCall(globalContext.ir.symbols.getOrCreateKotlinPackage).apply { putValueArgument(0, clazzRef) putValueArgument(1, module) } } else { - val functionSymbol = reflectionClass.functions.filter { it.owner.name.asString() == "getOrCreateKotlinClass" } - .single { it.owner.valueParameters.size == 1 } - irCall(functionSymbol, functionSymbol.owner.returnType).apply { + irCall(globalContext.ir.symbols.getOrCreateKotlinClass).apply { putValueArgument(0, clazzRef) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt index 2ed96d1d5c0..c7cf547d000 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt @@ -18,14 +18,20 @@ import org.jetbrains.kotlin.ir.builders.* import org.jetbrains.kotlin.ir.builders.declarations.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* -import org.jetbrains.kotlin.ir.expressions.impl.* -import org.jetbrains.kotlin.ir.symbols.* -import org.jetbrains.kotlin.ir.types.* -import org.jetbrains.kotlin.ir.types.impl.* +import org.jetbrains.kotlin.ir.expressions.impl.IrClassReferenceImpl +import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl +import org.jetbrains.kotlin.ir.expressions.impl.IrVarargImpl +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol +import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol +import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.ir.types.createType +import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl +import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection +import org.jetbrains.kotlin.ir.types.typeWith import org.jetbrains.kotlin.ir.util.* -import org.jetbrains.kotlin.ir.visitors.* +import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.load.java.JvmAbi -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance @@ -60,18 +66,6 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class private val IrMemberAccessExpression.symbol: IrSymbol get() = getter?.owner?.symbol ?: field!!.owner.symbol - private val plainJavaClass = - context.getIrClass(FqName("java.lang.Class")).owner - - private val reflectionClass = - context.getIrClass(FqName("kotlin.jvm.internal.Reflection")).owner - - private val getOrCreateKotlinClass = - reflectionClass.functions.single { it.name.asString() == "getOrCreateKotlinClass" && it.valueParameters.size == 1 } - - private val getOrCreateKotlinPackage = - reflectionClass.functions.single { it.name.asString() == "getOrCreateKotlinPackage" && it.valueParameters.size == 2 } - private val arrayItemGetter = context.ir.symbols.array.owner.functions.single { it.name.asString() == "get" } @@ -101,8 +95,8 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class private val IrMemberAccessExpression.parentJavaClassReference get() = IrClassReferenceImpl( startOffset, endOffset, - plainJavaClass.defaultType, - plainJavaClass.symbol, + context.ir.symbols.javaLangClass.typeWith(), + context.ir.symbols.javaLangClass, // TODO: when the parent is an interface, this should map to DefaultImpls. However, that requires // moving this lowering below InterfaceLowering; see another TODO above. CrIrType(context.state.typeMapper.mapImplementationOwner(propertyContainerChild!!.descriptor)) @@ -110,16 +104,17 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class private fun IrBuilderWithScope.buildReflectedContainerReference(expression: IrMemberAccessExpression): IrExpression { val parent = expression.propertyContainerChild?.parent + val context = this@PropertyReferenceLowering.context return when { // FileClassLowering creates a class to which all package-level declarations are moved. However, it does not // fix the declarations' parents (yet), which is why we check for both a file class and a package fragment. parent is IrPackageFragment || (parent is IrClass && parent.origin == IrDeclarationOrigin.FILE_CLASS) -> - irCall(getOrCreateKotlinPackage).apply { + irCall(context.ir.symbols.getOrCreateKotlinPackage).apply { putValueArgument(0, expression.parentJavaClassReference) - putValueArgument(1, irString(this@PropertyReferenceLowering.context.state.moduleName)) + putValueArgument(1, irString(context.state.moduleName)) } parent is IrClass -> - irCall(getOrCreateKotlinClass).apply { + irCall(context.ir.symbols.getOrCreateKotlinClass).apply { putValueArgument(0, expression.parentJavaClassReference) } else -> throw AssertionError("referenced property not inside a class/package fragment") @@ -133,9 +128,9 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class ) private fun propertyReferenceKind(mutable: Boolean, i: Int) = PropertyReferenceKind( - context.getIrClass(FqName("kotlin.jvm.internal.${if (mutable) "Mutable" else ""}PropertyReference$i")), - context.getIrClass(FqName("kotlin.jvm.internal.${if (mutable) "Mutable" else ""}PropertyReference${i}Impl")), - reflectionClass.functions.single { it.name.asString() == (if (mutable) "mutableProperty$i" else "property$i") } + context.ir.symbols.getPropertyReferenceClass(mutable, i, false), + context.ir.symbols.getPropertyReferenceClass(mutable, i, true), + context.ir.symbols.reflection.owner.functions.single { it.name.asString() == (if (mutable) "mutableProperty$i" else "property$i") } ) private fun propertyReferenceKindFor(expression: IrMemberAccessExpression): PropertyReferenceKind = @@ -295,7 +290,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class fun buildOverride(method: IrSimpleFunction, build: IrBlockBodyBuilder.(List) -> IrExpression) = buildFun { setSourceRange(expression) - name = if (method.name.asString() == "") Name.identifier("getName") else method.name + name = method.name returnType = method.returnType visibility = method.visibility origin = referenceClass.origin @@ -329,7 +324,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class } } - buildOverride(superClass.properties.single { it.name.asString() == "name" }.getter!!) { + buildOverride(superClass.functions.single { it.name.asString() == "getName" }) { irString(expression.descriptor.name.asString()) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrPropertyBuilder.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrPropertyBuilder.kt new file mode 100644 index 00000000000..7aa0d85df3f --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrPropertyBuilder.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.ir.builders.declarations + +import org.jetbrains.kotlin.descriptors.Modality + +class IrPropertyBuilder : IrDeclarationBuilder() { + var modality: Modality = Modality.FINAL + + var isVar: Boolean = false + var isConst: Boolean = false + var isLateinit: Boolean = false + var isDelegated: Boolean = false + var isExternal: Boolean = false +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrTypeParameterBuilder.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrTypeParameterBuilder.kt new file mode 100644 index 00000000000..96682e5c77b --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/IrTypeParameterBuilder.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.ir.builders.declarations + +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.utils.SmartList + +class IrTypeParameterBuilder : IrDeclarationBuilder() { + var index: Int = UNDEFINED_PARAMETER_INDEX + var variance: Variance = Variance.INVARIANT + var isReified: Boolean = false + val superTypes: MutableList = SmartList() +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt index 824f0dc98d5..f7becd35a73 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt @@ -12,14 +12,12 @@ import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.incremental.components.NoLookupLocation -import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction -import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol -import org.jetbrains.kotlin.ir.types.toIrType import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl +import org.jetbrains.kotlin.ir.types.toIrType import org.jetbrains.kotlin.ir.types.withHasQuestionMark import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.ir.util.TypeTranslator @@ -162,8 +160,24 @@ class IrBuiltIns( val primitiveIrTypes by lazy { listOf(booleanType, charType, byteType, shortType, intType, floatType, longType, doubleType) } - val kCallableClass = builtIns.getBuiltInClassByFqName(KotlinBuiltIns.FQ_NAMES.kCallable.toSafe()).toIrSymbol() - val kPropertyClass = builtIns.getBuiltInClassByFqName(KotlinBuiltIns.FQ_NAMES.kPropertyFqName.toSafe()).toIrSymbol() + val kCallableClass = builtIns.kCallable.toIrSymbol() + val kPropertyClass = builtIns.kProperty.toIrSymbol() + val kDeclarationContainerClass = builtIns.kDeclarationContainer.toIrSymbol() + val kClassClass = builtIns.kClass.toIrSymbol() + + private val kProperty0Class = builtIns.kProperty0.toIrSymbol() + private val kProperty1Class = builtIns.kProperty1.toIrSymbol() + private val kProperty2Class = builtIns.kProperty2.toIrSymbol() + private val kMutableProperty0Class = builtIns.kMutableProperty0.toIrSymbol() + private val kMutableProperty1Class = builtIns.kMutableProperty1.toIrSymbol() + private val kMutableProperty2Class = builtIns.kMutableProperty2.toIrSymbol() + + fun getKPropertyClass(mutable: Boolean, n: Int): IrClassSymbol = when (n) { + 0 -> if (mutable) kMutableProperty0Class else kProperty0Class + 1 -> if (mutable) kMutableProperty1Class else kProperty1Class + 2 -> if (mutable) kMutableProperty2Class else kProperty2Class + else -> error("No KProperty for n=$n mutable=$mutable") + } // TODO switch to IrType val primitiveTypes = listOf(bool, char, byte, short, int, long, float, double) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxAgainstJavaCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxAgainstJavaCodegenTest.kt index d8abf3a6fde..e35cc50f853 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxAgainstJavaCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxAgainstJavaCodegenTest.kt @@ -9,9 +9,7 @@ import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot import org.jetbrains.kotlin.codegen.AbstractBlackBoxAgainstJavaCodegenTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.TargetBackend -import java.io.File abstract class AbstractIrBlackBoxAgainstJavaCodegenTest : AbstractBlackBoxAgainstJavaCodegenTest() { @@ -20,9 +18,5 @@ abstract class AbstractIrBlackBoxAgainstJavaCodegenTest : AbstractBlackBoxAgains configuration.put(JVMConfigurationKeys.IR, true) } - override fun extractConfigurationKind(files: MutableList): ConfigurationKind { - return ConfigurationKind.ALL - } - override fun getBackend() = TargetBackend.JVM_IR } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxCodegenTest.kt index 95080c417a0..20a7e220a73 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxCodegenTest.kt @@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen.ir import org.jetbrains.kotlin.codegen.AbstractBlackBoxCodegenTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.TargetBackend abstract class AbstractIrBlackBoxCodegenTest : AbstractBlackBoxCodegenTest() { @@ -27,15 +26,5 @@ abstract class AbstractIrBlackBoxCodegenTest : AbstractBlackBoxCodegenTest() { configuration.put(JVMConfigurationKeys.IR, true) } - //symbols are constructed with stdlib descriptors so stdlib should be presented - // TODO rewrite symbols building - override fun extractConfigurationKind(files: MutableList): ConfigurationKind { - val result = super.extractConfigurationKind(files) - return when (result) { - ConfigurationKind.JDK_NO_RUNTIME, ConfigurationKind.JDK_ONLY -> ConfigurationKind.NO_KOTLIN_REFLECT - else -> result - } - } - override fun getBackend() = TargetBackend.JVM_IR } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxInlineCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxInlineCodegenTest.kt index c148c607410..72ffcd2783b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxInlineCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBlackBoxInlineCodegenTest.kt @@ -19,10 +19,7 @@ package org.jetbrains.kotlin.codegen.ir import org.jetbrains.kotlin.codegen.AbstractBlackBoxCodegenTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.ConfigurationKind abstract class AbstractIrBlackBoxInlineCodegenTest: AbstractBlackBoxCodegenTest() { override fun updateConfiguration(configuration: CompilerConfiguration) = configuration.put(JVMConfigurationKeys.IR, true) - - override fun extractConfigurationKind(files: MutableList): ConfigurationKind = ConfigurationKind.ALL -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBytecodeTextTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBytecodeTextTest.kt index 3097181baef..6b38996e5c5 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBytecodeTextTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrBytecodeTextTest.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.codegen.ir import org.jetbrains.kotlin.codegen.AbstractBytecodeTextTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.ConfigurationKind abstract class AbstractIrBytecodeTextTest : AbstractBytecodeTextTest() { override fun updateConfiguration(configuration: CompilerConfiguration) = configuration.put(JVMConfigurationKeys.IR, true) - - override fun extractConfigurationKind(files: MutableList): ConfigurationKind = ConfigurationKind.ALL } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt index b559ed2fa76..926fa6a4f24 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt @@ -9,7 +9,6 @@ import com.intellij.openapi.util.Comparing import org.jetbrains.kotlin.codegen.AbstractCheckLocalVariablesTableTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.ConfigurationKind import org.junit.ComparisonFailure import java.io.File @@ -19,10 +18,6 @@ abstract class AbstractIrCheckLocalVariablesTableTest : AbstractCheckLocalVariab configuration.put(JVMConfigurationKeys.IR, true) } - override fun extractConfigurationKind(files: MutableList): ConfigurationKind { - return ConfigurationKind.ALL - } - override fun doCompare( testFile: File, text: String, diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt index 68599f7570f..178d1dfad51 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.codegen.ir import org.jetbrains.kotlin.codegen.AbstractCompileKotlinAgainstKotlinTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.ConfigurationKind abstract class AbstractIrCompileKotlinAgainstKotlinTest : AbstractCompileKotlinAgainstKotlinTest() { override fun updateConfiguration(configuration: CompilerConfiguration) = configuration.put(JVMConfigurationKeys.IR, true) - - override fun extractConfigurationKind(files: MutableList): ConfigurationKind = ConfigurationKind.ALL -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrLineNumberTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrLineNumberTest.kt index e0dad53da2f..73f3e8a07ae 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrLineNumberTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrLineNumberTest.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.codegen.AbstractLineNumberTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.psi.KtFile -import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase import org.jetbrains.org.objectweb.asm.ClassReader import org.jetbrains.org.objectweb.asm.Label @@ -18,10 +17,6 @@ import org.jetbrains.org.objectweb.asm.Opcodes import java.io.File abstract class AbstractIrLineNumberTest : AbstractLineNumberTest() { - override fun extractConfigurationKind(files: MutableList): ConfigurationKind { - return ConfigurationKind.ALL - } - override fun updateConfiguration(configuration: CompilerConfiguration) { super.updateConfiguration(configuration) configuration.put(JVMConfigurationKeys.IR, true) diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index f4924eb8e5e..f4f1a77f78d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -253,6 +253,7 @@ public abstract class KotlinBuiltIns { public final FqNameUnsafe kPropertyFqName = reflect("KProperty"); public final FqNameUnsafe kMutablePropertyFqName = reflect("KMutableProperty"); public final ClassId kProperty = ClassId.topLevel(kPropertyFqName.toSafe()); + public final FqNameUnsafe kDeclarationContainer = reflect("KDeclarationContainer"); public final FqName uByteFqName = fqName("UByte"); public final FqName uShortFqName = fqName("UShort"); @@ -492,6 +493,51 @@ public abstract class KotlinBuiltIns { return getBuiltInClassByFqName(FQ_NAMES.kClass.toSafe()); } + @NotNull + public ClassDescriptor getKDeclarationContainer() { + return getBuiltInClassByFqName(FQ_NAMES.kDeclarationContainer.toSafe()); + } + + @NotNull + public ClassDescriptor getKCallable() { + return getBuiltInClassByFqName(FQ_NAMES.kCallable.toSafe()); + } + + @NotNull + public ClassDescriptor getKProperty() { + return getBuiltInClassByFqName(FQ_NAMES.kPropertyFqName.toSafe()); + } + + @NotNull + public ClassDescriptor getKProperty0() { + return getBuiltInClassByFqName(FQ_NAMES.kProperty0.toSafe()); + } + + @NotNull + public ClassDescriptor getKProperty1() { + return getBuiltInClassByFqName(FQ_NAMES.kProperty1.toSafe()); + } + + @NotNull + public ClassDescriptor getKProperty2() { + return getBuiltInClassByFqName(FQ_NAMES.kProperty2.toSafe()); + } + + @NotNull + public ClassDescriptor getKMutableProperty0() { + return getBuiltInClassByFqName(FQ_NAMES.kMutableProperty0.toSafe()); + } + + @NotNull + public ClassDescriptor getKMutableProperty1() { + return getBuiltInClassByFqName(FQ_NAMES.kMutableProperty1.toSafe()); + } + + @NotNull + public ClassDescriptor getKMutableProperty2() { + return getBuiltInClassByFqName(FQ_NAMES.kMutableProperty2.toSafe()); + } + @NotNull public ClassDescriptor getIterator() { return getBuiltInClassByFqName(FQ_NAMES.iterator);