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);