[IR] Rename PublicSignature -> CommonSignature

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 + ".<set-${property.name.asString()}>"
         } else {
             propertySignature.declarationFqName + ".<get-${property.name.asString()}>"
         }
-        return IdSignature.PublicSignature(propertySignature.packageFqName, accessorFqName, propertySignature.id, propertySignature.mask)
+        return IdSignature.CommonSignature(propertySignature.packageFqName, accessorFqName, propertySignature.id, propertySignature.mask)
     }
 }

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

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

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.isNotNullClassType(signature: IdSignature.CommonSignature) = isClassType(signature, hasQuestionMark = false)
-private fun IrType.isNullableClassType(signature: IdSignature.PublicSignature) = isClassType(signature, hasQuestionMark = true)
+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<IdSignature.PublicSignature, PrimitiveType> =
+private val idSignatureToPrimitiveType: Map<IdSignature.CommonSignature, PrimitiveType> =
     PrimitiveType.values().associateBy {
         getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, it.typeName.asString())
     }
 
-val primitiveArrayTypesSignatures: Map<PrimitiveType, IdSignature.PublicSignature> =
+val primitiveArrayTypesSignatures: Map<PrimitiveType, IdSignature.CommonSignature> =
     PrimitiveType.values().associateWith {
         getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "${it.typeName.asString()}Array")
     }

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() }

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>
     ) : IdSignature() {
-        override val isPublic: Boolean
+        override val isPubliclyVisible: Boolean
-            get() = memberSignature.isPublic
+            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() {
+    class FileLocalSignature(val container: IdSignature, val id: Long, val description: String? = null) : IdSignature() {
-        override val isPublic: Boolean get() = false
+        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)
 }

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 }

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)

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

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

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt

@@ -39,10 +39,10 @@ abstract class IdSignatureBuilder<D> {
                 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()

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 =

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 {
+private fun IrClass.isClassTypeWithSignature(signature: IdSignature.CommonSignature): Boolean {
-    if (!symbol.isPublicApi) return false
     return signature == symbol.signature
 }
 

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? =
+    private fun getElementType(irClass: IrClass): LLVMTypeRef? {
-            if (irClass.symbol.isPublicApi) arrayClasses[irClass.symbol.signature as IdSignature.PublicSignature] else null
+        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)

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")
             }