diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt index 1d92af91e78..9268d445fba 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt @@ -76,14 +76,14 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu is FirRegularClass -> { // TODO: private classes are probably not acceptable here too val classId = declaration.classId - IdSignature.PublicSignature( + IdSignature.CommonSignature( classId.packageFqName.asString(), classId.relativeClassName.asString(), builder.hashId, builder.mask ) } is FirTypeAlias -> { if (declaration.visibility == Visibilities.Private) return null val classId = declaration.symbol.classId - IdSignature.PublicSignature( + IdSignature.CommonSignature( classId.packageFqName.asString(), classId.relativeClassName.asString(), builder.hashId, builder.mask ) } @@ -95,7 +95,7 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu val packageName = classId?.packageFqName ?: declaration.symbol.callableId.packageName val callableName = declaration.symbol.callableId.callableName - IdSignature.PublicSignature( + IdSignature.CommonSignature( packageName.asString(), classId?.relativeClassName?.child(callableName)?.asString() ?: callableName.asString(), builder.hashId, builder.mask @@ -110,12 +110,12 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu isSetter: Boolean, containingClass: ConeClassLikeLookupTag? ): IdSignature? { - val propertySignature = composeSignature(property, containingClass) as? IdSignature.PublicSignature ?: return null + val propertySignature = composeSignature(property, containingClass) as? IdSignature.CommonSignature ?: return null val accessorFqName = if (isSetter) { propertySignature.declarationFqName + "." } else { propertySignature.declarationFqName + "." } - return IdSignature.PublicSignature(propertySignature.packageFqName, accessorFqName, propertySignature.id, propertySignature.mask) + return IdSignature.CommonSignature(propertySignature.packageFqName, accessorFqName, propertySignature.id, propertySignature.mask) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt index 13a5d8f142e..7bca9cabbcd 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt @@ -144,7 +144,7 @@ private class FileClassLowering(val context: JvmBackendContext) : FileLoweringPa } private companion object { - private val JVM_NAME = IdSignature.PublicSignature("kotlin.jvm", "JvmName", null, 0) + private val JVM_NAME = IdSignature.CommonSignature("kotlin.jvm", "JvmName", null, 0) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt index 265e552e536..6c7dc31c893 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt @@ -137,7 +137,7 @@ private class SuspendLambdaLowering(context: JvmBackendContext) : SuspendLowerin val function = reference.symbol.owner val isRestricted = reference.symbol.owner.extensionReceiverParameter?.type?.classOrNull?.owner?.annotations?.any { - it.type.classOrNull?.signature == IdSignature.PublicSignature("kotlin.coroutines", "RestrictsSuspension", null, 0) + it.type.classOrNull?.signature == IdSignature.CommonSignature("kotlin.coroutines", "RestrictsSuspension", null, 0) } == true val suspendLambda = if (isRestricted) context.ir.symbols.restrictedSuspendLambdaClass.owner diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt index 5a05ecfed29..2dd18bb58c5 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt @@ -43,16 +43,16 @@ object IdSignatureValues { @JvmField val iterable = getPublicSignature(StandardNames.COLLECTIONS_PACKAGE_FQ_NAME, "Iterable") @JvmField val continuation = getPublicSignature(StandardNames.COROUTINES_PACKAGE_FQ_NAME_RELEASE, "Continuation") @JvmField val result = getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "Result") - @JvmField val sequence = IdSignature.PublicSignature("kotlin.sequences", "Sequence", null, 0) + @JvmField val sequence = IdSignature.CommonSignature("kotlin.sequences", "Sequence", null, 0) } -private fun IrType.isNotNullClassType(signature: IdSignature.PublicSignature) = isClassType(signature, hasQuestionMark = false) -private fun IrType.isNullableClassType(signature: IdSignature.PublicSignature) = isClassType(signature, hasQuestionMark = true) +private fun IrType.isNotNullClassType(signature: IdSignature.CommonSignature) = isClassType(signature, hasQuestionMark = false) +private fun IrType.isNullableClassType(signature: IdSignature.CommonSignature) = isClassType(signature, hasQuestionMark = true) fun getPublicSignature(packageFqName: FqName, name: String) = - IdSignature.PublicSignature(packageFqName.asString(), name, null, 0) + IdSignature.CommonSignature(packageFqName.asString(), name, null, 0) -private fun IrType.isClassType(signature: IdSignature.PublicSignature, hasQuestionMark: Boolean? = null): Boolean { +private fun IrType.isClassType(signature: IdSignature.CommonSignature, hasQuestionMark: Boolean? = null): Boolean { if (this !is IrSimpleType) return false if (hasQuestionMark != null && this.hasQuestionMark != hasQuestionMark) return false return signature == classifier.signature @@ -66,12 +66,12 @@ private fun classFqNameEquals(symbol: IrClassSymbol, fqName: FqNameUnsafe): Bool return classFqNameEquals(symbol.owner, fqName) } -private val idSignatureToPrimitiveType: Map = +private val idSignatureToPrimitiveType: Map = PrimitiveType.values().associateBy { getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, it.typeName.asString()) } -val primitiveArrayTypesSignatures: Map = +val primitiveArrayTypesSignatures: Map = PrimitiveType.values().associateWith { getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "${it.typeName.asString()}Array") } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt index 67eb1f32417..5c65fa8d04d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt @@ -337,7 +337,7 @@ abstract class DeclarationStubGenerator( private fun findDescriptorBySignature(signature: IdSignature): DeclarationDescriptor? = when (signature) { is IdSignature.AccessorSignature -> findDescriptorForAccessorSignature(signature) - is IdSignature.PublicSignature -> findDescriptorForPublicSignature(signature) + is IdSignature.CommonSignature -> findDescriptorForPublicSignature(signature) else -> error("only PublicSignature or AccessorSignature should reach this point, got $signature") } @@ -347,7 +347,7 @@ abstract class DeclarationStubGenerator( return propertyDescriptor.accessors.singleOrNull { it.name.asString() == shortName } } - private fun findDescriptorForPublicSignature(signature: IdSignature.PublicSignature): DeclarationDescriptor? { + private fun findDescriptorForPublicSignature(signature: IdSignature.CommonSignature): DeclarationDescriptor? { val packageDescriptor = moduleDescriptor.getPackage(signature.packageFqName()) val nameSegments = signature.nameSegments val toplevelDescriptors = packageDescriptor.memberScope.getDescriptorsFiltered { name -> name.asString() == nameSegments.first() } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt index 30049c6a140..0b14a36a01b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt @@ -30,7 +30,7 @@ sealed class IdSignature { abstract fun packageFqName(): FqName - open fun asPublic(): PublicSignature? = null + open fun asPublic(): CommonSignature? = null abstract fun render(): String @@ -45,7 +45,7 @@ sealed class IdSignature { override fun toString(): String = "${if (isPublic) "public" else "private"} ${render()}" - class PublicSignature(val packageFqName: String, val declarationFqName: String, val id: Long?, val mask: Long) : IdSignature() { + class CommonSignature(val packageFqName: String, val declarationFqName: String, val id: Long?, val mask: Long) : IdSignature() { override val isPublic: Boolean get() = true override fun packageFqName(): FqName = FqName(packageFqName) @@ -72,21 +72,21 @@ sealed class IdSignature { val nameSegments = nameSegments if (nameSegments.size == 1) return this - return PublicSignature(packageFqName, nameSegments.first(), null, adaptMask(mask)) + return CommonSignature(packageFqName, nameSegments.first(), null, adoptedMask) } override fun isPackageSignature(): Boolean = id == null && declarationFqName.isEmpty() - override fun nearestPublicSig(): PublicSignature = this + override fun nearestPublicSig(): CommonSignature = this override fun flags(): Long = mask override fun render(): String = "$packageFqName/$declarationFqName|$id[${mask.toString(2)}]" - override fun asPublic(): PublicSignature? = this + override fun asPublic(): CommonSignature = this override fun equals(other: Any?): Boolean = - other is PublicSignature && packageFqName == other.packageFqName && declarationFqName == other.declarationFqName && + other is CommonSignature && packageFqName == other.packageFqName && declarationFqName == other.declarationFqName && id == other.id && mask == other.mask override fun hashCode(): Int = @@ -106,7 +106,7 @@ sealed class IdSignature { override fun flags(): Long = accessorSignature.mask - override fun asPublic(): PublicSignature? = accessorSignature + override fun asPublic(): CommonSignature = accessorSignature override fun equals(other: Any?): Boolean = if (other is AccessorSignature) accessorSignature == other.accessorSignature @@ -136,14 +136,14 @@ sealed class IdSignature { val memberSignature: IdSignature, val overriddenSignatures: List ) : IdSignature() { - override val isPublic: Boolean - get() = memberSignature.isPublic + override val isPubliclyVisible: Boolean + get() = memberSignature.isPubliclyVisible override fun topLevelSignature(): IdSignature = memberSignature.topLevelSignature() override fun nearestPublicSig(): IdSignature = - if (memberSignature.isPublic) + if (memberSignature.isPubliclyVisible) this else memberSignature.nearestPublicSig() @@ -173,15 +173,15 @@ sealed class IdSignature { } } - class FileLocalSignature(val container: IdSignature, val id: Long) : IdSignature() { - override val isPublic: Boolean get() = false + class FileLocalSignature(val container: IdSignature, val id: Long, val description: String? = null) : IdSignature() { + override val isPubliclyVisible: Boolean get() = false override fun packageFqName(): FqName = container.packageFqName() override fun topLevelSignature(): IdSignature { val topLevelContainer = container.topLevelSignature() if (topLevelContainer === container) { - if (topLevelContainer is PublicSignature && topLevelContainer.declarationFqName.isEmpty()) { + if (topLevelContainer is CommonSignature && topLevelContainer.declarationFqName.isEmpty()) { // private top level return this } @@ -310,4 +310,8 @@ sealed class IdSignature { interface IdSignatureComposer { fun composeSignature(descriptor: DeclarationDescriptor): IdSignature? fun composeEnumEntrySignature(descriptor: ClassDescriptor): IdSignature? + fun composeFieldSignature(descriptor: PropertyDescriptor): IdSignature? + fun composeAnonInitSignature(descriptor: ClassDescriptor): IdSignature? + + fun inFile(file: IrFileSymbol?, block: () -> Unit) } diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt index 376aa2e535f..bde4ece0255 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt @@ -42,7 +42,7 @@ class DescriptorByIdSignatureFinder( fun findDescriptorBySignature(signature: IdSignature): DeclarationDescriptor? = when (signature) { is IdSignature.AccessorSignature -> findDescriptorForAccessorSignature(signature) - is IdSignature.PublicSignature -> findDescriptorForPublicSignature(signature) + is IdSignature.CommonSignature -> findDescriptorForPublicSignature(signature) else -> error("only PublicSignature or AccessorSignature should reach this point, got $signature") } @@ -89,7 +89,7 @@ class DescriptorByIdSignatureFinder( } } - private fun findDescriptorForPublicSignature(signature: IdSignature.PublicSignature): DeclarationDescriptor? { + private fun findDescriptorForPublicSignature(signature: IdSignature.CommonSignature): DeclarationDescriptor? { val nameSegments = signature.nameSegments val toplevelDescriptors = performLookup(nameSegments, signature.packageFqName()) .ifEmpty { return null } diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt index a7b4da2cb00..ac2accea534 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt @@ -199,7 +199,7 @@ open class IrFileSerializer( /* ------- IdSignature ------------------------------------------------------ */ - private fun serializePublicSignature(signature: IdSignature.PublicSignature): ProtoPublicIdSignature { + private fun serializePublicSignature(signature: IdSignature.CommonSignature): ProtoPublicIdSignature { val proto = ProtoPublicIdSignature.newBuilder() proto.addAllPackageFqName(serializeFqName(signature.packageFqName)) proto.addAllDeclarationFqName(serializeFqName(signature.declarationFqName)) @@ -274,7 +274,7 @@ open class IrFileSerializer( fun serializeIdSignature(idSignature: IdSignature): ProtoIdSignature { val proto = ProtoIdSignature.newBuilder() when (idSignature) { - is IdSignature.PublicSignature -> proto.publicSig = serializePublicSignature(idSignature) + is IdSignature.CommonSignature -> proto.publicSig = serializePublicSignature(idSignature) is IdSignature.AccessorSignature -> proto.accessorSig = serializeAccessorSignature(idSignature) is IdSignature.FileLocalSignature -> proto.privateSig = serializePrivateSignature(idSignature) is IdSignature.ScopeLocalDeclaration -> proto.scopedLocalSig = serializeScopeLocalSignature(idSignature) diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt index 434cae774d3..1cbd18ff6bc 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt @@ -128,7 +128,7 @@ class IrModuleDeserializerWithBuiltIns( val className = fqnParts.firstOrNull() ?: error("Expected class name for $idSig") val functionDescriptor = computeFunctionDescriptor(className) - val topLevelSignature = IdSignature.PublicSignature(publicSig.packageFqName, className, null, publicSig.mask) + val topLevelSignature = IdSignature.CommonSignature(publicSig.packageFqName, className, null, publicSig.mask) val functionClass = when (functionDescriptor.functionKind) { FunctionClassKind.KSuspendFunction -> functionFactory.kSuspendFunctionN(functionDescriptor.arity) { callback -> diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrSymbolDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrSymbolDeserializer.kt index 088523ac3e9..c64a9b049ba 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrSymbolDeserializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrSymbolDeserializer.kt @@ -129,18 +129,18 @@ class IrSymbolDeserializer( val cls = fileReader.deserializeFqName(proto.declarationFqNameList) val memberId = if (proto.hasMemberUniqId()) proto.memberUniqId else null - return IdSignature.PublicSignature(pkg, cls, memberId, proto.flags) + return IdSignature.CommonSignature(pkg, cls, memberId, proto.flags) } private fun deserializeAccessorIdSignature(proto: ProtoAccessorIdSignature): IdSignature.AccessorSignature { val propertySignature = deserializeIdSignature(proto.propertySignature) - require(propertySignature is IdSignature.PublicSignature) { "For public accessor corresponding property supposed to be public as well" } + require(propertySignature is IdSignature.CommonSignature) { "For public accessor corresponding property supposed to be public as well" } val name = fileReader.deserializeString(proto.name) val hash = proto.accessorHashId val mask = proto.flags val accessorSignature = - IdSignature.PublicSignature(propertySignature.packageFqName, "${propertySignature.declarationFqName}.$name", hash, mask) + IdSignature.CommonSignature(propertySignature.packageFqName, "${propertySignature.declarationFqName}.$name", hash, mask) return IdSignature.AccessorSignature(propertySignature, accessorSignature) } diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt index fd46fd7cdc0..0c6caa28ab7 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt @@ -39,10 +39,10 @@ abstract class IdSignatureBuilder { return IdSignature.SpecialFakeOverrideSignature(memberSignature, overriddenSignatures) } hashIdAcc == null -> { - IdSignature.PublicSignature(packageFqName, classFqName, hashId, mask) + IdSignature.CommonSignature(packageFqName, classFqName, hashId, mask) } else -> { - val accessorSignature = IdSignature.PublicSignature(packageFqName, classFqName, hashIdAcc, mask) + val accessorSignature = IdSignature.CommonSignature(packageFqName, classFqName, hashIdAcc, mask) hashIdAcc = null classFqnSegments.run { removeAt(lastIndex) } val propertySignature = build() diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt index ae948401462..14de5007237 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt @@ -42,7 +42,7 @@ private val objCConstructorFqName = FqName("kotlinx.cinterop.ObjCConstructor") private val objCFactoryFqName = interopPackageName.child(Name.identifier("ObjCFactory")) private val objcnamesForwardDeclarationsPackageName = Name.identifier("objcnames") -private fun getTopLevelPublicSignature(fqName: FqName): IdSignature.PublicSignature = +private fun getTopLevelPublicSignature(fqName: FqName): IdSignature.CommonSignature = getPublicSignature(fqName.parent(), fqName.shortName().asString()) fun ClassDescriptor.isObjCClass(): Boolean = diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt index a7c2df26a3d..fd49cc1af23 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol -import org.jetbrains.kotlin.ir.symbols.isPublicApi import org.jetbrains.kotlin.ir.types.IdSignatureValues import org.jetbrains.kotlin.ir.types.classifierOrFail import org.jetbrains.kotlin.ir.types.isMarkedNullable @@ -36,8 +35,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.safeAs -private fun IrClass.isClassTypeWithSignature(signature: IdSignature.PublicSignature): Boolean { - if (!symbol.isPublicApi) return false +private fun IrClass.isClassTypeWithSignature(signature: IdSignature.CommonSignature): Boolean { return signature == symbol.signature } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt index d7c88d65325..b2780f5b0b0 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt @@ -188,8 +188,10 @@ internal class RTTIGenerator(override val context: Context) : ContextUtils { vector128Type to 10 ) - private fun getElementType(irClass: IrClass): LLVMTypeRef? = - if (irClass.symbol.isPublicApi) arrayClasses[irClass.symbol.signature as IdSignature.PublicSignature] else null + private fun getElementType(irClass: IrClass): LLVMTypeRef? { + val signature = irClass.symbol.signature as? IdSignature.CommonSignature? + return signature?.let { arrayClasses[it] } + } private fun getInstanceSize(classType: LLVMTypeRef?, irClass: IrClass) : Int { val elementType = getElementType(irClass) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrlinker.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrlinker.kt index e1db08bb25b..624789319dd 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrlinker.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrlinker.kt @@ -190,7 +190,7 @@ internal class KonanIrLinker( override fun contains(idSig: IdSignature): Boolean = idSig.isForwardDeclarationSignature() private fun resolveDescriptor(idSig: IdSignature): ClassDescriptor = - with(idSig as IdSignature.PublicSignature) { + with(idSig as IdSignature.CommonSignature) { val classId = ClassId(packageFqName(), FqName(declarationFqName), false) moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: error("No declaration found with $idSig") }