Move out symbols that do not depend on a BackendContext to a separate BuiltinSymbolsBase class.

The goal was to be able to use such symbols before BackendContext is even created – in psi2ir postprocessing step (i.e., IR compiler plugins).

Remove old code from serialization ir plugin.

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/extensions/IrGenerationExtension.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.backend.common.extensions
 
+import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
@@ -21,8 +22,9 @@ class IrPluginContext(
     val languageVersionSettings: LanguageVersionSettings,
     val symbolTable: SymbolTable,
     val typeTranslator: TypeTranslator,
-    override val irBuiltIns: IrBuiltIns
+    override val irBuiltIns: IrBuiltIns,
-): IrGeneratorContext()
+    val symbols: BuiltinSymbolsBase = BuiltinSymbolsBase(irBuiltIns.builtIns, symbolTable)
+) : IrGeneratorContext()
 
 interface IrGenerationExtension {
     companion object :

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt

@@ -44,16 +44,14 @@ abstract class Ir<out T : CommonBackendContext>(val context: T, val irModule: Ir
     open fun shouldGenerateHandlerParameterForDefaultBodyFun() = false
 }
 
-// Some symbols below are used in kotlin-native, so they can't be private
+/**
-@Suppress("MemberVisibilityCanBePrivate", "PropertyName")
+ * Symbols for builtins that are available without any context and are not specific to any backend
-abstract class Symbols<out T : CommonBackendContext>(val context: T, private val symbolTable: ReferenceSymbolTable) {
+ */
-
+open class BuiltinSymbolsBase(protected val builtIns: KotlinBuiltIns, private val symbolTable: ReferenceSymbolTable) {
-    protected val builtIns
-        get() = context.builtIns
-
     protected fun builtInsPackage(vararg packageNameSegments: String) =
-        context.builtIns.builtInsModule.getPackage(FqName.fromSegments(listOf(*packageNameSegments))).memberScope
+        builtIns.builtInsModule.getPackage(FqName.fromSegments(listOf(*packageNameSegments))).memberScope
 
+    // consider making this public so it can be used to easily locate stdlib functions from any place (in particular, plugins and lowerings)
     private fun getSimpleFunction(
         name: Name,
         vararg packageNameSegments: String = arrayOf("kotlin"),
@@ -75,16 +73,6 @@ abstract class Symbols<out T : CommonBackendContext>(val context: T, private val
     open val externalSymbolTable: ReferenceSymbolTable
         get() = symbolTable
 
-    abstract val ThrowNullPointerException: IrFunctionSymbol
-    abstract val ThrowNoWhenBranchMatchedException: IrFunctionSymbol
-    abstract val ThrowTypeCastException: IrFunctionSymbol
-
-    abstract val ThrowUninitializedPropertyAccessException: IrSimpleFunctionSymbol
-
-    abstract val stringBuilder: IrClassSymbol
-
-    abstract val defaultConstructorMarker: IrClassSymbol
-
     val iterator = getClass(Name.identifier("Iterator"), "kotlin", "collections")
 
     val charSequence = getClass(Name.identifier("CharSequence"), "kotlin")
@@ -186,22 +174,6 @@ abstract class Symbols<out T : CommonBackendContext>(val context: T, private val
     val mutableIterator = symbolTable.referenceClass(builtIns.mutableIterator)
     val mutableListIterator = symbolTable.referenceClass(builtIns.mutableListIterator)
 
-    abstract val copyRangeTo: Map<ClassDescriptor, IrSimpleFunctionSymbol>
-
-    abstract val coroutineImpl: IrClassSymbol
-
-    abstract val coroutineSuspendedGetter: IrSimpleFunctionSymbol
-
-    abstract val getContinuation: IrSimpleFunctionSymbol
-
-    abstract val coroutineContextGetter: IrSimpleFunctionSymbol
-
-    abstract val suspendCoroutineUninterceptedOrReturn: IrSimpleFunctionSymbol
-
-    abstract val coroutineGetContext: IrSimpleFunctionSymbol
-
-    abstract val returnIfSuspended: IrSimpleFunctionSymbol
-
     private val binaryOperatorCache = mutableMapOf<Triple<Name, KotlinType, KotlinType>, IrSimpleFunctionSymbol>()
 
     fun getBinaryOperator(name: Name, lhsType: KotlinType, rhsType: KotlinType): IrSimpleFunctionSymbol {
@@ -250,6 +222,37 @@ abstract class Symbols<out T : CommonBackendContext>(val context: T, private val
                 KotlinBuiltIns.isStringOrNullableString(it.extensionReceiverParameter!!.type) && it.valueParameters.size == 1 &&
                 KotlinBuiltIns.isNullableAny(it.valueParameters.first().type)
     }
+}
+
+// Some symbols below are used in kotlin-native, so they can't be private
+@Suppress("MemberVisibilityCanBePrivate", "PropertyName")
+abstract class Symbols<out T : CommonBackendContext>(val context: T, symbolTable: ReferenceSymbolTable) :
+    BuiltinSymbolsBase(context.builtIns, symbolTable) {
+    abstract val ThrowNullPointerException: IrFunctionSymbol
+    abstract val ThrowNoWhenBranchMatchedException: IrFunctionSymbol
+    abstract val ThrowTypeCastException: IrFunctionSymbol
+
+    abstract val ThrowUninitializedPropertyAccessException: IrSimpleFunctionSymbol
+
+    abstract val stringBuilder: IrClassSymbol
+
+    abstract val defaultConstructorMarker: IrClassSymbol
+
+    abstract val copyRangeTo: Map<ClassDescriptor, IrSimpleFunctionSymbol>
+
+    abstract val coroutineImpl: IrClassSymbol
+
+    abstract val coroutineSuspendedGetter: IrSimpleFunctionSymbol
+
+    abstract val getContinuation: IrSimpleFunctionSymbol
+
+    abstract val coroutineContextGetter: IrSimpleFunctionSymbol
+
+    abstract val suspendCoroutineUninterceptedOrReturn: IrSimpleFunctionSymbol
+
+    abstract val coroutineGetContext: IrSimpleFunctionSymbol
+
+    abstract val returnIfSuspended: IrSimpleFunctionSymbol
 
     companion object {
         fun isLateinitIsInitializedPropertyGetter(symbol: IrFunctionSymbol): Boolean =

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.backend.common.deepCopyWithVariables
 import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrPropertyImpl
@@ -26,9 +25,7 @@ import org.jetbrains.kotlin.ir.types.toKotlinType
 import org.jetbrains.kotlin.ir.types.typeWith
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.calls.components.isVararg
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.isTypeParameter
@@ -41,18 +38,14 @@ import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.*
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
 import org.jetbrains.kotlinx.serialization.compiler.resolve.*
 
-val SerializationPluginContext.externalSymbols: SymbolTable get() = symbolTable // Todo: deprecate and remove
-val SerializationPluginContext.localSymbolTable: SymbolTable get() = symbolTable // Todo: deprecate and remove
-
 interface IrBuilderExtension {
     val compilerContext: SerializationPluginContext
-    val translator: TypeTranslator get() = compilerContext.typeTranslator // Todo: deprecate and remove
 
     private fun IrClass.declareSimpleFunctionWithExternalOverrides(descriptor: FunctionDescriptor): IrSimpleFunction {
-        return compilerContext.localSymbolTable.declareSimpleFunction(startOffset, endOffset, SERIALIZABLE_PLUGIN_ORIGIN, descriptor)
+        return compilerContext.symbolTable.declareSimpleFunction(startOffset, endOffset, SERIALIZABLE_PLUGIN_ORIGIN, descriptor)
             .also { f ->
                 descriptor.overriddenDescriptors.mapTo(f.overriddenSymbols) {
-                    compilerContext.externalSymbols.referenceSimpleFunction(it.original)
+                    compilerContext.symbolTable.referenceSimpleFunction(it.original)
                 }
             }
     }
@@ -64,7 +57,7 @@ interface IrBuilderExtension {
     ) {
         val f: IrSimpleFunction = if (declareNew) declareSimpleFunctionWithExternalOverrides(
             descriptor
-        ) else compilerContext.externalSymbols.referenceSimpleFunction(descriptor).owner
+        ) else compilerContext.symbolTable.referenceSimpleFunction(descriptor).owner
         f.parent = this
         f.returnType = descriptor.returnType!!.toIrType()
         if (declareNew) f.createParameterDeclarations(this.thisReceiver!!)
@@ -78,12 +71,12 @@ interface IrBuilderExtension {
         overwriteValueParameters: Boolean = false,
         bodyGen: IrBlockBodyBuilder.(IrConstructor) -> Unit
     ) {
-        val c = if (declareNew) compilerContext.localSymbolTable.declareConstructor(
+        val c = if (declareNew) compilerContext.symbolTable.declareConstructor(
             this.startOffset,
             this.endOffset,
             SERIALIZABLE_PLUGIN_ORIGIN,
             descriptor
-        ) else compilerContext.externalSymbols.referenceConstructor(descriptor).owner
+        ) else compilerContext.symbolTable.referenceConstructor(descriptor).owner
         c.parent = this
         c.returnType = descriptor.returnType.toIrType()
         if (declareNew || overwriteValueParameters) c.createParameterDeclarations(
@@ -122,44 +115,25 @@ interface IrBuilderExtension {
             typeHint = returnTypeHint
         ).also { call -> typeArguments.forEachIndexed(call::putTypeArgument) }
 
-    // todo: remove copypasta
-
-    private fun SerializationPluginContext.builtInsPackage(vararg packageNameSegments: String) =
-        builtIns.builtInsModule.getPackage(FqName.fromSegments(listOf(*packageNameSegments))).memberScope
-
-    private fun SerializationPluginContext.getSimpleFunction(
-        name: Name,
-        vararg packageNameSegments: String = arrayOf("kotlin"),
-        condition: (SimpleFunctionDescriptor) -> Boolean
-    ): IrSimpleFunctionSymbol =
-        symbolTable.referenceSimpleFunction(
-            builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
-                .first(condition)
-        )
-
-
     fun IrBuilderWithScope.createArrayOfExpression(
         arrayElementType: IrType,
         arrayElements: List<IrExpression>
     ): IrExpression {
 
-        val arrayType = context.irBuiltIns.arrayClass.typeWith(arrayElementType)
+        val arrayType = compilerContext.symbols.array.typeWith(arrayElementType)
         val arg0 = IrVarargImpl(startOffset, endOffset, arrayType, arrayElementType, arrayElements)
         val typeArguments = listOf(arrayElementType)
 
-        val arrayOf = compilerContext.getSimpleFunction(Name.identifier("arrayOf")) {
+        return irCall(compilerContext.symbols.arrayOf, arrayType, typeArguments = typeArguments).apply {
-            it.extensionReceiverParameter == null && it.dispatchReceiverParameter == null && it.valueParameters.size == 1 &&
-                    it.valueParameters[0].isVararg
-        }
-        return irCall(arrayOf, arrayType, typeArguments = typeArguments).apply {
             putValueArgument(0, arg0)
         }
     }
 
     fun IrBuilderWithScope.irBinOp(name: Name, lhs: IrExpression, rhs: IrExpression): IrExpression {
-        val symbol = compilerContext.symbolTable.referenceSimpleFunction(
+        val symbol = compilerContext.symbols.getBinaryOperator(
-            lhs.type.toKotlinType().memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
+            name,
-                .first { it.valueParameters.size == 1 && it.valueParameters[0].type == rhs.type.toKotlinType() }
+            lhs.type.toKotlinType(),
+            rhs.type.toKotlinType()
         )
         return irInvoke(lhs, symbol, rhs)
     }
@@ -169,7 +143,7 @@ interface IrBuilderExtension {
             startOffset,
             endOffset,
             classDescriptor.defaultType.toIrType(),
-            compilerContext.externalSymbols.referenceClass(classDescriptor)
+            compilerContext.symbolTable.referenceClass(classDescriptor)
         )
 
     fun IrBuilderWithScope.irGetObject(irObject: IrClass) =
@@ -182,7 +156,7 @@ interface IrBuilderExtension {
 
     fun <T : IrDeclaration> T.buildWithScope(builder: (T) -> Unit): T =
         also { irDeclaration ->
-            compilerContext.localSymbolTable.withScope(irDeclaration.descriptor) {
+            compilerContext.symbolTable.withScope(irDeclaration.descriptor) {
                 builder(irDeclaration)
             }
         }
@@ -220,13 +194,9 @@ interface IrBuilderExtension {
             result
         )
 
-    fun translateType(ktType: KotlinType): IrType =
+    fun KotlinType.toIrType() = compilerContext.typeTranslator.translateType(this)
-        translator.translateType(ktType)
 
-    fun KotlinType.toIrType() = translateType(this)
+    val SerializableProperty.irField: IrField get() = compilerContext.symbolTable.referenceField(this.descriptor).owner
-
-
-    val SerializableProperty.irField: IrField get() = compilerContext.externalSymbols.referenceField(this.descriptor).owner
 
     /*
      The rest of the file is mainly copied from FunctionGenerator.
@@ -241,7 +211,7 @@ interface IrBuilderExtension {
             +IrDelegatingConstructorCallImpl(
                 startOffset, endOffset,
                 compilerContext.irBuiltIns.unitType,
-                compilerContext.externalSymbols.referenceConstructor(anyConstructor)
+                compilerContext.symbolTable.referenceConstructor(anyConstructor)
             )
         }
     }
@@ -273,7 +243,7 @@ interface IrBuilderExtension {
         propertyDescriptor: PropertyDescriptor,
         originProperty: IrProperty
     ): IrField {
-        return compilerContext.localSymbolTable.declareField(
+        return compilerContext.symbolTable.declareField(
             originProperty.startOffset,
             originProperty.endOffset,
             SERIALIZABLE_PLUGIN_ORIGIN,
@@ -286,9 +256,9 @@ interface IrBuilderExtension {
         descriptor: PropertyAccessorDescriptor,
         fieldSymbol: IrFieldSymbol
     ): IrSimpleFunction {
-        val declaration = compilerContext.externalSymbols.declareSimpleFunctionWithOverrides(fieldSymbol.owner.startOffset,
+        val declaration = compilerContext.symbolTable.declareSimpleFunctionWithOverrides(fieldSymbol.owner.startOffset,
-                                                                                 fieldSymbol.owner.endOffset,
+                                                                                         fieldSymbol.owner.endOffset,
-                                                                                 SERIALIZABLE_PLUGIN_ORIGIN,descriptor)
+                                                                                         SERIALIZABLE_PLUGIN_ORIGIN, descriptor)
         return declaration.buildWithScope { irAccessor ->
             irAccessor.createParameterDeclarations(receiver = null)
             irAccessor.returnType = irAccessor.descriptor.returnType!!.toIrType()
@@ -318,7 +288,7 @@ interface IrBuilderExtension {
                 irAccessor.symbol,
                 IrGetFieldImpl(
                     startOffset, endOffset,
-                    compilerContext.localSymbolTable.referenceField(property),
+                    compilerContext.symbolTable.referenceField(property),
                     property.type.toIrType(),
                     receiver
                 )
@@ -343,7 +313,7 @@ interface IrBuilderExtension {
         irBody.statements.add(
             IrSetFieldImpl(
                 startOffset, endOffset,
-                compilerContext.localSymbolTable.referenceField(property),
+                compilerContext.symbolTable.referenceField(property),
                 receiver,
                 IrGetValueImpl(startOffset, endOffset, irValueParameter.type, irValueParameter.symbol),
                 compilerContext.irBuiltIns.unitType
@@ -361,7 +331,6 @@ interface IrBuilderExtension {
             is ClassDescriptor ->
                 IrGetValueImpl(
                     ownerSymbol.owner.startOffset, ownerSymbol.owner.endOffset,
-//                symbolTable.referenceValue(containingDeclaration.thisAsReceiverParameter)
                     ownerSymbol
                 )
             else -> throw AssertionError("Property must be in class")
@@ -421,7 +390,7 @@ interface IrBuilderExtension {
             startOffset,
             endOffset,
             returnType.toIrType(),
-            compilerContext.externalSymbols.referenceClassifier(clazz),
+            compilerContext.symbolTable.referenceClassifier(clazz),
             classType.toIrType()
         )
     }
@@ -449,7 +418,7 @@ interface IrBuilderExtension {
 
     fun findEnumValuesMethod(enumClass: ClassDescriptor): IrFunction {
         assert(enumClass.kind == ClassKind.ENUM_CLASS)
-        return compilerContext.externalSymbols.referenceClass(enumClass).owner.functions
+        return compilerContext.symbolTable.referenceClass(enumClass).owner.functions
             .find { it.origin == IrDeclarationOrigin.ENUM_CLASS_SPECIAL_MEMBER && it.name == Name.identifier("values") }
             ?: throw AssertionError("Enum class does not have .values() function")
     }
@@ -469,7 +438,7 @@ interface IrBuilderExtension {
         property: SerializableProperty
     ): IrExpression? {
         val nullableSerClass =
-            compilerContext.externalSymbols.referenceClass(property.module.getClassFromInternalSerializationPackage(SpecialBuiltins.nullableSerializer))
+            compilerContext.symbolTable.referenceClass(property.module.getClassFromInternalSerializationPackage(SpecialBuiltins.nullableSerializer))
         val serializer =
             property.serializableWith?.toClassDescriptor
                 ?: if (!property.type.isTypeParameter()) generator.findTypeSerializerOrContext(
@@ -508,7 +477,7 @@ interface IrBuilderExtension {
 
     fun wrapIrTypeIntoKSerializerIrType(module: ModuleDescriptor, type: IrType, variance: Variance = Variance.INVARIANT): IrType {
         val kSerClass =
-            compilerContext.externalSymbols.referenceClass(module.getClassFromSerializationPackage(SerialEntityNames.KSERIALIZER_CLASS))
+            compilerContext.symbolTable.referenceClass(module.getClassFromSerializationPackage(SerialEntityNames.KSERIALIZER_CLASS))
         return IrSimpleTypeImpl(
             kSerClass, hasQuestionMark = false, arguments = listOf(
                 makeTypeProjection(type, variance)
@@ -531,7 +500,7 @@ interface IrBuilderExtension {
         genericIndex
     ) { it, _ ->
         val prop = enclosingGenerator.localSerializersFieldsDescriptors[it]
-        irGetField(irGet(dispatchReceiverParameter), compilerContext.localSymbolTable.referenceField(prop).owner)
+        irGetField(irGet(dispatchReceiverParameter), compilerContext.symbolTable.referenceField(prop).owner)
     }
 
     fun IrBuilderWithScope.serializerInstance(
@@ -543,7 +512,7 @@ interface IrBuilderExtension {
         genericGetter: ((Int, KotlinType) -> IrExpression)? = null
     ): IrExpression? {
         val nullableSerClass =
-            compilerContext.externalSymbols.referenceClass(module.getClassFromInternalSerializationPackage(SpecialBuiltins.nullableSerializer))
+            compilerContext.symbolTable.referenceClass(module.getClassFromInternalSerializationPackage(SpecialBuiltins.nullableSerializer))
         if (serializerClassOriginal == null) {
             if (genericIndex == null) return null
             return genericGetter?.invoke(genericIndex, kType)
@@ -656,9 +625,9 @@ interface IrBuilderExtension {
                 requireNotNull(
                     findSerializerConstructorForTypeArgumentsSerializers(serializerClass)
                 ) { "Generated serializer does not have constructor with required number of arguments" }
-                    .let { compilerContext.externalSymbols.referenceConstructor(it) }
+                    .let { compilerContext.symbolTable.referenceConstructor(it) }
             } else {
-                compilerContext.externalSymbols.referenceConstructor(serializerClass.unsubstitutedPrimaryConstructor!!)
+                compilerContext.symbolTable.referenceConstructor(serializerClass.unsubstitutedPrimaryConstructor!!)
             }
             val returnType = wrapIrTypeIntoKSerializerIrType(module, thisIrType)
             return irInvoke(null, ctor, typeArguments = typeArgs, valueArguments = args, returnTypeHint = returnType)

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableCompanionIrGenerator.kt

@@ -57,11 +57,11 @@ class SerializableCompanionIrGenerator(
             )
         ) ?: return
         val annotationCtor = requireNotNull(annotationMarkerClass.unsubstitutedPrimaryConstructor?.let {
-            compilerContext.externalSymbols.referenceConstructor(it)
+            compilerContext.symbolTable.referenceConstructor(it)
         })
 
         val annotationType = annotationMarkerClass.defaultType.toIrType()
-        val irSerializableClass = compilerContext.externalSymbols.referenceClass(serializableDescriptor).owner
+        val irSerializableClass = compilerContext.symbolTable.referenceClass(serializableDescriptor).owner
         val annotationCtorCall = IrConstructorCallImpl.fromSymbolDescriptor(startOffset, endOffset, annotationType, annotationCtor).apply {
             val serializerType = serializer.toSimpleType(false)
             putValueArgument(

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt

@@ -46,7 +46,7 @@ class SerializableIrGenerator(
             val exceptionCtor =
                 serializableDescriptor.getClassFromSerializationPackage(MISSING_FIELD_EXC)
                     .unsubstitutedPrimaryConstructor!!
-            val exceptionCtorRef = compilerContext.externalSymbols.referenceConstructor(exceptionCtor)
+            val exceptionCtorRef = compilerContext.symbolTable.referenceConstructor(exceptionCtor)
             val exceptionType = exceptionCtor.returnType.toIrType()
 
             val serializableProperties = properties.serializableProperties
@@ -111,7 +111,7 @@ class SerializableIrGenerator(
     private fun IrBlockBodyBuilder.generateSuperNonSerializableCall(superClass: ClassDescriptor) {
         val suitableCtor = superClass.constructors.singleOrNull { it.valueParameters.size == 0 }
             ?: throw IllegalArgumentException("Non-serializable parent of serializable $serializableDescriptor must have no arg constructor")
-        val ctorRef = compilerContext.externalSymbols.referenceConstructor(suitableCtor)
+        val ctorRef = compilerContext.symbolTable.referenceConstructor(suitableCtor)
         val call = IrDelegatingConstructorCallImpl(
             startOffset,
             endOffset,
@@ -138,7 +138,7 @@ class SerializableIrGenerator(
         propertiesStart: Int
     ): Int {
         check(superClass.isInternalSerializable)
-        val superCtorRef = compilerContext.externalSymbols.serializableSyntheticConstructor(superClass)
+        val superCtorRef = compilerContext.symbolTable.serializableSyntheticConstructor(superClass)
         val superProperties = bindingContext.serializablePropertiesFor(superClass).serializableProperties
         val superSlots = superProperties.bitMaskSlotCount()
         val arguments = allValueParameters.subList(0, superSlots) +

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForEnumsGenerator.kt

@@ -35,7 +35,7 @@ class SerializerForEnumsGenerator(
             IrGetValueImpl(startOffset, endOffset, saveFunc.dispatchReceiverParameter!!.symbol)
 
         val encoderClass = serializerDescriptor.getClassFromSerializationPackage(SerialEntityNames.ENCODER_CLASS)
-        val descriptorGetterSymbol = compilerContext.externalSymbols.referenceFunction(anySerialDescProperty?.getter!!)
+        val descriptorGetterSymbol = compilerContext.symbolTable.referenceFunction(anySerialDescProperty?.getter!!)
         val encodeEnum = encoderClass.referenceMethod(CallingConventions.encodeEnum)
         val serialDescGetter = irGet(descriptorGetterSymbol.owner.returnType, irThis(), descriptorGetterSymbol)
 
@@ -50,7 +50,7 @@ class SerializerForEnumsGenerator(
             IrGetValueImpl(startOffset, endOffset, loadFunc.dispatchReceiverParameter!!.symbol)
 
         val decoderClass = serializerDescriptor.getClassFromSerializationPackage(SerialEntityNames.DECODER_CLASS)
-        val descriptorGetterSymbol = compilerContext.externalSymbols.referenceFunction(anySerialDescProperty?.getter!!)
+        val descriptorGetterSymbol = compilerContext.symbolTable.referenceFunction(anySerialDescProperty?.getter!!)
         val decode = decoderClass.referenceMethod(CallingConventions.decodeEnum)
         val serialDescGetter = irGet(descriptorGetterSymbol.owner.returnType, irThis(), descriptorGetterSymbol)
 
@@ -58,11 +58,8 @@ class SerializerForEnumsGenerator(
         val getValues = irInvoke(dispatchReceiver = null, callee = valuesF.symbol)
 
         val arrayGet =
-            compilerContext.builtIns.array.unsubstitutedMemberScope.getContributedFunctions(
+            compilerContext.builtIns.array.getFuncDesc("get").single()
-                Name.identifier("get"),
+        val arrayGetSymbol = compilerContext.symbolTable.referenceFunction(arrayGet)
-                NoLookupLocation.FROM_BACKEND
-            ).single()
-        val arrayGetSymbol = compilerContext.externalSymbols.referenceFunction(arrayGet)
         val getValueByOrdinal =
             irInvoke(getValues, arrayGetSymbol, irInvoke(irGet(loadFunc.valueParameters[0]), decode, serialDescGetter))
         +irReturn(getValueByOrdinal)
@@ -75,7 +72,7 @@ class SerializerForEnumsGenerator(
         val serialDescForEnums = serializerDescriptor
             .getClassFromInternalSerializationPackage(SerialEntityNames.SERIAL_DESCRIPTOR_FOR_ENUM)
         val ctor =
-            compilerContext.externalSymbols.referenceConstructor(serialDescForEnums.unsubstitutedPrimaryConstructor!!)
+            compilerContext.symbolTable.referenceConstructor(serialDescForEnums.unsubstitutedPrimaryConstructor!!)
         return irInvoke(
             null, ctor,
             irString(serialName),

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt

@@ -38,7 +38,7 @@ object SERIALIZABLE_PLUGIN_ORIGIN : IrDeclarationOriginImpl("SERIALIZER")
 
 open class SerializerIrGenerator(val irClass: IrClass, final override val compilerContext: SerializationPluginContext, bindingContext: BindingContext) :
     SerializerCodegen(irClass.descriptor, bindingContext), IrBuilderExtension {
-    protected val serializableIrClass = compilerContext.externalSymbols.referenceClass(serializableDescriptor).owner
+    protected val serializableIrClass = compilerContext.symbolTable.referenceClass(serializableDescriptor).owner
 
     override fun generateSerialDesc() {
         val desc: PropertyDescriptor = generatedSerialDescPropertyDescriptor ?: return
@@ -51,7 +51,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
         lateinit var prop: IrProperty
 
         // how to (auto)create backing field and getter/setter?
-        compilerContext.localSymbolTable.withScope(irClass.descriptor) {
+        compilerContext.symbolTable.withScope(irClass.descriptor) {
 
             introduceValueParameter(thisAsReceiverParameter)
             prop = generateSimplePropertyWithBackingField(thisAsReceiverParameter.symbol, desc, irClass)
@@ -62,13 +62,13 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
             }
         }
 
-        compilerContext.localSymbolTable.declareAnonymousInitializer(
+        compilerContext.symbolTable.declareAnonymousInitializer(
             irClass.startOffset, irClass.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, irClass.descriptor
         ).buildWithScope { initIrBody ->
             initIrBody.parent = irClass
             val ctor = irClass.declarations.filterIsInstance<IrConstructor>().find { it.isPrimary }
                 ?: throw AssertionError("Serializer must have primary constructor")
-            compilerContext.localSymbolTable.withScope(initIrBody.descriptor) {
+            compilerContext.symbolTable.withScope(initIrBody.descriptor) {
                 initIrBody.body =
                     DeclarationIrBuilder(compilerContext, initIrBody.symbol, initIrBody.startOffset, initIrBody.endOffset).irBlockBody {
                         val localDesc = irTemporary(
@@ -105,7 +105,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
     ): IrExpression {
         val serialDescImplConstructor = serialDescImplClass
             .unsubstitutedPrimaryConstructor!!
-        val serialClassDescImplCtor = compilerContext.externalSymbols.referenceConstructor(serialDescImplConstructor)
+        val serialClassDescImplCtor = compilerContext.symbolTable.referenceConstructor(serialDescImplConstructor)
         return irInvoke(
             null, serialClassDescImplCtor,
             irString(serialName), if (isGeneratedSerializer) correctThis else irNull()
@@ -167,7 +167,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
             // store type arguments serializers in fields
             val thisAsReceiverParameter = irClass.thisReceiver!!
             ctor.valueParameters.forEachIndexed { index, param ->
-                val localSerial = compilerContext.localSymbolTable.referenceField(localSerializersFieldsDescriptors[index])
+                val localSerial = compilerContext.symbolTable.referenceField(localSerializersFieldsDescriptors[index])
                 +irSetField(generateReceiverExpressionForFieldAccess(
                     thisAsReceiverParameter.symbol,
                     localSerializersFieldsDescriptors[index]
@@ -194,7 +194,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
     }
 
     protected fun ClassDescriptor.referenceMethod(methodName: String) =
-        getFuncDesc(methodName).single().let { compilerContext.externalSymbols.referenceFunction(it) }
+        getFuncDesc(methodName).single().let { compilerContext.symbolTable.referenceFunction(it) }
 
     override fun generateSave(function: FunctionDescriptor) = irClass.contributeFunction(function) { saveFunc ->
 
@@ -207,7 +207,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
         val kOutputClass = serializerDescriptor.getClassFromSerializationPackage(STRUCTURE_ENCODER_CLASS)
         val kOutputSmallClass = serializerDescriptor.getClassFromSerializationPackage(ENCODER_CLASS)
 
-        val descriptorGetterSymbol = compilerContext.externalSymbols.referenceFunction(anySerialDescProperty?.getter!!) //???
+        val descriptorGetterSymbol = compilerContext.symbolTable.referenceFunction(anySerialDescProperty?.getter!!) //???
 
         val localSerialDesc = irTemporary(irGet(descriptorGetterSymbol.owner.returnType, irThis(), descriptorGetterSymbol), "desc")
 
@@ -324,7 +324,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
 
         val inputClass = serializerDescriptor.getClassFromSerializationPackage(STRUCTURE_DECODER_CLASS)
         val inputSmallClass = serializerDescriptor.getClassFromSerializationPackage(DECODER_CLASS)
-        val descriptorGetterSymbol = compilerContext.externalSymbols.referenceFunction(anySerialDescProperty?.getter!!) //???
+        val descriptorGetterSymbol = compilerContext.symbolTable.referenceFunction(anySerialDescProperty?.getter!!) //???
         val localSerialDesc = irTemporary(irGet(descriptorGetterSymbol.owner.returnType, irThis(), descriptorGetterSymbol), "desc")
 
         // workaround due to unavailability of labels (KT-25386)
@@ -411,7 +411,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
                     val exceptionCtor =
                         serializableDescriptor.getClassFromSerializationPackage(UNKNOWN_FIELD_EXC)
                             .unsubstitutedPrimaryConstructor!!
-                    val excClassRef = compilerContext.externalSymbols.referenceConstructor(exceptionCtor)
+                    val excClassRef = compilerContext.symbolTable.referenceConstructor(exceptionCtor)
                     +elseBranch(
                         irThrow(
                             irInvoke(
@@ -438,9 +438,9 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
         val typeArgs = (loadFunc.returnType as IrSimpleType).arguments.map { (it as IrTypeProjection).type }
         val ctor: IrConstructorSymbol = if (serializableDescriptor.isInternalSerializable) {
             args = bitMasks.map { irGet(it) } + args + irNull()
-            compilerContext.externalSymbols.serializableSyntheticConstructor(serializableDescriptor)
+            compilerContext.symbolTable.serializableSyntheticConstructor(serializableDescriptor)
         } else {
-            compilerContext.externalSymbols.referenceConstructor(serializableDescriptor.unsubstitutedPrimaryConstructor!!)
+            compilerContext.symbolTable.referenceConstructor(serializableDescriptor.unsubstitutedPrimaryConstructor!!)
         }
 
         +irReturn(irInvoke(null, ctor, typeArgs, args))