Fir: simplify IrBuiltInsOverFir

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt

@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
+import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
-import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 
 fun FirSession.convertToIr(
     scopeSession: ScopeSession,
@@ -42,7 +42,7 @@ fun FirSession.convertToIr(
         this, scopeSession, firFiles + commonFirFiles,
         languageVersionSettings, signaturer,
         fir2IrExtensions,
-        FirJvmKotlinMangler(this), IrFactoryImpl,
+        FirJvmKotlinMangler(this), JvmIrMangler, IrFactoryImpl,
         FirJvmVisibilityConverter,
         Fir2IrJvmSpecialAnnotationSymbolProvider(),
         irGeneratorExtensions

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt

@@ -422,6 +422,7 @@ class Fir2IrConverter(
             signaturer: IdSignatureComposer,
             fir2IrExtensions: Fir2IrExtensions,
             mangler: FirMangler,
+            irMangler: KotlinMangler.IrMangler,
             irFactory: IrFactory,
             visibilityConverter: Fir2IrVisibilityConverter,
             specialSymbolProvider: Fir2IrSpecialSymbolProvider?,
@@ -446,7 +447,7 @@ class Fir2IrConverter(
             components.typeConverter = typeConverter
             val irBuiltIns =
                 IrBuiltInsOverFir(
-                    components, languageVersionSettings, moduleDescriptor,
+                    components, languageVersionSettings, moduleDescriptor, irMangler,
                     languageVersionSettings.getFlag(AnalysisFlags.builtInsFromSources)
                 )
             components.irBuiltIns = irBuiltIns

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.backend.common.ir.addDispatchReceiver
+import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.builtins.UnsignedType
 import org.jetbrains.kotlin.config.LanguageVersionSettings
@@ -44,6 +45,7 @@ class IrBuiltInsOverFir(
     private val components: Fir2IrComponents,
     override val languageVersionSettings: LanguageVersionSettings,
     private val moduleDescriptor: FirModuleDescriptor,
+    irMangler: KotlinMangler.IrMangler,
     private val tryLoadBuiltInsFirst: Boolean = false
 ) : IrBuiltIns() {
 
@@ -56,6 +58,8 @@ class IrBuiltInsOverFir(
     private val kotlinIrPackage = createPackage(kotlinPackage)
     private val kotlinInternalIrPackage = createPackage(kotlinInternalPackage)
 
+    private val irSignatureBuilder = PublicIdSignatureComputer(irMangler)
+
     override val booleanNotSymbol: IrSimpleFunctionSymbol by lazy {
         boolean.ensureLazyContentsCreated()
         booleanClass.owner.functions.first { it.name == OperatorNameConventions.NOT && it.returnType == booleanType }.symbol
@@ -384,9 +388,12 @@ class IrBuiltInsOverFir(
                 isIntrinsicConst: Boolean = false,
                 builder: IrSimpleFunction.() -> Unit = {}
             ) =
-                createFunction(fqName, name, returnType, valueParameterTypes, origin = BUILTIN_OPERATOR, isIntrinsicConst = isIntrinsicConst).also {
+                createFunction(name, returnType, valueParameterTypes, origin = BUILTIN_OPERATOR, isIntrinsicConst = isIntrinsicConst).also {
                     declarations.add(it)
                     it.builder()
+                }.also {
+                    it.parent = operatorsPackageFragment
+                    components.symbolTable.declareSimpleFunctionWithSignature(irSignatureBuilder.computeSignature(it), it.symbol)
                 }.symbol
 
             primitiveFloatingPointIrTypes.forEach { fpType ->
@@ -424,7 +431,7 @@ class IrBuiltInsOverFir(
                 }
 
                 createFunction(
-                    fqName, "CHECK_NOT_NULL",
+                    "CHECK_NOT_NULL",
                     IrSimpleTypeImpl(typeParameter.symbol, SimpleTypeNullability.DEFINITELY_NOT_NULL, emptyList(), emptyList()),
                     arrayOf("" to IrSimpleTypeImpl(typeParameter.symbol, hasQuestionMark = true, emptyList(), emptyList())),
                     origin = BUILTIN_OPERATOR
@@ -432,6 +439,8 @@ class IrBuiltInsOverFir(
                     it.typeParameters = listOf(typeParameter)
                     typeParameter.parent = it
                     declarations.add(it)
+                    it.parent = operatorsPackageFragment
+                    components.symbolTable.declareSimpleFunctionWithSignature(irSignatureBuilder.computeSignature(it), it.symbol)
                 }.symbol
             }
 
@@ -518,9 +527,11 @@ class IrBuiltInsOverFir(
             vararg argumentTypes: Pair<String, IrType>,
             builder: IrSimpleFunction.() -> Unit
         ) =
-            owner.createFunction(kotlinPackage, name, returnType, argumentTypes).also {
+            owner.createFunction(name, returnType, argumentTypes).also {
                 it.builder()
                 this.owner.declarations.add(it)
+                it.parent = kotlinIrPackage
+                components.symbolTable.declareSimpleFunctionWithSignature(irSignatureBuilder.computeSignature(it), it.symbol)
             }.symbol
 
         val kotlinKt = kotlinIrPackage.createClass(kotlinPackage.child(Name.identifier("KotlinKt")))
@@ -695,6 +706,7 @@ class IrBuiltInsOverFir(
                     }.also {
                         it.parent = parent
                         it.createImplicitParameterDeclarationWithWrappedDescriptor()
+                        components.symbolTable.declareClassWithSignature(irSignatureBuilder.computeSignature(it), it.symbol)
                     }
                 }
             ).symbol)
@@ -728,7 +740,7 @@ class IrBuiltInsOverFir(
         builderBlock: IrClassBuilder.() -> Unit = {},
         block: IrClass.() -> Unit = {}
     ): IrClassSymbol {
-        val signature = IdSignature.CommonSignature(fqName.parent().asString(), fqName.shortName().asString(), null, 0)
+        val signature = getPublicSignature(fqName.parent(), fqName.shortName().asString())
 
         return this.createClass(
             signature, *supertypes,
@@ -773,15 +785,16 @@ class IrBuiltInsOverFir(
         build: IrConstructor.() -> Unit = {}
     ): IrConstructorSymbol {
         val name = SpecialNames.INIT
-        val signature =
-            IdSignature.CommonSignature(this.packageFqName!!.asString(), classId!!.relativeClassName.child(name).asString(), null, 0)
         val ctor = irFactory.createConstructor(
-            UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, IrConstructorPublicSymbolImpl(signature), name, visibility, defaultType,
+            UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, IrConstructorSymbolImpl(), name, visibility, defaultType,
             isInline = false, isExternal = false, isPrimary = isPrimary, isExpect = false
         )
         ctor.parent = this
         ctor.build()
         declarations.add(ctor)
+        components.symbolTable.declareConstructorWithSignature(
+            irSignatureBuilder.computeSignature(ctor), ctor.symbol
+        )
         return ctor.symbol
     }
 
@@ -802,12 +815,6 @@ class IrBuiltInsOverFir(
         isIntrinsicConst: Boolean = true,
         build: IrFunctionBuilder.() -> Unit = {}
     ) = parent.createFunction(
-        IdSignature.CommonSignature(
-            this.packageFqName!!.asString(),
-            classId!!.relativeClassName.child(Name.identifier(name)).asString(),
-            null,
-            0
-        ),
         name, returnType, valueParameterTypes, origin, modality, isOperator, isIntrinsicConst, build
     ).also { fn ->
         fn.addDispatchReceiver { type = this@createMemberFunction.defaultType }
@@ -828,6 +835,9 @@ class IrBuiltInsOverFir(
                 fn.overriddenSymbols += it.symbol
             }
         }
+        components.symbolTable.declareSimpleFunctionWithSignature(
+            irSignatureBuilder.computeSignature(fn), fn.symbol
+        )
     }
 
     private fun IrClass.createMemberFunction(
@@ -860,7 +870,6 @@ class IrBuiltInsOverFir(
     }
 
     private fun IrDeclarationParent.createFunction(
-        signature: IdSignature,
         name: String,
         returnType: IrType,
         valueParameterTypes: Array<out Pair<String, IrType>>,
@@ -869,41 +878,23 @@ class IrBuiltInsOverFir(
         isOperator: Boolean = false,
         isIntrinsicConst: Boolean = false,
         build: IrFunctionBuilder.() -> Unit = {}
-    ) = IrFunctionBuilder().run {
+    ) = irFactory.buildFun {
         this.name = Name.identifier(name)
         this.returnType = returnType
         this.origin = origin
         this.modality = modality
         this.isOperator = isOperator
         build()
-        irFactory.createFunction(
+    }.also { fn ->
-            startOffset, endOffset, origin, IrSimpleFunctionPublicSymbolImpl(signature), this.name, visibility, modality, this.returnType,
+        valueParameterTypes.forEachIndexed { index, (pName, irType) ->
-            isInline, isExternal, isTailrec, isSuspend, isOperator, isInfix, isExpect, isFakeOverride, containerSource,
+            fn.addValueParameter(Name.identifier(pName.ifBlank { "arg$index" }), irType, origin)
-        ).also { fn ->
-            valueParameterTypes.forEachIndexed { index, (pName, irType) ->
-                fn.addValueParameter(Name.identifier(pName.ifBlank { "arg$index" }), irType, origin)
-            }
-            if (isIntrinsicConst) {
-                fn.annotations += intrinsicConstAnnotation
-            }
-            fn.parent = this@createFunction
         }
+        if (isIntrinsicConst) {
+            fn.annotations += intrinsicConstAnnotation
+        }
+        fn.parent = this@createFunction
     }
 
-    private fun IrDeclarationParent.createFunction(
-        packageFqName: FqName,
-        name: String,
-        returnType: IrType,
-        valueParameterTypes: Array<out Pair<String, IrType>>,
-        origin: IrDeclarationOrigin = IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB,
-        modality: Modality = Modality.FINAL,
-        isOperator: Boolean = false,
-        isIntrinsicConst: Boolean = false
-    ) = createFunction(
-        IdSignature.CommonSignature(packageFqName.asString(), name, null, 0),
-        name, returnType, valueParameterTypes, origin, modality, isOperator, isIntrinsicConst
-    )
-
     private fun IrClass.addArrayMembers(elementType: IrType) {
         addConstructor {
             origin = object : IrDeclarationOriginImpl("BUILTIN_CLASS_CONSTRUCTOR") {}
@@ -1042,7 +1033,7 @@ class IrBuiltInsOverFir(
     ) =
         createClass(
             parent,
-            IdSignature.CommonSignature(parent.kotlinFqName.asString(), primitiveType.arrayTypeName.asString(), null, 0),
+            getPublicSignature(parent.kotlinFqName, primitiveType.arrayTypeName.asString()),
             build = { modality = Modality.FINAL }
         ) {
             configureSuperTypes()

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -55,6 +55,7 @@ import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.multiproject.ModulesApiHistory
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
+import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.load.java.JavaClassesTracker
@@ -279,7 +280,7 @@ class IncrementalFirJvmCompilerRunner(
             val (irModuleFragment, components) = Fir2IrConverter.createModuleFragment(
                 cycleResult.session, cycleResult.scopeSession, cycleResult.fir + allCommonFirFiles,
                 cycleResult.session.languageVersionSettings, signaturer,
-                extensions, FirJvmKotlinMangler(cycleResult.session), IrFactoryImpl,
+                extensions, FirJvmKotlinMangler(cycleResult.session), JvmIrMangler, IrFactoryImpl,
                 FirJvmVisibilityConverter,
                 Fir2IrJvmSpecialAnnotationSymbolProvider(),
                 irGenerationExtensions

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt

@@ -459,6 +459,10 @@ open class SymbolTable(
         )
     }
 
+    fun declareClassWithSignature(sig: IdSignature, symbol: IrClassSymbol) {
+        classSymbolTable.set(sig, symbol)
+    }
+
     fun declareClassIfNotExists(descriptor: ClassDescriptor, classFactory: (IrClassSymbol) -> IrClass): IrClass =
         classSymbolTable.declareIfNotExists(descriptor, { signature -> createClassSymbol(descriptor, signature) }, classFactory)
 
@@ -846,6 +850,10 @@ open class SymbolTable(
         }
     }
 
+    fun declareSimpleFunctionWithSignature(sig: IdSignature, symbol: IrSimpleFunctionSymbol) {
+        simpleFunctionSymbolTable.set(sig, symbol)
+    }
+
     override fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol =
         simpleFunctionSymbolTable.referenced(descriptor) { signature -> createSimpleFunctionSymbol(descriptor, signature) }
 

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirAnalyzerFacade.kt

@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
+import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.sourceFiles.LightTreeFile
 
 abstract class AbstractFirAnalyzerFacade {
@@ -114,7 +114,7 @@ class FirAnalyzerFacade(
             session, _scopeSession!!, firFiles!! + commonFirFiles,
             languageVersionSettings, signaturer,
             fir2IrExtensions,
-            FirJvmKotlinMangler(session), IrFactoryImpl,
+            FirJvmKotlinMangler(session), JvmIrMangler, IrFactoryImpl,
             FirJvmVisibilityConverter,
             Fir2IrJvmSpecialAnnotationSymbolProvider(),
             irGeneratorExtensions