diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CodeGenerationInfo.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CodeGenerationInfo.kt index 51090b2e3cb..9d97968d98d 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CodeGenerationInfo.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CodeGenerationInfo.kt @@ -7,10 +7,11 @@ package org.jetbrains.kotlin.backend.konan import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.util.hasAnnotation import org.jetbrains.kotlin.name.FqName internal fun IrClass.isNonGeneratedAnnotation(): Boolean = this.kind == ClassKind.ANNOTATION_CLASS && - !this.descriptor.annotations.hasAnnotation(serialInfoAnnotationFqName) + !this.annotations.hasAnnotation(serialInfoAnnotationFqName) private val serialInfoAnnotationFqName = FqName("kotlinx.serialization.SerialInfo") diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanFqNames.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanFqNames.kt index a7cde60ab1d..eebb61a32da 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanFqNames.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanFqNames.kt @@ -13,12 +13,16 @@ internal const val NATIVE_PTR_NAME = "NativePtr" internal const val NON_NULL_NATIVE_PTR_NAME = "NonNullNativePtr" object KonanFqNames { - val packageName = FqName("kotlin.native") val internalPackageName = FqName("kotlin.native.internal") val nativePtr = internalPackageName.child(Name.identifier(NATIVE_PTR_NAME)).toUnsafe() val nonNullNativePtr = internalPackageName.child(Name.identifier(NON_NULL_NATIVE_PTR_NAME)).toUnsafe() val throws = FqName("kotlin.native.Throws") + val threadLocal = FqName("kotlin.native.concurrent.ThreadLocal") + val sharedImmutable = FqName("kotlin.native.concurrent.SharedImmutable") + val frozen = FqName("kotlin.native.internal.Frozen") + val typedIntrinsic = FqName("kotlin.native.internal.TypedIntrinsic") + val objCMethod = FqName("kotlinx.cinterop.ObjCMethod") } /** diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt index f9969a7c247..48c5176d78a 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt @@ -14,10 +14,7 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.types.classifierOrFail -import org.jetbrains.kotlin.ir.util.constructedClass -import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization -import org.jetbrains.kotlin.ir.util.hasAnnotation -import org.jetbrains.kotlin.ir.util.isReal +import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.ExternalOverridabilityCondition @@ -61,8 +58,7 @@ fun ClassDescriptor.isExternalObjCClass(): Boolean = this.isObjCClass() && } fun IrClass.isExternalObjCClass(): Boolean = this.isObjCClass() && (this as IrDeclaration).parentDeclarationsWithSelf.filterIsInstance().any { - it.annotations.hasAnnotation(externalObjCClassFqName) || - it.descriptor.annotations.hasAnnotation(externalObjCClassFqName) + it.annotations.hasAnnotation(externalObjCClassFqName) } fun ClassDescriptor.isObjCForwardDeclaration(): Boolean = @@ -140,9 +136,9 @@ fun FunctionDescriptor.getObjCMethodInfo(): ObjCMethodInfo? = this.getObjCMethod fun IrFunction.isObjCBridgeBased(): Boolean { assert(this.isReal) - return this.descriptor.annotations.hasAnnotation(objCMethodFqName) || - this.descriptor.annotations.hasAnnotation(objCFactoryFqName) || - this.descriptor.annotations.hasAnnotation(objCConstructorFqName) + return this.annotations.hasAnnotation(objCMethodFqName) || + this.annotations.hasAnnotation(objCFactoryFqName) || + this.annotations.hasAnnotation(objCConstructorFqName) } /** @@ -222,11 +218,11 @@ fun ConstructorDescriptor.objCConstructorIsDesignated(): Boolean { } -val IrConstructor.isObjCConstructor get() = this.descriptor.annotations.hasAnnotation(objCConstructorFqName) +val IrConstructor.isObjCConstructor get() = this.annotations.hasAnnotation(objCConstructorFqName) // TODO-DCE-OBJC-INIT: Selector should be preserved by DCE. fun IrConstructor.getObjCInitMethod(): IrSimpleFunction? { - return this.descriptor.annotations.findAnnotation(objCConstructorFqName)?.let { + return this.annotations.findAnnotation(objCConstructorFqName)?.let { val initSelector = it.getStringValue("initSelector") this.constructedClass.declarations.asSequence() .filterIsInstance() @@ -234,9 +230,9 @@ fun IrConstructor.getObjCInitMethod(): IrSimpleFunction? { } } -val IrFunction.hasObjCFactoryAnnotation get() = this.descriptor.annotations.hasAnnotation(objCFactoryFqName) +val IrFunction.hasObjCFactoryAnnotation get() = this.annotations.hasAnnotation(objCFactoryFqName) -val IrFunction.hasObjCMethodAnnotation get() = this.descriptor.annotations.hasAnnotation(objCMethodFqName) +val IrFunction.hasObjCMethodAnnotation get() = this.annotations.hasAnnotation(objCMethodFqName) fun FunctionDescriptor.getObjCFactoryInitMethodInfo(): ObjCMethodInfo? { val factoryAnnotation = this.annotations.findAnnotation(objCFactoryFqName) ?: return null diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt index 675c1c8e49c..98aaedb3563 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt @@ -581,11 +581,9 @@ private fun IrType.isCEnumType(): Boolean { .any { (it.classifierOrNull?.owner as? IrClass)?.fqNameForIrSerialization == FqName("kotlinx.cinterop.CEnum") } } -// TODO: get rid of consulting descriptors for annotations. // Make sure external stubs always get proper annotaions. private fun IrDeclaration.hasCCallAnnotation(name: String): Boolean = - this.annotations.hasAnnotation(cCall.child(Name.identifier(name))) || - this.descriptor.annotations.hasAnnotation(cCall.child(Name.identifier(name))) + this.annotations.hasAnnotation(cCall.child(Name.identifier(name))) private fun IrValueParameter.isWCStringParameter() = hasCCallAnnotation("WCString") diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/DescriptorUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/DescriptorUtils.kt index 79f58cd1877..9ec9be73449 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/DescriptorUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/DescriptorUtils.kt @@ -5,17 +5,19 @@ package org.jetbrains.kotlin.backend.konan.descriptors +import org.jetbrains.kotlin.backend.konan.* +import org.jetbrains.kotlin.backend.konan.descriptors.resolveFakeOverride import org.jetbrains.kotlin.backend.konan.ir.* -import org.jetbrains.kotlin.backend.konan.isInlinedNative +import org.jetbrains.kotlin.backend.konan.isObjCClass +import org.jetbrains.kotlin.backend.konan.llvm.longName import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.IrConst +import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.types.isUnit -import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization -import org.jetbrains.kotlin.ir.util.isReal -import org.jetbrains.kotlin.ir.util.isSuspend -import org.jetbrains.kotlin.ir.util.overrides +import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.types.SimpleType /** @@ -75,12 +77,8 @@ internal fun IrSimpleFunction.resolveFakeOverride(allowAbstract: Boolean = false return realSupers.first { allowAbstract || it.modality != Modality.ABSTRACT } } -// TODO: don't forget to remove descriptor access here. internal val IrFunction.isTypedIntrinsic: Boolean - get() = this.descriptor.isTypedIntrinsic - -internal val IrDeclaration.isFrozen: Boolean - get() = this.descriptor.isFrozen + get() = annotations.hasAnnotation(KonanFqNames.typedIntrinsic) internal val arrayTypes = setOf( "kotlin.Array", @@ -242,4 +240,28 @@ fun IrDeclaration.findTopLevelDeclaration(): IrDeclaration = when { (this as IrField).correspondingProperty!!.findTopLevelDeclaration() else -> (this.parent as IrDeclaration).findTopLevelDeclaration() -} \ No newline at end of file +} + +internal val IrClass.isFrozen: Boolean + get() = annotations.hasAnnotation(KonanFqNames.frozen) || + // RTTI is used for non-reference type box or Objective-C object wrapper: + !this.defaultType.binaryTypeIsReference() || this.isObjCClass() + +fun IrConstructorCall.getAnnotationValue() = (getValueArgument(0) as? IrConst)?.value + +fun IrConstructorCall.getStringValue(name: String): String { + val parameter = symbol.owner.valueParameters.single { it.name.asString() == name } + return (getValueArgument(parameter.index) as IrConst).value +} + +fun IrFunction.externalSymbolOrThrow(): String? { + annotations.findAnnotation(RuntimeNames.symbolNameAnnotation)?.let { return it.getAnnotationValue() } + + if (annotations.hasAnnotation(KonanFqNames.objCMethod)) return null + + if (annotations.hasAnnotation(KonanFqNames.typedIntrinsic)) return null + + if (annotations.hasAnnotation(RuntimeNames.cCall)) return null + + throw Error("external function ${this.longName} must have @TypedIntrinsic, @SymbolName or @ObjCMethod annotation") +} diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/LegacyDescriptorUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/LegacyDescriptorUtils.kt index fbb497be5fe..dac78dc929a 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/LegacyDescriptorUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/LegacyDescriptorUtils.kt @@ -7,22 +7,14 @@ package org.jetbrains.kotlin.backend.konan.descriptors import org.jetbrains.kotlin.backend.common.atMostOne import org.jetbrains.kotlin.backend.konan.RuntimeNames -import org.jetbrains.kotlin.backend.konan.binaryTypeIsReference -import org.jetbrains.kotlin.backend.konan.isObjCClass import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl -import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl import org.jetbrains.kotlin.descriptors.konan.DeserializedKonanModuleOrigin import org.jetbrains.kotlin.descriptors.konan.konanModuleOrigin import org.jetbrains.kotlin.metadata.konan.KonanProtoBuf import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.DescriptorFactory import org.jetbrains.kotlin.resolve.OverridingUtil -import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.module @@ -30,11 +22,8 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor import org.jetbrains.kotlin.serialization.konan.KonanPackageFragment -import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.isNothing import org.jetbrains.kotlin.types.typeUtil.isUnit -import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty - /** * Implementation of given method. @@ -172,31 +161,6 @@ internal val DeclarationDescriptor.isExpectMember: Boolean internal val DeclarationDescriptor.isSerializableExpectClass: Boolean get() = this is ClassDescriptor && ExpectedActualDeclarationChecker.shouldGenerateExpectClass(this) -internal fun KotlinType?.createExtensionReceiver(owner: CallableDescriptor): ReceiverParameterDescriptor? = - DescriptorFactory.createExtensionReceiverParameterForCallable( - owner, - this, - Annotations.EMPTY - ) - -internal fun FunctionDescriptorImpl.initialize( - extensionReceiverType: KotlinType?, - dispatchReceiverParameter: ReceiverParameterDescriptor?, - typeParameters: List, - unsubstitutedValueParameters: List, - unsubstitutedReturnType: KotlinType?, - modality: Modality?, - visibility: Visibility -): FunctionDescriptorImpl = this.initialize( - extensionReceiverType.createExtensionReceiver(this), - dispatchReceiverParameter, - typeParameters, - unsubstitutedValueParameters, - unsubstitutedReturnType, - modality, - visibility -) - private fun sourceByIndex(descriptor: CallableMemberDescriptor, index: Int): SourceFile { val fragment = descriptor.findPackage() as KonanPackageFragment return fragment.sourceFileMap.sourceFile(index) @@ -216,43 +180,4 @@ fun CallableMemberDescriptor.findSourceFile(): SourceFile { } } -internal val DeclarationDescriptor.isFrozen: Boolean - get() = this.annotations.hasAnnotation(RuntimeNames.frozenAnnotation) || - (this is org.jetbrains.kotlin.descriptors.ClassDescriptor - // RTTI is used for non-reference type box or Objective-C object wrapper: - && (!this.defaultType.binaryTypeIsReference() || this.isObjCClass())) - -internal val FunctionDescriptor.isTypedIntrinsic: Boolean - get() = this.annotations.hasAnnotation(RuntimeNames.typedIntrinsicAnnotation) - -// TODO: coalesce all our annotation value getters into fewer functions. -fun getAnnotationValue(annotation: AnnotationDescriptor): String? { - return annotation.allValueArguments.values.ifNotEmpty { - val stringValue = single() as? StringValue - stringValue?.value - } -} - -fun CallableMemberDescriptor.externalSymbolOrThrow(): String? { - this.annotations.findAnnotation(RuntimeNames.symbolNameAnnotation)?.let { - return getAnnotationValue(it)!! - } - if (this.annotations.hasAnnotation(RuntimeNames.objCMethodAnnotation)) return null - - if (this.annotations.hasAnnotation(RuntimeNames.typedIntrinsicAnnotation)) return null - - if (this.annotations.hasAnnotation(RuntimeNames.cCall)) return null - - throw Error("external function ${this} must have @TypedIntrinsic, @SymbolName or @ObjCMethod annotation") -} - -fun createAnnotation( - descriptor: ClassDescriptor, - vararg values: Pair -): AnnotationDescriptor = AnnotationDescriptorImpl( - descriptor.defaultType, - values.map { (name, value) -> Name.identifier(name) to StringValue(value) }.toMap(), - SourceElement.NO_SOURCE -) - val ModuleDescriptor.konanLibrary get() = (this.konanModuleOrigin as? DeserializedKonanModuleOrigin)?.library diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt index 4c34b76c89e..510050dffb2 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt @@ -451,13 +451,13 @@ internal class KonanSymbols(context: Context, private val symbolTable: SymbolTab ) val listOfInternal = internalFunction("listOfInternal") - val threadLocal = + val threadLocal = symbolTable.referenceClass( context.builtIns.builtInsModule.findClassAcrossModuleDependencies( - ClassId.topLevel(FqName("kotlin.native.concurrent.ThreadLocal")))!! + ClassId.topLevel(KonanFqNames.threadLocal))!!) - val sharedImmutable = + val sharedImmutable = symbolTable.referenceClass( context.builtIns.builtInsModule.findClassAcrossModuleDependencies( - ClassId.topLevel(FqName("kotlin.native.concurrent.SharedImmutable")))!! + ClassId.topLevel(KonanFqNames.sharedImmutable))!!) private fun topLevelClass(fqName: String): IrClassSymbol = topLevelClass(FqName(fqName)) private fun topLevelClass(fqName: FqName): IrClassSymbol = classById(ClassId.topLevel(fqName)) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt index 693600af2c6..7e3b1c4dba8 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.backend.konan.ir import org.jetbrains.kotlin.backend.common.atMostOne -import org.jetbrains.kotlin.backend.konan.descriptors.getArgumentValueOrNull import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities @@ -69,14 +68,7 @@ val IrClass.isFinalClass: Boolean fun IrClass.isSpecialClassWithNoSupertypes() = this.isAny() || this.isNothing() fun IrDeclaration.getAnnotationArgumentValue(fqName: FqName, argumentName: String): T? { - val annotation = this.annotations.findAnnotation(fqName) - if (annotation == null) { - // As a last resort try searching the descriptor. - // This is needed for a period while we don't have IR for platform libraries. - return this.descriptor.annotations - .findAnnotation(fqName) - ?.getArgumentValueOrNull(argumentName) - } + val annotation = this.annotations.findAnnotation(fqName) ?: return null for (index in 0 until annotation.valueArgumentsCount) { val parameter = annotation.symbol.owner.valueParameters[index] if (parameter.name == Name.identifier(argumentName)) { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt index 94f5a8c5170..9469fc41f49 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt @@ -18,11 +18,9 @@ import org.jetbrains.kotlin.backend.konan.ir.isUnit import org.jetbrains.kotlin.backend.konan.llvm.KonanMangler.isExported import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.types.* -import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization import org.jetbrains.kotlin.ir.types.getClass -import org.jetbrains.kotlin.ir.util.isSuspend -import org.jetbrains.kotlin.ir.util.isVararg import org.jetbrains.kotlin.backend.konan.isInlinedNative +import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.konan.library.KonanLibrary import org.jetbrains.kotlin.library.uniqueName @@ -45,20 +43,19 @@ object KonanMangler : KotlinManglerImpl() { */ override fun IrDeclaration.isPlatformSpecificExported(): Boolean { // TODO: revise - val descriptorAnnotations = this.descriptor.annotations - if (descriptorAnnotations.hasAnnotation(RuntimeNames.symbolNameAnnotation)) { + if (annotations.hasAnnotation(RuntimeNames.symbolNameAnnotation)) { // Treat any `@SymbolName` declaration as exported. return true } - if (descriptorAnnotations.hasAnnotation(RuntimeNames.exportForCppRuntime)) { + if (annotations.hasAnnotation(RuntimeNames.exportForCppRuntime)) { // Treat any `@ExportForCppRuntime` declaration as exported. return true } - if (descriptorAnnotations.hasAnnotation(RuntimeNames.cnameAnnotation)) { + if (annotations.hasAnnotation(RuntimeNames.cnameAnnotation)) { // Treat `@CName` declaration as exported. return true } - if (descriptorAnnotations.hasAnnotation(RuntimeNames.exportForCompilerAnnotation)) { + if (annotations.hasAnnotation(RuntimeNames.exportForCompilerAnnotation)) { return true } @@ -107,13 +104,13 @@ object KonanMangler : KotlinManglerImpl() { } if (isExternal) { - this.descriptor.externalSymbolOrThrow()?.let { + this.externalSymbolOrThrow()?.let { return it } } - this.descriptor.annotations.findAnnotation(RuntimeNames.exportForCppRuntime)?.let { - val name = getAnnotationValue(it) ?: this.name.asString() + this.annotations.findAnnotation(RuntimeNames.exportForCppRuntime)?.let { + val name = it.getAnnotationValue() ?: this.name.asString() return name // no wrapping currently required } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt index 56170441a7e..39e294534c7 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt @@ -3,6 +3,7 @@ package org.jetbrains.kotlin.backend.konan.llvm import kotlinx.cinterop.cValuesOf import llvm.* import org.jetbrains.kotlin.backend.konan.RuntimeNames +import org.jetbrains.kotlin.backend.konan.descriptors.getAnnotationValue import org.jetbrains.kotlin.backend.konan.descriptors.isTypedIntrinsic import org.jetbrains.kotlin.backend.konan.llvm.objc.genObjCSelector import org.jetbrains.kotlin.backend.konan.reportCompilationError @@ -12,8 +13,8 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.types.getClass import org.jetbrains.kotlin.ir.util.dump +import org.jetbrains.kotlin.ir.util.findAnnotation import org.jetbrains.kotlin.ir.util.isSuspend -import org.jetbrains.kotlin.name.Name internal enum class IntrinsicType { PLUS, @@ -113,8 +114,8 @@ internal fun tryGetIntrinsicType(callSite: IrFunctionAccessExpression): Intrinsi private fun getIntrinsicType(callSite: IrFunctionAccessExpression): IntrinsicType { val function = callSite.symbol.owner - val annotation = function.descriptor.annotations.findAnnotation(RuntimeNames.typedIntrinsicAnnotation)!! - val value = annotation.allValueArguments.getValue(Name.identifier("kind")).value as String + val annotation = function.annotations.findAnnotation(RuntimeNames.typedIntrinsicAnnotation)!! + val value = annotation.getAnnotationValue()!! return IntrinsicType.valueOf(value) } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index 762d9705644..2accbb6ac9f 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.backend.konan.ir.* import org.jetbrains.kotlin.backend.konan.ir.NaiveSourceBasedFileEntryImpl import org.jetbrains.kotlin.backend.konan.ir.containsNull import org.jetbrains.kotlin.backend.konan.llvm.coverage.* -import org.jetbrains.kotlin.backend.konan.llvm.objcexport.is64Bit import org.jetbrains.kotlin.backend.konan.optimizations.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.UnsignedType @@ -28,29 +27,14 @@ import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.descriptors.IrPropertyDelegateDescriptor import org.jetbrains.kotlin.ir.expressions.* -import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.ir.visitors.acceptVoid import org.jetbrains.kotlin.konan.target.CompilerOutputKind -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.descriptorUtil.classId -private val threadLocalAnnotationFqName = FqName("kotlin.native.concurrent.ThreadLocal") -private val sharedAnnotationFqName = FqName("kotlin.native.concurrent.SharedImmutable") -private val frozenAnnotationFqName = FqName("kotlin.native.internal.Frozen") - -val IrField.propertyDescriptor: PropertyDescriptor - get() { - val descriptor = this.descriptor - return if (descriptor is IrPropertyDelegateDescriptor) - descriptor.correspondingProperty - else - descriptor - } - internal enum class FieldStorage { MAIN_THREAD, SHARED, @@ -59,17 +43,18 @@ internal enum class FieldStorage { // TODO: maybe unannotated singleton objects shall be accessed from main thread only as well? val IrClass.objectIsShared get() = - !descriptor.annotations.hasAnnotation(threadLocalAnnotationFqName) + !annotations.hasAnnotation(KonanFqNames.threadLocal) internal val IrField.storageClass: FieldStorage get() { - val descriptor = propertyDescriptor + // TODO: Is this correct? + val annotations = correspondingPropertySymbol?.owner?.annotations ?: annotations return when { - descriptor.annotations.hasAnnotation(threadLocalAnnotationFqName) -> FieldStorage.THREAD_LOCAL + annotations.hasAnnotation(KonanFqNames.threadLocal) -> FieldStorage.THREAD_LOCAL !isFinal -> FieldStorage.MAIN_THREAD - descriptor.annotations.hasAnnotation(sharedAnnotationFqName) -> FieldStorage.SHARED + annotations.hasAnnotation(KonanFqNames.sharedImmutable) -> FieldStorage.SHARED // TODO: simplify, once IR types are fully there. - type is IrSimpleType && (type as IrSimpleType). - classifier.descriptor.annotations.hasAnnotation(frozenAnnotationFqName) -> FieldStorage.SHARED + (type.classifierOrNull?.owner as? IrAnnotationContainer) + ?.annotations?.hasAnnotation(KonanFqNames.frozen) == true -> FieldStorage.SHARED else -> FieldStorage.MAIN_THREAD } } @@ -682,7 +667,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map() .mapNotNull { val annotation = - it.descriptor.annotations.findAnnotation(context.interopBuiltIns.objCMethodImp.fqNameSafe) ?: + it.annotations.findAnnotation(context.interopBuiltIns.objCMethodImp.fqNameSafe) ?: return@mapNotNull null ObjCMethodDesc( diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt index 1139096dac6..232f85f7c0b 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt @@ -14,8 +14,6 @@ import org.jetbrains.kotlin.backend.konan.isExternalObjCClassMethod import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.* -import org.jetbrains.kotlin.konan.KonanAbiVersion -import org.jetbrains.kotlin.ir.util.fqNameSafe import org.jetbrains.kotlin.ir.util.isAnnotationClass import org.jetbrains.kotlin.ir.util.isInterface import org.jetbrains.kotlin.library.KotlinAbiVersion @@ -128,9 +126,9 @@ internal class RTTIGenerator(override val context: Context) : ContextUtils { private val EXPORT_TYPE_INFO_FQ_NAME = FqName.fromSegments(listOf("kotlin", "native", "internal", "ExportTypeInfo")) private fun exportTypeInfoIfRequired(irClass: IrClass, typeInfoGlobal: LLVMValueRef?) { - val annotation = irClass.descriptor.annotations.findAnnotation(EXPORT_TYPE_INFO_FQ_NAME) + val annotation = irClass.annotations.findAnnotation(EXPORT_TYPE_INFO_FQ_NAME) if (annotation != null) { - val name = getAnnotationValue(annotation)!! + val name = annotation.getAnnotationValue()!! // TODO: use LLVMAddAlias. val global = addGlobal(name, pointerType(runtime.typeInfoType), isExported = true) LLVMSetInitializer(global, typeInfoGlobal) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RetainAnnotation.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RetainAnnotation.kt index 8434a9f7b79..b75fa9aa91b 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RetainAnnotation.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RetainAnnotation.kt @@ -5,18 +5,18 @@ package org.jetbrains.kotlin.backend.konan.llvm -import org.jetbrains.kotlin.backend.konan.descriptors.getStringValueOrNull -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.backend.konan.descriptors.getAnnotationValue +import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.util.findAnnotation import org.jetbrains.kotlin.konan.target.KonanTarget import org.jetbrains.kotlin.name.FqName private val retainAnnotationName = FqName("kotlin.native.Retain") private val retainForTargetAnnotationName = FqName("kotlin.native.RetainForTarget") - -internal fun FunctionDescriptor.retainAnnotation(target: KonanTarget): Boolean { +internal fun IrFunction.retainAnnotation(target: KonanTarget): Boolean { if (this.annotations.findAnnotation(retainAnnotationName) != null) return true val forTarget = this.annotations.findAnnotation(retainForTargetAnnotationName) - if (forTarget != null && forTarget.getStringValueOrNull("target") == target.name) return true + if (forTarget != null && forTarget.getAnnotationValue() == target.name) return true return false } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/CallableReferenceLowering.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/CallableReferenceLowering.kt index 90a6069c1fe..a104191a469 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/CallableReferenceLowering.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/CallableReferenceLowering.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.backend.konan.Context import org.jetbrains.kotlin.backend.konan.descriptors.synthesizedName import org.jetbrains.kotlin.backend.common.pop import org.jetbrains.kotlin.backend.common.push -import org.jetbrains.kotlin.backend.konan.ir.fqNameForIrSerialization import org.jetbrains.kotlin.backend.konan.ir.isFunctionOrKFunctionType import org.jetbrains.kotlin.backend.konan.llvm.functionName import org.jetbrains.kotlin.descriptors.* @@ -95,11 +94,10 @@ internal class CallableReferenceLowering(val context: Context): FileLoweringPass if (cur !is IrCall) break val argument = if (i < stack.size - 1) stack[i + 1] else expression - val descriptor = cur.descriptor - val argumentDescriptor = descriptor.valueParameters.singleOrNull { + val parameter = cur.symbol.owner.valueParameters.singleOrNull { cur.getValueArgument(it.index) == argument } - if (argumentDescriptor?.annotations?.findAnnotation(VOLATILE_LAMBDA_FQ_NAME) != null) { + if (parameter?.annotations?.findAnnotation(VOLATILE_LAMBDA_FQ_NAME) != null) { return expression } break diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ContractsDslRemover.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ContractsDslRemover.kt index bec6f69c68a..79876d8f4be 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ContractsDslRemover.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ContractsDslRemover.kt @@ -10,12 +10,13 @@ import org.jetbrains.kotlin.backend.konan.Context import org.jetbrains.kotlin.contracts.parsing.ContractsDslNames import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrDeclarationContainer +import org.jetbrains.kotlin.ir.util.hasAnnotation import org.jetbrains.kotlin.ir.util.transformFlat internal class ContractsDslRemover(val context: Context) : DeclarationContainerLoweringPass { override fun lower(irDeclarationContainer: IrDeclarationContainer) { irDeclarationContainer.declarations.transformFlat { - if (it is IrClass && it.descriptor.annotations.hasAnnotation(ContractsDslNames.CONTRACTS_DSL_ANNOTATION_FQN)) + if (it is IrClass && it.annotations.hasAnnotation(ContractsDslNames.CONTRACTS_DSL_ANNOTATION_FQN)) null else listOf(it) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/DelegationLowering.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/DelegationLowering.kt index 8c57a62cd05..80a154599d8 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/DelegationLowering.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/DelegationLowering.kt @@ -12,6 +12,10 @@ import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.lower.irBlock import org.jetbrains.kotlin.backend.konan.Context import org.jetbrains.kotlin.backend.konan.descriptors.synthesizedName +import org.jetbrains.kotlin.backend.konan.KonanBackendContext +import org.jetbrains.kotlin.backend.konan.ir.buildSimpleAnnotation +import org.jetbrains.kotlin.backend.konan.ir.typeWithStarProjections +import org.jetbrains.kotlin.backend.konan.isObjCClass import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl import org.jetbrains.kotlin.descriptors.annotations.Annotations @@ -87,10 +91,7 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa val kPropertiesFieldType: IrType = context.ir.symbols.array.typeWith(kPropertyImplType) - val kPropertiesField = WrappedFieldDescriptor( - Annotations.create(listOf(AnnotationDescriptorImpl(context.ir.symbols.sharedImmutable.defaultType, - emptyMap(), SourceElement.NO_SOURCE))) - ).let { + val kPropertiesField = WrappedFieldDescriptor().let { IrFieldImpl( SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, DECLARATION_ORIGIN_KPROPERTIES_FOR_DELEGATION, @@ -104,6 +105,7 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa ).apply { it.bind(this) parent = irFile + annotations += buildSimpleAnnotation(context.irBuiltIns, startOffset, endOffset, context.ir.symbols.sharedImmutable.owner) } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt index d4de8f4614a..711bdda4719 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt @@ -5,13 +5,13 @@ package org.jetbrains.kotlin.backend.konan.lower -import org.jetbrains.kotlin.backend.common.FileLoweringPass +import org.jetbrains.kotlin.backend.common.* +import org.jetbrains.kotlin.backend.common.descriptors.WrappedSimpleFunctionDescriptor +import org.jetbrains.kotlin.backend.common.descriptors.WrappedValueParameterDescriptor +import org.jetbrains.kotlin.backend.common.ir.copyTo import org.jetbrains.kotlin.backend.common.ir.createDispatchReceiverParameter import org.jetbrains.kotlin.backend.common.ir.simpleFunctions import org.jetbrains.kotlin.backend.common.lower.* -import org.jetbrains.kotlin.backend.common.peek -import org.jetbrains.kotlin.backend.common.pop -import org.jetbrains.kotlin.backend.common.push import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.backend.konan.cgen.* import org.jetbrains.kotlin.backend.konan.descriptors.allOverriddenFunctions @@ -26,12 +26,7 @@ import org.jetbrains.kotlin.backend.konan.llvm.tryGetIntrinsicType import org.jetbrains.kotlin.builtins.UnsignedTypes import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl -import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.builders.* @@ -43,15 +38,15 @@ import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol +import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl +import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.OverridingUtil -import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny internal abstract class BaseInteropIrTransformer(private val context: Context) : IrBuildingTransformer(context) { @@ -159,20 +154,20 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo irClass.declarations.toList().mapNotNull { when { - it is IrSimpleFunction && it.descriptor.annotations.hasAnnotation(interop.objCAction) -> + it is IrSimpleFunction && it.annotations.hasAnnotation(interop.objCAction.fqNameSafe) -> generateActionImp(it) - it is IrProperty && it.descriptor.annotations.hasAnnotation(interop.objCOutlet) -> + it is IrProperty && it.annotations.hasAnnotation(interop.objCOutlet.fqNameSafe) -> generateOutletSetterImp(it) - it is IrConstructor && it.descriptor.annotations.hasAnnotation(interop.objCOverrideInit) -> + it is IrConstructor && it.annotations.hasAnnotation(interop.objCOverrideInit.fqNameSafe) -> generateOverrideInit(irClass, it) else -> null } }.let { irClass.addChildren(it) } - if (irClass.descriptor.annotations.hasAnnotation(interop.exportObjCClass.fqNameSafe)) { + if (irClass.annotations.hasAnnotation(interop.exportObjCClass.fqNameSafe)) { val irBuilder = context.createIrBuilder(currentFile.symbol).at(irClass) topLevelInitializers.add(irBuilder.getObjCClass(irClass.symbol)) } @@ -224,51 +219,26 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo // Generate `override fun init...(...) = this.initBy(...)`: - val resultDescriptor = SimpleFunctionDescriptorImpl.create( - irClass.descriptor, - Annotations.EMPTY, - initMethod.name, - CallableMemberDescriptor.Kind.DECLARATION, - SourceElement.NO_SOURCE - ) - - val valueParameters = constructor.valueParameters.map { - val descriptor = ValueParameterDescriptorImpl( - resultDescriptor, - null, - it.index, - Annotations.EMPTY, - it.name, - it.descriptor.type, - false, - false, - false, - it.varargElementType?.toKotlinType(), - SourceElement.NO_SOURCE - ) - it.copy(descriptor) - } - resultDescriptor.initialize( - null, - irClass.descriptor.thisAsReceiverParameter, - emptyList(), - valueParameters.map { it.descriptor as ValueParameterDescriptor }, - irClass.descriptor.defaultType, - Modality.OPEN, - Visibilities.PUBLIC - ) - + val resultDescriptor = WrappedSimpleFunctionDescriptor() return IrFunctionImpl( - constructor.startOffset, constructor.endOffset, OVERRIDING_INITIALIZER_BY_CONSTRUCTOR, - resultDescriptor, - irClass.defaultType + constructor.startOffset, constructor.endOffset, + OVERRIDING_INITIALIZER_BY_CONSTRUCTOR, + IrSimpleFunctionSymbolImpl(resultDescriptor), + initMethod.name, + Visibilities.PUBLIC, + Modality.OPEN, + irClass.defaultType, + isInline = false, + isExternal = false, + isTailrec = false, + isSuspend = false ).also { result -> + resultDescriptor.bind(result) result.parent = irClass result.createDispatchReceiverParameter() - result.valueParameters += valueParameters + constructor.valueParameters.mapTo(result.valueParameters) { it.copyTo(result) } result.overriddenSymbols.add(initMethod.symbol) - result.descriptor.overriddenDescriptors = listOf(initMethod.descriptor) result.body = context.createIrBuilder(result.symbol).irBlockBody(result) { +irReturn( @@ -390,54 +360,40 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo } } - val newDescriptor = SimpleFunctionDescriptorImpl.create( - function.descriptor.containingDeclaration, - Annotations.EMPTY, - ("imp:" + selector).synthesizedName, - CallableMemberDescriptor.Kind.SYNTHESIZED, - SourceElement.NO_SOURCE - ) - - val valueParameters = parameterTypes.mapIndexed { index, it -> - ValueParameterDescriptorImpl( - newDescriptor, - null, - index, - Annotations.EMPTY, - Name.identifier("p$index"), - it.toKotlinType(), - false, - false, - false, - null, - SourceElement.NO_SOURCE - ) + val newFunction = WrappedSimpleFunctionDescriptor().let { + IrFunctionImpl( + function.startOffset, function.endOffset, + IrDeclarationOrigin.DEFINED, + IrSimpleFunctionSymbolImpl(it), + ("imp:$selector").synthesizedName, + Visibilities.PRIVATE, + Modality.FINAL, + returnType, + isInline = false, + isExternal = false, + isTailrec = false, + isSuspend = false + ).apply { + it.bind(this) + } } - newDescriptor.initialize( - null, null, - emptyList(), - valueParameters, - function.descriptor.returnType, - Modality.FINAL, - Visibilities.PRIVATE - ) - - val newFunction = IrFunctionImpl( - function.startOffset, function.endOffset, - IrDeclarationOrigin.DEFINED, - newDescriptor, - function.returnType - ).apply { - parameterTypes.mapIndexedTo(this.valueParameters) { index, it -> + parameterTypes.mapIndexedTo(newFunction.valueParameters) { index, type -> + WrappedValueParameterDescriptor().let { IrValueParameterImpl( - startOffset, - endOffset, + function.startOffset, function.endOffset, IrDeclarationOrigin.DEFINED, - descriptor.valueParameters[index], - it, - null - ) + IrValueParameterSymbolImpl(it), + Name.identifier("p$index"), + index, + type, + varargElementType = null, + isCrossinline = false, + isNoinline = false + ).apply { + it.bind(this) + parent = newFunction + } } } @@ -480,18 +436,6 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo } } - private fun createObjCMethodImpAnnotations(selector: String, encoding: String): Annotations { - val annotation = AnnotationDescriptorImpl( - context.interopBuiltIns.objCMethodImp.defaultType, - mapOf("selector" to selector, "encoding" to encoding) - .mapKeys { Name.identifier(it.key) } - .mapValues { StringValue(it.value) }, - SourceElement.NO_SOURCE - ) - - return Annotations.create(listOf(annotation)) - } - private fun checkKotlinObjCClass(irClass: IrClass) { val kind = irClass.descriptor.kind if (kind != ClassKind.CLASS && kind != ClassKind.OBJECT) { @@ -561,7 +505,6 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo builder.at(expression) val constructedClass = outerClasses.peek()!! - val constructedClassDescriptor = constructedClass.descriptor if (!constructedClass.isObjCClass()) { return expression @@ -578,12 +521,13 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo } } + val delegatingCallConstructingClass = expression.symbol.owner.constructedClass if (!constructedClass.isExternalObjCClass() && - (expression.symbol.owner.constructedClass).isExternalObjCClass()) { + delegatingCallConstructingClass.isExternalObjCClass()) { // Calling super constructor from Kotlin Objective-C class. - assert(constructedClassDescriptor.getSuperClassNotAny() == expression.descriptor.constructedClass) + assert(constructedClass.getSuperClassNotAny() == delegatingCallConstructingClass) val initMethod = expression.symbol.owner.getObjCInitMethod()!! @@ -602,14 +546,14 @@ internal class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfo val initCall = builder.genLoweredObjCMethodCall( initMethodInfo, - superQualifier = expression.symbol.owner.constructedClass.symbol, + superQualifier = delegatingCallConstructingClass.symbol, receiver = builder.getRawPtr(builder.irGet(constructedClass.thisReceiver!!)), arguments = initMethod.valueParameters.map { expression.getValueArgument(it.index) }, call = expression, method = initMethod ) - val superConstructor = expression.symbol.owner.constructedClass + val superConstructor = delegatingCallConstructingClass .constructors.single { it.valueParameters.size == 0 }.symbol return builder.irBlock(expression) { @@ -897,7 +841,7 @@ private class InteropTransformer(val context: Context, override val irFile: IrFi } } - if (function.descriptor.annotations.hasAnnotation(RuntimeNames.cCall)) { + if (function.annotations.hasAnnotation(RuntimeNames.cCall)) { context.llvmImports.add(function.descriptor.llvmSymbolOrigin) return generateWithStubs { generateCCall(expression, builder, isInvoke = false) } } @@ -1186,5 +1130,3 @@ private fun IrBuilder.irFloat(value: Float) = private fun IrBuilder.irDouble(value: Double) = IrConstImpl.double(startOffset, endOffset, context.irBuiltIns.doubleType, value) - -private fun Annotations.hasAnnotation(descriptor: ClassDescriptor) = this.hasAnnotation(descriptor.fqNameSafe) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/TestProcessor.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/TestProcessor.kt index 5e75e1a6d59..2a0c349d2ba 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/TestProcessor.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/TestProcessor.kt @@ -463,7 +463,7 @@ internal class TestProcessor (val context: Context) { } } - private val IrClass.ignored: Boolean get() = descriptor.annotations.hasAnnotation(IGNORE_FQ_NAME) + private val IrClass.ignored: Boolean get() = annotations.hasAnnotation(IGNORE_FQ_NAME) /** * Builds a test suite class representing a test class (any class in the original IrFile with method(s) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt index 9566d364cf3..7171efeaa68 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt @@ -19,10 +19,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrGetField +import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.getClass import org.jetbrains.kotlin.ir.types.isNothing @@ -602,15 +599,15 @@ internal object DataFlowIR { } val symbol = when { it.isExternal || (it.symbol in context.irBuiltIns.irBuiltInsSymbols) -> { - val escapesAnnotation = it.descriptor.annotations.findAnnotation(FQ_NAME_ESCAPES) - val pointsToAnnotation = it.descriptor.annotations.findAnnotation(FQ_NAME_POINTS_TO) + val escapesAnnotation = it.annotations.findAnnotation(FQ_NAME_ESCAPES) + val pointsToAnnotation = it.annotations.findAnnotation(FQ_NAME_POINTS_TO) @Suppress("UNCHECKED_CAST") - val escapesBitMask = (escapesAnnotation?.allValueArguments?.get(escapesWhoDescriptor.name) as? ConstantValue)?.value + val escapesBitMask = (escapesAnnotation?.getValueArgument(0) as? IrConst)?.value @Suppress("UNCHECKED_CAST") - val pointsToBitMask = (pointsToAnnotation?.allValueArguments?.get(pointsToOnWhomDescriptor.name) as? ConstantValue>)?.value + val pointsToBitMask = (pointsToAnnotation?.getValueArgument(0) as? IrVararg)?.elements?.map { (it as IrConst).value } FunctionSymbol.External(name.localHash.value, attributes, it, takeName { name }).apply { escapes = escapesBitMask - pointsTo = pointsToBitMask?.let { it.map { it.value }.toIntArray() } + pointsTo = pointsToBitMask?.let { it.toIntArray() } } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt index 8c3656e8f7b..0ddd6b5e15a 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt @@ -7,6 +7,7 @@ import org.jetbrains.kotlin.backend.konan.llvm.KonanMangler import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.util.hasAnnotation class KonanIrModuleSerializer( logger: LoggingContext, @@ -15,9 +16,9 @@ class KonanIrModuleSerializer( ) : IrModuleSerializer(logger, declarationTable, KonanMangler, bodiesOnlyForInlines) { override fun backendSpecificExplicitRoot(declaration: IrFunction) = - declaration.descriptor.annotations.hasAnnotation(RuntimeNames.exportForCppRuntime) + declaration.annotations.hasAnnotation(RuntimeNames.exportForCppRuntime) override fun backendSpecificExplicitRoot(declaration: IrClass) = - declaration.descriptor.annotations.hasAnnotation(RuntimeNames.exportTypeInfoAnnotation) + declaration.annotations.hasAnnotation(RuntimeNames.exportTypeInfoAnnotation) } \ No newline at end of file diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt index 93a26e6e218..d5b9dae5aa9 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt @@ -7,22 +7,20 @@ package org.jetbrains.kotlin.ir.util import org.jetbrains.kotlin.backend.common.CommonBackendContext import org.jetbrains.kotlin.backend.common.descriptors.* -import org.jetbrains.kotlin.backend.common.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.backend.common.descriptors.WrappedVariableDescriptor import org.jetbrains.kotlin.backend.common.descriptors.substitute -import org.jetbrains.kotlin.backend.common.ir.copyParameterDeclarationsFrom import org.jetbrains.kotlin.backend.konan.KonanBackendContext import org.jetbrains.kotlin.backend.konan.KonanCompilationException +import org.jetbrains.kotlin.backend.konan.KonanFqNames +import org.jetbrains.kotlin.backend.konan.RuntimeNames import org.jetbrains.kotlin.backend.konan.descriptors.synthesizedName -import org.jetbrains.kotlin.backend.konan.ir.allParameters +import org.jetbrains.kotlin.backend.konan.ir.buildSimpleAnnotation import org.jetbrains.kotlin.backend.konan.ir.containsNull import org.jetbrains.kotlin.builtins.KOTLIN_REFLECT_FQ_NAME import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.ParameterDescriptor -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl -import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.* @@ -36,8 +34,6 @@ import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl @@ -65,13 +61,7 @@ internal fun IrExpression.isNullConst() = this is IrConst<*> && this.kind == IrC private var topLevelInitializersCounter = 0 internal fun IrFile.addTopLevelInitializer(expression: IrExpression, context: KonanBackendContext, threadLocal: Boolean) { - val descriptor = WrappedFieldDescriptor( - if (threadLocal) - Annotations.create(listOf(AnnotationDescriptorImpl(context.ir.symbols.threadLocal.defaultType, - emptyMap(), SourceElement.NO_SOURCE))) - else - Annotations.EMPTY - ) + val descriptor = WrappedFieldDescriptor() val irField = IrFieldImpl( expression.startOffset, expression.endOffset, IrDeclarationOrigin.DEFINED, @@ -85,7 +75,10 @@ internal fun IrFile.addTopLevelInitializer(expression: IrExpression, context: Ko ).apply { descriptor.bind(this) - initializer = IrExpressionBodyImpl(expression.startOffset, expression.endOffset, expression) + if (threadLocal) + annotations += buildSimpleAnnotation(context.irBuiltIns, startOffset, endOffset, context.ir.symbols.threadLocal.owner) + + initializer = IrExpressionBodyImpl(startOffset, endOffset, expression) } addChild(irField) }