[IR] Get rid of parameter name descriptor from methods of SymbolTableExtension

2023-07-12 13:50:02 +03:00
parent 08400d930f
commit c2f9961d4f
5 changed files with 240 additions and 240 deletions
@@ -51,7 +51,7 @@ class SymbolTableWithBuiltInsDeduplication(

    private inner class Extension : DescriptorSymbolTableExtension(this) {
        /**
-         * Gets or creates the [IrClassSymbol] for [descriptor], or for the built-in descriptor with the same name if [descriptor] is a
+         * Gets or creates the [IrClassSymbol] for [declaration], or for the built-in descriptor with the same name if [declaration] is a
         * duplicate built-in.
         *
         * Note that not all built-in symbols may have been bound or created by the time [irBuiltIns] has been bound. However, [referenceClass]
@@ -59,19 +59,19 @@ class SymbolTableWithBuiltInsDeduplication(
         * create a stub for the symbol if [referenceClass] was invoked from the stub generator.
         */
        @ObsoleteDescriptorBasedAPI
-        override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol {
-            val irBuiltIns = this@SymbolTableWithBuiltInsDeduplication.irBuiltIns ?: return super.referenceClass(descriptor)
+        override fun referenceClass(declaration: ClassDescriptor): IrClassSymbol {
+            val irBuiltIns = this@SymbolTableWithBuiltInsDeduplication.irBuiltIns ?: return super.referenceClass(declaration)

            // We need to find out whether `descriptor` is possibly a built-in symbol before it's actually retrieved to break recursion as
            // `irBuiltIns.findClass` uses `referenceClass` recursively.
-            val builtInDescriptor = irBuiltIns.findBuiltInClassDescriptor(descriptor)
+            val builtInDescriptor = irBuiltIns.findBuiltInClassDescriptor(declaration)
            if (builtInDescriptor != null) {
                // We need to delegate to the supertype implementation here to break recursion. `findBuiltInClassDescriptor` will return
                // `descriptor` even if `descriptor` was found via `findBuiltInClassDescriptor`.
                return super.referenceClass(builtInDescriptor)
            }

-            return super.referenceClass(descriptor)
+            return super.referenceClass(declaration)
        }
    }

@@ -34,12 +34,12 @@ class FragmentCompilerSymbolTableDecorator(
    }

    private inner class ExtensionDecorator : DescriptorSymbolTableExtension(this) {
-        override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol {
-            val fi = fragmentInfo ?: return super.referenceValueParameter(descriptor)
+        override fun referenceValueParameter(declaration: ParameterDescriptor): IrValueParameterSymbol {
+            val fi = fragmentInfo ?: return super.referenceValueParameter(declaration)

-            if (descriptor !is ReceiverParameterDescriptor) return super.referenceValueParameter(descriptor)
+            if (declaration !is ReceiverParameterDescriptor) return super.referenceValueParameter(declaration)

-            val finderPredicate = when (val receiverValue = descriptor.value) {
+            val finderPredicate = when (val receiverValue = declaration.value) {
                is ExtensionReceiver, is ContextReceiver -> { (targetDescriptor, _): EvaluatorFragmentParameterInfo ->
                    receiverValue == (targetDescriptor as? ReceiverParameterDescriptor)?.value
                }
@@ -54,7 +54,7 @@ class FragmentCompilerSymbolTableDecorator(
            if (parameterPosition > -1) {
                return super.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition])
            }
-            return super.referenceValueParameter(descriptor)
+            return super.referenceValueParameter(declaration)
        }

        override fun referenceValue(value: ValueDescriptor): IrValueSymbol {
@@ -25,98 +25,98 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo
    private inner class ExtensionWrapper : DescriptorSymbolTableExtension(originalTable) {
        private val delegate get() = originalTable.descriptorExtension

-        override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol {
+        override fun referenceClass(declaration: ClassDescriptor): IrClassSymbol {
            synchronized(lock) {
-                return delegate.referenceClass(descriptor).also {
+                return delegate.referenceClass(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generateClassStub(descriptor)
+                        stubGenerator?.generateClassStub(declaration)
                    }
                }
            }
        }

-        override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol {
+        override fun referenceTypeAlias(declaration: TypeAliasDescriptor): IrTypeAliasSymbol {
            synchronized(lock) {
-                return delegate.referenceTypeAlias(descriptor).also {
+                return delegate.referenceTypeAlias(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generateTypeAliasStub(descriptor)
+                        stubGenerator?.generateTypeAliasStub(declaration)
                    }
                }
            }
        }

-        override fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol {
+        override fun referenceConstructor(declaration: ClassConstructorDescriptor): IrConstructorSymbol {
            synchronized(lock) {
-                return delegate.referenceConstructor(descriptor).also {
+                return delegate.referenceConstructor(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generateConstructorStub(descriptor)
+                        stubGenerator?.generateConstructorStub(declaration)
                    }
                }
            }
        }

-        override fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol {
+        override fun referenceEnumEntry(declaration: ClassDescriptor): IrEnumEntrySymbol {
            synchronized(lock) {
-                return delegate.referenceEnumEntry(descriptor).also {
+                return delegate.referenceEnumEntry(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generateEnumEntryStub(descriptor)
+                        stubGenerator?.generateEnumEntryStub(declaration)
                    }
                }
            }
        }

-        override fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol {
+        override fun referenceSimpleFunction(declaration: FunctionDescriptor): IrSimpleFunctionSymbol {
            synchronized(lock) {
-                return delegate.referenceSimpleFunction(descriptor).also {
+                return delegate.referenceSimpleFunction(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generateFunctionStub(descriptor)
+                        stubGenerator?.generateFunctionStub(declaration)
                    }
                }
            }
        }

-        override fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol {
+        override fun referenceProperty(declaration: PropertyDescriptor): IrPropertySymbol {
            synchronized(lock) {
-                return delegate.referenceProperty(descriptor).also {
+                return delegate.referenceProperty(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generatePropertyStub(descriptor)
+                        stubGenerator?.generatePropertyStub(declaration)
                    }
                }
            }
        }

-        override fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol {
+        override fun referenceTypeParameter(declaration: TypeParameterDescriptor): IrTypeParameterSymbol {
            synchronized(lock) {
-                return delegate.referenceTypeParameter(classifier).also {
+                return delegate.referenceTypeParameter(declaration).also {
                    if (!it.isBound) {
-                        stubGenerator?.generateOrGetTypeParameterStub(classifier)
+                        stubGenerator?.generateOrGetTypeParameterStub(declaration)
                    }
                }
            }
        }

-        override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol {
-            return delegate.referenceValueParameter(descriptor)
+        override fun referenceValueParameter(declaration: ParameterDescriptor): IrValueParameterSymbol {
+            return delegate.referenceValueParameter(declaration)
        }

        override fun referenceValue(value: ValueDescriptor): IrValueSymbol {
            return delegate.referenceValue(value)
        }

-        override fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol {
-            return delegate.referenceScript(descriptor)
+        override fun referenceScript(declaration: ScriptDescriptor): IrScriptSymbol {
+            return delegate.referenceScript(declaration)
        }

-        override fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol {
-            return delegate.referenceField(descriptor)
+        override fun referenceField(declaration: PropertyDescriptor): IrFieldSymbol {
+            return delegate.referenceField(declaration)
        }

-        override fun referenceDeclaredFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol {
-            return delegate.referenceDeclaredFunction(descriptor)
+        override fun referenceDeclaredFunction(declaration: FunctionDescriptor): IrSimpleFunctionSymbol {
+            return delegate.referenceDeclaredFunction(declaration)
        }

-        override fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol {
-            return delegate.referenceScopedTypeParameter(classifier)
+        override fun referenceScopedTypeParameter(declaration: TypeParameterDescriptor): IrTypeParameterSymbol {
+            return delegate.referenceScopedTypeParameter(declaration)
        }
    }
 }
@@ -80,17 +80,17 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        return IrScriptImpl(symbol, nameProvider.nameForDeclaration(script), irFactory, startOffset, endOffset)
    }

-    override fun createScriptSymbol(descriptor: ScriptDescriptor, signature: IdSignature?): IrScriptSymbol {
-        return IrScriptSymbolImpl(descriptor)
+    override fun createScriptSymbol(declaration: ScriptDescriptor, signature: IdSignature?): IrScriptSymbol {
+        return IrScriptSymbolImpl(declaration)
    }

    // ------------------------------------ class ------------------------------------

-    override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol {
-        return if (descriptor is IrBasedClassDescriptor) {
-            descriptor.owner.symbol
+    override fun referenceClass(declaration: ClassDescriptor): IrClassSymbol {
+        return if (declaration is IrBasedClassDescriptor) {
+            declaration.owner.symbol
        } else {
-            super.referenceClass(descriptor)
+            super.referenceClass(declaration)
        }
    }

@@ -105,8 +105,8 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        )
    }

-    override fun createPublicClassSymbol(descriptor: ClassDescriptor, signature: IdSignature): IrClassSymbol {
-        return IrClassPublicSymbolImpl(signature, descriptor)
+    override fun createPublicClassSymbol(declaration: ClassDescriptor, signature: IdSignature): IrClassSymbol {
+        return IrClassPublicSymbolImpl(signature, declaration)
    }

    override fun createPrivateClassSymbol(descriptor: ClassDescriptor): IrClassSymbol {
@@ -130,12 +130,12 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        )
    }

-    override fun createPublicConstructorSymbol(descriptor: ClassConstructorDescriptor, signature: IdSignature): IrConstructorSymbol {
-        return IrConstructorPublicSymbolImpl(signature, descriptor)
+    override fun createPublicConstructorSymbol(declaration: ClassConstructorDescriptor, signature: IdSignature): IrConstructorSymbol {
+        return IrConstructorPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivateConstructorSymbol(descriptor: ClassConstructorDescriptor): IrConstructorSymbol {
-        return IrConstructorSymbolImpl(descriptor)
+    override fun createPrivateConstructorSymbol(declaration: ClassConstructorDescriptor): IrConstructorSymbol {
+        return IrConstructorSymbolImpl(declaration)
    }

    // ------------------------------------ enum entry ------------------------------------
@@ -155,12 +155,12 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        )
    }

-    override fun createPublicEnumEntrySymbol(descriptor: ClassDescriptor, signature: IdSignature): IrEnumEntrySymbol {
-        return IrEnumEntryPublicSymbolImpl(signature, descriptor)
+    override fun createPublicEnumEntrySymbol(declaration: ClassDescriptor, signature: IdSignature): IrEnumEntrySymbol {
+        return IrEnumEntryPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivateEnumEntrySymbol(descriptor: ClassDescriptor): IrEnumEntrySymbol {
-        return IrEnumEntrySymbolImpl(descriptor)
+    override fun createPrivateEnumEntrySymbol(declaration: ClassDescriptor): IrEnumEntrySymbol {
+        return IrEnumEntrySymbolImpl(declaration)
    }

    override fun defaultEnumEntryFactory(
@@ -175,19 +175,19 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten

    // ------------------------------------ field ------------------------------------

-    override fun createPublicFieldSymbol(descriptor: PropertyDescriptor, signature: IdSignature): IrFieldSymbol {
-        return IrFieldPublicSymbolImpl(signature, descriptor)
+    override fun createPublicFieldSymbol(declaration: PropertyDescriptor, signature: IdSignature): IrFieldSymbol {
+        return IrFieldPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivateFieldSymbol(descriptor: PropertyDescriptor): IrFieldSymbol {
-        return IrFieldSymbolImpl(descriptor)
+    override fun createPrivateFieldSymbol(declaration: PropertyDescriptor): IrFieldSymbol {
+        return IrFieldSymbolImpl(declaration)
    }

    override fun defaultFieldFactory(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: PropertyDescriptor,
+        declaration: PropertyDescriptor,
        type: IrType,
        visibility: DescriptorVisibility?,
        symbol: IrFieldSymbol,
@@ -196,7 +196,7 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
            startOffset = startOffset,
            endOffset = endOffset,
            origin = origin,
-            name = nameProvider.nameForDeclaration(descriptor),
+            name = nameProvider.nameForDeclaration(declaration),
            visibility = visibility ?: symbol.descriptor.visibility,
            symbol = symbol,
            type = type,
@@ -225,19 +225,19 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        )
    }

-    override fun createPublicPropertySymbol(descriptor: PropertyDescriptor, signature: IdSignature): IrPropertySymbol {
-        return IrPropertyPublicSymbolImpl(signature, descriptor)
+    override fun createPublicPropertySymbol(declaration: PropertyDescriptor, signature: IdSignature): IrPropertySymbol {
+        return IrPropertyPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivatePropertySymbol(descriptor: PropertyDescriptor): IrPropertySymbol {
-        return IrPropertySymbolImpl(descriptor)
+    override fun createPrivatePropertySymbol(declaration: PropertyDescriptor): IrPropertySymbol {
+        return IrPropertySymbolImpl(declaration)
    }

    override fun defaultPropertyFactory(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: PropertyDescriptor,
+        declaration: PropertyDescriptor,
        isDelegated: Boolean,
        symbol: IrPropertySymbol,
    ): IrProperty {
@@ -245,17 +245,17 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
            startOffset = startOffset,
            endOffset = endOffset,
            origin = origin,
-            name = nameProvider.nameForDeclaration(descriptor),
-            visibility = descriptor.visibility,
-            modality = descriptor.modality,
+            name = nameProvider.nameForDeclaration(declaration),
+            visibility = declaration.visibility,
+            modality = declaration.modality,
            symbol = symbol,
-            isVar = descriptor.isVar,
-            isConst = descriptor.isConst,
-            isLateinit = descriptor.isLateInit,
+            isVar = declaration.isVar,
+            isConst = declaration.isConst,
+            isLateinit = declaration.isLateInit,
            isDelegated = isDelegated,
-            isExternal = descriptor.isEffectivelyExternal(),
-            isExpect = descriptor.isExpect,
-            isFakeOverride = descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE,
+            isExternal = declaration.isEffectivelyExternal(),
+            isExpect = declaration.isExpect,
+            isFakeOverride = declaration.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE,
        ).apply {
            metadata = DescriptorMetadataSource.Property(symbol.descriptor)
        }
@@ -263,12 +263,12 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten

    // ------------------------------------ typealias ------------------------------------

-    override fun createPublicTypeAliasSymbol(descriptor: TypeAliasDescriptor, signature: IdSignature): IrTypeAliasSymbol {
-        return IrTypeAliasPublicSymbolImpl(signature, descriptor)
+    override fun createPublicTypeAliasSymbol(declaration: TypeAliasDescriptor, signature: IdSignature): IrTypeAliasSymbol {
+        return IrTypeAliasPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivateTypeAliasSymbol(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol {
-        return IrTypeAliasSymbolImpl(descriptor)
+    override fun createPrivateTypeAliasSymbol(declaration: TypeAliasDescriptor): IrTypeAliasSymbol {
+        return IrTypeAliasSymbolImpl(declaration)
    }

    // ------------------------------------ function ------------------------------------
@@ -288,36 +288,36 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        )
    }

-    override fun createPublicFunctionSymbol(descriptor: FunctionDescriptor, signature: IdSignature): IrSimpleFunctionSymbol {
-        return IrSimpleFunctionPublicSymbolImpl(signature, descriptor)
+    override fun createPublicFunctionSymbol(declaration: FunctionDescriptor, signature: IdSignature): IrSimpleFunctionSymbol {
+        return IrSimpleFunctionPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivateFunctionSymbol(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol {
-        return IrSimpleFunctionSymbolImpl(descriptor)
+    override fun createPrivateFunctionSymbol(declaration: FunctionDescriptor): IrSimpleFunctionSymbol {
+        return IrSimpleFunctionSymbolImpl(declaration)
    }

    // ------------------------------------ type parameter ------------------------------------

-    override fun createPublicTypeParameterSymbol(descriptor: TypeParameterDescriptor, signature: IdSignature): IrTypeParameterSymbol {
-        return IrTypeParameterPublicSymbolImpl(signature, descriptor)
+    override fun createPublicTypeParameterSymbol(declaration: TypeParameterDescriptor, signature: IdSignature): IrTypeParameterSymbol {
+        return IrTypeParameterPublicSymbolImpl(signature, declaration)
    }

-    override fun createPrivateTypeParameterSymbol(descriptor: TypeParameterDescriptor): IrTypeParameterSymbol {
-        return IrTypeParameterSymbolImpl(descriptor)
+    override fun createPrivateTypeParameterSymbol(declaration: TypeParameterDescriptor): IrTypeParameterSymbol {
+        return IrTypeParameterSymbolImpl(declaration)
    }

    override fun defaultTypeParameterFactory(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: TypeParameterDescriptor,
+        declaration: TypeParameterDescriptor,
        symbol: IrTypeParameterSymbol,
    ): IrTypeParameter {
        return irFactory.createTypeParameter(
            startOffset = startOffset,
            endOffset = endOffset,
            origin = origin,
-            name = nameProvider.nameForDeclaration(descriptor),
+            name = nameProvider.nameForDeclaration(declaration),
            symbol = symbol,
            variance = symbol.descriptor.variance,
            index = symbol.descriptor.index,
@@ -399,9 +399,9 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
        valueParameterSlice.introduceLocal(irValueParameter.descriptor, irValueParameter.symbol)
    }

-    override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol {
-        return valueParameterSlice.referenced(descriptor) {
-            error("Undefined parameter referenced: $descriptor\n${valueParameterSlice.dump()}")
+    override fun referenceValueParameter(declaration: ParameterDescriptor): IrValueParameterSymbol {
+        return valueParameterSlice.referenced(declaration) {
+            error("Undefined parameter referenced: $declaration\n${valueParameterSlice.dump()}")
        }
    }

@@ -14,18 +14,18 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.utils.threadLocal

 abstract class ReferenceSymbolTableExtension<Class, TypeAlias, Script, Function, Constructor, Property, ValueParameter, TypeParameter> {
-    abstract fun referenceScript(descriptor: Script): IrScriptSymbol
-    abstract fun referenceClass(descriptor: Class): IrClassSymbol
-    abstract fun referenceConstructor(descriptor: Constructor): IrConstructorSymbol
-    abstract fun referenceEnumEntry(descriptor: Class): IrEnumEntrySymbol
-    abstract fun referenceField(descriptor: Property): IrFieldSymbol
-    abstract fun referenceProperty(descriptor: Property): IrPropertySymbol
-    abstract fun referenceSimpleFunction(descriptor: Function): IrSimpleFunctionSymbol
-    abstract fun referenceDeclaredFunction(descriptor: Function): IrSimpleFunctionSymbol
-    abstract fun referenceValueParameter(descriptor: ValueParameter): IrValueParameterSymbol
-    abstract fun referenceTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol
-    abstract fun referenceScopedTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol
-    abstract fun referenceTypeAlias(descriptor: TypeAlias): IrTypeAliasSymbol
+    abstract fun referenceScript(declaration: Script): IrScriptSymbol
+    abstract fun referenceClass(declaration: Class): IrClassSymbol
+    abstract fun referenceConstructor(declaration: Constructor): IrConstructorSymbol
+    abstract fun referenceEnumEntry(declaration: Class): IrEnumEntrySymbol
+    abstract fun referenceField(declaration: Property): IrFieldSymbol
+    abstract fun referenceProperty(declaration: Property): IrPropertySymbol
+    abstract fun referenceSimpleFunction(declaration: Function): IrSimpleFunctionSymbol
+    abstract fun referenceDeclaredFunction(declaration: Function): IrSimpleFunctionSymbol
+    abstract fun referenceValueParameter(declaration: ValueParameter): IrValueParameterSymbol
+    abstract fun referenceTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol
+    abstract fun referenceScopedTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol
+    abstract fun referenceTypeAlias(declaration: TypeAlias): IrTypeAliasSymbol
 }

 typealias SymbolFactory<Declaration, Symbol> = (Declaration, IdSignature?) -> Symbol
@@ -92,50 +92,50 @@ abstract class SymbolTableExtension<
    fun declareScript(
        startOffset: Int,
        endOffset: Int,
-        descriptor: Script,
+        declaration: Script,
    ): IrScript {
        return declare(
-            descriptor,
+            declaration,
            scriptSlice,
            SymbolTable::declareScript,
-            symbolFactory = { createScriptSymbol(descriptor, it) },
-            ownerFactory = { defaultScriptFactory(startOffset, endOffset, descriptor, it) }
+            symbolFactory = { createScriptSymbol(declaration, it) },
+            ownerFactory = { defaultScriptFactory(startOffset, endOffset, declaration, it) }
        )
    }

-    override fun referenceScript(descriptor: Script): IrScriptSymbol {
-        return scriptSlice.referenced(descriptor) { createScriptSymbol(descriptor, signature = null) }
+    override fun referenceScript(declaration: Script): IrScriptSymbol {
+        return scriptSlice.referenced(declaration) { createScriptSymbol(declaration, signature = null) }
    }

    protected abstract fun defaultScriptFactory(startOffset: Int, endOffset: Int, script: Script, symbol: IrScriptSymbol): IrScript

-    protected abstract fun createScriptSymbol(descriptor: Script, signature: IdSignature?): IrScriptSymbol
+    protected abstract fun createScriptSymbol(declaration: Script, signature: IdSignature?): IrScriptSymbol

    // ------------------------------------ script ------------------------------------

-    fun declareClass(descriptor: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass {
+    fun declareClass(declaration: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass {
        return declare(
-            descriptor,
+            declaration,
            classSlice,
            SymbolTable::declareClass,
-            { createClassSymbol(descriptor, it) },
+            { createClassSymbol(declaration, it) },
            classFactory
        )
    }

-    fun declareClassIfNotExists(descriptor: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass {
+    fun declareClassIfNotExists(declaration: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass {
        return declareIfNotExist(
-            descriptor,
+            declaration,
            classSlice,
            SymbolTable::declareClassIfNotExists,
-            { createClassSymbol(descriptor, it) },
+            { createClassSymbol(declaration, it) },
            classFactory
        )
    }

-    override fun referenceClass(descriptor: Class): IrClassSymbol {
+    override fun referenceClass(declaration: Class): IrClassSymbol {
        return reference(
-            descriptor,
+            declaration,
            classSlice,
            SymbolTable::referenceClassImpl,
            ::createClassSymbol,
@@ -144,41 +144,41 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createClassSymbol(descriptor: Class, signature: IdSignature?): IrClassSymbol {
-        return signature?.let { createPublicClassSymbol(descriptor, signature) } ?: createPrivateClassSymbol(descriptor)
+    protected fun createClassSymbol(declaration: Class, signature: IdSignature?): IrClassSymbol {
+        return signature?.let { createPublicClassSymbol(declaration, signature) } ?: createPrivateClassSymbol(declaration)
    }

-    protected abstract fun createPublicClassSymbol(descriptor: Class, signature: IdSignature): IrClassSymbol
+    protected abstract fun createPublicClassSymbol(declaration: Class, signature: IdSignature): IrClassSymbol
    protected abstract fun createPrivateClassSymbol(descriptor: Class): IrClassSymbol

    // ------------------------------------ constructor ------------------------------------

-    fun declareConstructor(descriptor: Constructor, constructorFactory: (IrConstructorSymbol) -> IrConstructor): IrConstructor {
+    fun declareConstructor(declaration: Constructor, constructorFactory: (IrConstructorSymbol) -> IrConstructor): IrConstructor {
        return declare(
-            descriptor,
+            declaration,
            constructorSlice,
            SymbolTable::declareConstructor,
-            { createConstructorSymbol(descriptor, it) },
+            { createConstructorSymbol(declaration, it) },
            constructorFactory
        )
    }

    fun declareConstructorIfNotExists(
-        descriptor: Constructor,
+        declaration: Constructor,
        constructorFactory: (IrConstructorSymbol) -> IrConstructor,
    ): IrConstructor {
        return declareIfNotExist(
-            descriptor,
+            declaration,
            constructorSlice,
            SymbolTable::declareConstructorIfNotExists,
-            { createConstructorSymbol(descriptor, it) },
+            { createConstructorSymbol(declaration, it) },
            constructorFactory
        )
    }

-    override fun referenceConstructor(descriptor: Constructor): IrConstructorSymbol {
+    override fun referenceConstructor(declaration: Constructor): IrConstructorSymbol {
        return reference(
-            descriptor,
+            declaration,
            constructorSlice,
            SymbolTable::referenceConstructorImpl,
            ::createConstructorSymbol,
@@ -187,46 +187,46 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createConstructorSymbol(descriptor: Constructor, signature: IdSignature?): IrConstructorSymbol {
-        return signature?.let { createPublicConstructorSymbol(descriptor, signature) } ?: createPrivateConstructorSymbol(descriptor)
+    protected fun createConstructorSymbol(declaration: Constructor, signature: IdSignature?): IrConstructorSymbol {
+        return signature?.let { createPublicConstructorSymbol(declaration, signature) } ?: createPrivateConstructorSymbol(declaration)
    }

-    protected abstract fun createPublicConstructorSymbol(descriptor: Constructor, signature: IdSignature): IrConstructorSymbol
-    protected abstract fun createPrivateConstructorSymbol(descriptor: Constructor): IrConstructorSymbol
+    protected abstract fun createPublicConstructorSymbol(declaration: Constructor, signature: IdSignature): IrConstructorSymbol
+    protected abstract fun createPrivateConstructorSymbol(declaration: Constructor): IrConstructorSymbol

    // ------------------------------------ enum entry ------------------------------------

-    fun declareEnumEntry(descriptor: Class, enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry {
+    fun declareEnumEntry(declaration: Class, enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry {
        return declare(
-            descriptor,
+            declaration,
            enumEntrySlice,
            SymbolTable::declareEnumEntry,
-            { createEnumEntrySymbol(descriptor, it) },
+            { createEnumEntrySymbol(declaration, it) },
            enumEntryFactory,
            ::calculateEnumEntrySignature
        )
    }

-    fun declareEnumEntry(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: Class): IrEnumEntry {
+    fun declareEnumEntry(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, declaration: Class): IrEnumEntry {
        return declareEnumEntry(
-            descriptor
-        ) { enumEntrySymbol -> defaultEnumEntryFactory(startOffset, endOffset, origin, descriptor, enumEntrySymbol) }
+            declaration
+        ) { enumEntrySymbol -> defaultEnumEntryFactory(startOffset, endOffset, origin, declaration, enumEntrySymbol) }
    }

-    fun declareEnumEntryIfNotExists(descriptor: Class, enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry {
+    fun declareEnumEntryIfNotExists(declaration: Class, enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry {
        return declareIfNotExist(
-            descriptor,
+            declaration,
            enumEntrySlice,
            SymbolTable::declareEnumEntryIfNotExists,
-            { createEnumEntrySymbol(descriptor, it) },
+            { createEnumEntrySymbol(declaration, it) },
            enumEntryFactory,
            ::calculateEnumEntrySignature
        )
    }

-    override fun referenceEnumEntry(descriptor: Class): IrEnumEntrySymbol {
+    override fun referenceEnumEntry(declaration: Class): IrEnumEntrySymbol {
        return reference(
-            descriptor,
+            declaration,
            enumEntrySlice,
            SymbolTable::referenceEnumEntryImpl,
            ::createEnumEntrySymbol,
@@ -236,12 +236,12 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createEnumEntrySymbol(descriptor: Class, signature: IdSignature?): IrEnumEntrySymbol {
-        return signature?.let { createPublicEnumEntrySymbol(descriptor, signature) } ?: createPrivateEnumEntrySymbol(descriptor)
+    protected fun createEnumEntrySymbol(declaration: Class, signature: IdSignature?): IrEnumEntrySymbol {
+        return signature?.let { createPublicEnumEntrySymbol(declaration, signature) } ?: createPrivateEnumEntrySymbol(declaration)
    }

-    protected abstract fun createPublicEnumEntrySymbol(descriptor: Class, signature: IdSignature): IrEnumEntrySymbol
-    protected abstract fun createPrivateEnumEntrySymbol(descriptor: Class): IrEnumEntrySymbol
+    protected abstract fun createPublicEnumEntrySymbol(declaration: Class, signature: IdSignature): IrEnumEntrySymbol
+    protected abstract fun createPrivateEnumEntrySymbol(declaration: Class): IrEnumEntrySymbol

    protected abstract fun defaultEnumEntryFactory(
        startOffset: Int,
@@ -257,7 +257,7 @@ abstract class SymbolTableExtension<
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: Property,
+        declaration: Property,
        type: IrType,
        visibility: DescriptorVisibility? = null,
        fieldFactory: (IrFieldSymbol) -> IrField = {
@@ -265,7 +265,7 @@ abstract class SymbolTableExtension<
                startOffset,
                endOffset,
                origin,
-                descriptor,
+                declaration,
                type,
                visibility,
                it
@@ -273,10 +273,10 @@ abstract class SymbolTableExtension<
        },
    ): IrField {
        return declare(
-            descriptor,
+            declaration,
            fieldSlice,
            SymbolTable::declareField,
-            { createFieldSymbol(descriptor, it) },
+            { createFieldSymbol(declaration, it) },
            fieldFactory,
            ::calculateFieldSignature
        )
@@ -286,18 +286,18 @@ abstract class SymbolTableExtension<
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: Property,
+        declaration: Property,
        type: IrType,
        irInitializer: IrExpressionBody?,
    ): IrField {
-        return declareField(startOffset, endOffset, origin, descriptor, type).apply {
+        return declareField(startOffset, endOffset, origin, declaration, type).apply {
            initializer = irInitializer
        }
    }

-    override fun referenceField(descriptor: Property): IrFieldSymbol {
+    override fun referenceField(declaration: Property): IrFieldSymbol {
        return reference(
-            descriptor,
+            declaration,
            fieldSlice,
            SymbolTable::referenceFieldImpl,
            ::createFieldSymbol,
@@ -307,18 +307,18 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createFieldSymbol(descriptor: Property, signature: IdSignature?): IrFieldSymbol {
-        return signature?.let { createPublicFieldSymbol(descriptor, signature) } ?: createPrivateFieldSymbol(descriptor)
+    protected fun createFieldSymbol(declaration: Property, signature: IdSignature?): IrFieldSymbol {
+        return signature?.let { createPublicFieldSymbol(declaration, signature) } ?: createPrivateFieldSymbol(declaration)
    }

-    protected abstract fun createPublicFieldSymbol(descriptor: Property, signature: IdSignature): IrFieldSymbol
-    protected abstract fun createPrivateFieldSymbol(descriptor: Property): IrFieldSymbol
+    protected abstract fun createPublicFieldSymbol(declaration: Property, signature: IdSignature): IrFieldSymbol
+    protected abstract fun createPrivateFieldSymbol(declaration: Property): IrFieldSymbol

    protected abstract fun defaultFieldFactory(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: Property,
+        declaration: Property,
        type: IrType,
        visibility: DescriptorVisibility?,
        symbol: IrFieldSymbol,
@@ -326,12 +326,12 @@ abstract class SymbolTableExtension<

    // ------------------------------------ property ------------------------------------

-    fun declareProperty(descriptor: Property, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty {
+    fun declareProperty(declaration: Property, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty {
        return declare(
-            descriptor,
+            declaration,
            propertySlice,
            SymbolTable::declareProperty,
-            { createPropertySymbol(descriptor, it) },
+            { createPropertySymbol(declaration, it) },
            propertyFactory
        )
    }
@@ -340,27 +340,27 @@ abstract class SymbolTableExtension<
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: Property,
+        declaration: Property,
        isDelegated: Boolean
    ): IrProperty {
-        return declareProperty(descriptor) { propertySymbol ->
-            defaultPropertyFactory(startOffset, endOffset, origin, descriptor, isDelegated, propertySymbol)
+        return declareProperty(declaration) { propertySymbol ->
+            defaultPropertyFactory(startOffset, endOffset, origin, declaration, isDelegated, propertySymbol)
        }
    }

-    fun declarePropertyIfNotExists(descriptor: Property, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty {
+    fun declarePropertyIfNotExists(declaration: Property, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty {
        return declareIfNotExist(
-            descriptor,
+            declaration,
            propertySlice,
            SymbolTable::declarePropertyIfNotExists,
-            { createPropertySymbol(descriptor, it) },
+            { createPropertySymbol(declaration, it) },
            propertyFactory
        )
    }

-    override fun referenceProperty(descriptor: Property): IrPropertySymbol {
+    override fun referenceProperty(declaration: Property): IrPropertySymbol {
        return reference(
-            descriptor,
+            declaration,
            propertySlice,
            SymbolTable::referencePropertyImpl,
            ::createPropertySymbol,
@@ -369,47 +369,47 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createPropertySymbol(descriptor: Property, signature: IdSignature?): IrPropertySymbol {
-        return signature?.let { createPublicPropertySymbol(descriptor, signature) } ?: createPrivatePropertySymbol(descriptor)
+    protected fun createPropertySymbol(declaration: Property, signature: IdSignature?): IrPropertySymbol {
+        return signature?.let { createPublicPropertySymbol(declaration, signature) } ?: createPrivatePropertySymbol(declaration)
    }

-    protected abstract fun createPublicPropertySymbol(descriptor: Property, signature: IdSignature): IrPropertySymbol
-    protected abstract fun createPrivatePropertySymbol(descriptor: Property): IrPropertySymbol
+    protected abstract fun createPublicPropertySymbol(declaration: Property, signature: IdSignature): IrPropertySymbol
+    protected abstract fun createPrivatePropertySymbol(declaration: Property): IrPropertySymbol

    protected abstract fun defaultPropertyFactory(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: Property,
+        declaration: Property,
        isDelegated: Boolean,
        symbol: IrPropertySymbol,
    ): IrProperty

    // ------------------------------------ typealias ------------------------------------

-    fun declareTypeAlias(descriptor: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias {
+    fun declareTypeAlias(declaration: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias {
        return declare(
-            descriptor,
+            declaration,
            typeAliasSlice,
            SymbolTable::declareTypeAlias,
-            { createTypeAliasSymbol(descriptor, it) },
+            { createTypeAliasSymbol(declaration, it) },
            typeAliasFactory
        )
    }

-    fun declareTypeAliasIfNotExists(descriptor: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias {
+    fun declareTypeAliasIfNotExists(declaration: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias {
        return declareIfNotExist(
-            descriptor,
+            declaration,
            typeAliasSlice,
            SymbolTable::declareTypeAliasIfNotExists,
-            { createTypeAliasSymbol(descriptor, it) },
+            { createTypeAliasSymbol(declaration, it) },
            typeAliasFactory
        )
    }

-    override fun referenceTypeAlias(descriptor: TypeAlias): IrTypeAliasSymbol {
+    override fun referenceTypeAlias(declaration: TypeAlias): IrTypeAliasSymbol {
        return reference(
-            descriptor,
+            declaration,
            typeAliasSlice,
            SymbolTable::referenceTypeAliasImpl,
            ::createTypeAliasSymbol,
@@ -418,41 +418,41 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createTypeAliasSymbol(descriptor: TypeAlias, signature: IdSignature?): IrTypeAliasSymbol {
-        return signature?.let { createPublicTypeAliasSymbol(descriptor, signature) } ?: createPrivateTypeAliasSymbol(descriptor)
+    protected fun createTypeAliasSymbol(declaration: TypeAlias, signature: IdSignature?): IrTypeAliasSymbol {
+        return signature?.let { createPublicTypeAliasSymbol(declaration, signature) } ?: createPrivateTypeAliasSymbol(declaration)
    }

-    protected abstract fun createPublicTypeAliasSymbol(descriptor: TypeAlias, signature: IdSignature): IrTypeAliasSymbol
-    protected abstract fun createPrivateTypeAliasSymbol(descriptor: TypeAlias): IrTypeAliasSymbol
+    protected abstract fun createPublicTypeAliasSymbol(declaration: TypeAlias, signature: IdSignature): IrTypeAliasSymbol
+    protected abstract fun createPrivateTypeAliasSymbol(declaration: TypeAlias): IrTypeAliasSymbol

    // ------------------------------------ function ------------------------------------

-    fun declareSimpleFunction(descriptor: Function, functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction): IrSimpleFunction {
+    fun declareSimpleFunction(declaration: Function, functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction): IrSimpleFunction {
        return declare(
-            descriptor,
+            declaration,
            functionSlice,
            SymbolTable::declareSimpleFunction,
-            { createFunctionSymbol(descriptor, it) },
+            { createFunctionSymbol(declaration, it) },
            functionFactory
        )
    }

    fun declareSimpleFunctionIfNotExists(
-        descriptor: Function,
+        declaration: Function,
        functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction,
    ): IrSimpleFunction {
        return declareIfNotExist(
-            descriptor,
+            declaration,
            functionSlice,
            SymbolTable::declareSimpleFunctionIfNotExists,
-            { createFunctionSymbol(descriptor, it) },
+            { createFunctionSymbol(declaration, it) },
            functionFactory
        )
    }

-    override fun referenceSimpleFunction(descriptor: Function): IrSimpleFunctionSymbol {
+    override fun referenceSimpleFunction(declaration: Function): IrSimpleFunctionSymbol {
        return reference(
-            descriptor,
+            declaration,
            functionSlice,
            SymbolTable::referenceSimpleFunctionImpl,
            ::createFunctionSymbol,
@@ -461,11 +461,11 @@ abstract class SymbolTableExtension<
        )
    }

-    override fun referenceDeclaredFunction(descriptor: Function): IrSimpleFunctionSymbol {
-        fun throwError(): Nothing = error("Function is not declared: $descriptor")
+    override fun referenceDeclaredFunction(declaration: Function): IrSimpleFunctionSymbol {
+        fun throwError(): Nothing = error("Function is not declared: $declaration")

        return reference(
-            descriptor,
+            declaration,
            functionSlice,
            SymbolTable::referenceSimpleFunctionImpl,
            { _, _ -> throwError() },
@@ -474,24 +474,24 @@ abstract class SymbolTableExtension<
        )
    }

-    protected fun createFunctionSymbol(descriptor: Function, signature: IdSignature?): IrSimpleFunctionSymbol {
-        return signature?.let { createPublicFunctionSymbol(descriptor, signature) } ?: createPrivateFunctionSymbol(descriptor)
+    protected fun createFunctionSymbol(declaration: Function, signature: IdSignature?): IrSimpleFunctionSymbol {
+        return signature?.let { createPublicFunctionSymbol(declaration, signature) } ?: createPrivateFunctionSymbol(declaration)
    }

-    protected abstract fun createPublicFunctionSymbol(descriptor: Function, signature: IdSignature): IrSimpleFunctionSymbol
-    protected abstract fun createPrivateFunctionSymbol(descriptor: Function): IrSimpleFunctionSymbol
+    protected abstract fun createPublicFunctionSymbol(declaration: Function, signature: IdSignature): IrSimpleFunctionSymbol
+    protected abstract fun createPrivateFunctionSymbol(declaration: Function): IrSimpleFunctionSymbol

    // ------------------------------------ type parameter ------------------------------------

    fun declareGlobalTypeParameter(
-        descriptor: TypeParameter,
+        declaration: TypeParameter,
        typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter,
    ): IrTypeParameter {
        return declare(
-            descriptor,
+            declaration,
            globalTypeParameterSlice,
            SymbolTable::declareGlobalTypeParameter,
-            { createTypeParameterSymbol(descriptor, it) },
+            { createTypeParameterSymbol(declaration, it) },
            typeParameterFactory
        )
    }
@@ -500,10 +500,10 @@ abstract class SymbolTableExtension<
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: TypeParameter,
+        declaration: TypeParameter,
    ): IrTypeParameter {
-        return declareGlobalTypeParameter(descriptor) {
-            defaultTypeParameterFactory(startOffset, endOffset, origin, descriptor, it)
+        return declareGlobalTypeParameter(declaration) {
+            defaultTypeParameterFactory(startOffset, endOffset, origin, declaration, it)
        }
    }

@@ -511,22 +511,22 @@ abstract class SymbolTableExtension<
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: TypeParameter,
+        declaration: TypeParameter,
        typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter = {
-            defaultTypeParameterFactory(startOffset, endOffset, origin, descriptor, it)
+            defaultTypeParameterFactory(startOffset, endOffset, origin, declaration, it)
        },
    ): IrTypeParameter {
        return scopedTypeParameterSlice.declare(
-            descriptor,
-            { createTypeParameterSymbol(descriptor, calculateSignature(descriptor)) },
+            declaration,
+            { createTypeParameterSymbol(declaration, calculateSignature(declaration)) },
            typeParameterFactory
        )
    }

-    override fun referenceTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol {
-        scopedTypeParameterSlice.get(classifier)?.let { return it }
+    override fun referenceTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol {
+        scopedTypeParameterSlice.get(declaration)?.let { return it }
        return reference(
-            classifier,
+            declaration,
            globalTypeParameterSlice,
            SymbolTable::referenceTypeParameterImpl,
            ::createTypeParameterSymbol,
@@ -535,28 +535,28 @@ abstract class SymbolTableExtension<
        )
    }

-    override fun referenceScopedTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol {
-        return scopedTypeParameterSlice.referenced(classifier) { createTypeParameterSymbol(classifier, calculateSignature(classifier)) }
+    override fun referenceScopedTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol {
+        return scopedTypeParameterSlice.referenced(declaration) { createTypeParameterSymbol(declaration, calculateSignature(declaration)) }
    }

-    protected fun createTypeParameterSymbol(descriptor: TypeParameter, signature: IdSignature?): IrTypeParameterSymbol {
-        return signature?.let { createPublicTypeParameterSymbol(descriptor, signature) } ?: createPrivateTypeParameterSymbol(descriptor)
+    protected fun createTypeParameterSymbol(declaration: TypeParameter, signature: IdSignature?): IrTypeParameterSymbol {
+        return signature?.let { createPublicTypeParameterSymbol(declaration, signature) } ?: createPrivateTypeParameterSymbol(declaration)
    }

-    protected abstract fun createPublicTypeParameterSymbol(descriptor: TypeParameter, signature: IdSignature): IrTypeParameterSymbol
-    protected abstract fun createPrivateTypeParameterSymbol(descriptor: TypeParameter): IrTypeParameterSymbol
+    protected abstract fun createPublicTypeParameterSymbol(declaration: TypeParameter, signature: IdSignature): IrTypeParameterSymbol
+    protected abstract fun createPrivateTypeParameterSymbol(declaration: TypeParameter): IrTypeParameterSymbol

    protected abstract fun defaultTypeParameterFactory(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: TypeParameter,
+        declaration: TypeParameter,
        symbol: IrTypeParameterSymbol,
    ): IrTypeParameter

    // ------------------------------------ value parameter ------------------------------------

-    override fun referenceValueParameter(descriptor: ValueParameter): IrValueParameterSymbol {
+    override fun referenceValueParameter(declaration: ValueParameter): IrValueParameterSymbol {
        error("There is no default implementation for any symbol table extension")
    }

@@ -621,7 +621,7 @@ abstract class SymbolTableExtension<
        }

    private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declare(
-        descriptor: D,
+        declaration: D,
        slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
        declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
        crossinline symbolFactory: (IdSignature?) -> Symbol,
@@ -629,7 +629,7 @@ abstract class SymbolTableExtension<
        specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) }
    ): SymbolOwner {
        return declare(
-            descriptor,
+            declaration,
            slice,
            declareBySignature,
            SymbolTableSlice<D, SymbolOwner, Symbol>::declare,
@@ -640,7 +640,7 @@ abstract class SymbolTableExtension<
    }

    private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declareIfNotExist(
-        descriptor: D,
+        declaration: D,
        slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
        declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
        crossinline symbolFactory: (IdSignature?) -> Symbol,
@@ -648,7 +648,7 @@ abstract class SymbolTableExtension<
        specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) }
    ): SymbolOwner {
        return declare(
-            descriptor,
+            declaration,
            slice,
            declareBySignature,
            SymbolTableSlice<D, SymbolOwner, Symbol>::declareIfNotExists,
@@ -659,7 +659,7 @@ abstract class SymbolTableExtension<
    }

    private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declare(
-        descriptor: D,
+        declaration: D,
        slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
        declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
        declareByDeclaration: SymbolTableSlice<D, SymbolOwner, Symbol>.(D, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
@@ -667,14 +667,14 @@ abstract class SymbolTableExtension<
        noinline ownerFactory: OwnerFactory<Symbol, SymbolOwner>,
        specificCalculateSignature: (D) -> IdSignature?
    ): SymbolOwner {
-        return when (val signature = specificCalculateSignature(descriptor)) {
-            null -> slice.declareByDeclaration(descriptor, { symbolFactory(signature) }, ownerFactory)
+        return when (val signature = specificCalculateSignature(declaration)) {
+            null -> slice.declareByDeclaration(declaration, { symbolFactory(signature) }, ownerFactory)
            else -> table.declareBySignature(signature, { symbolFactory(signature) }, ownerFactory)
        }
    }

    private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> reference(
-        descriptor: D,
+        declaration: D,
        slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
        referenceBySignature: SymbolTable.(IdSignature, () -> Symbol, () -> Symbol) -> Symbol,
        crossinline symbolFactory: (D, IdSignature?) -> Symbol,
@@ -682,12 +682,12 @@ abstract class SymbolTableExtension<
        crossinline privateSymbolFactory: (D) -> Symbol,
        specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) }
    ): Symbol {
-        return when (val signature = specificCalculateSignature(descriptor)) {
-            null -> slice.referenced(descriptor) { symbolFactory(descriptor, signature) }
+        return when (val signature = specificCalculateSignature(declaration)) {
+            null -> slice.referenced(declaration) { symbolFactory(declaration, signature) }
            else -> table.referenceBySignature(
                signature,
-                { publicSymbolFactory(descriptor, signature) },
-                { privateSymbolFactory(descriptor) }
+                { publicSymbolFactory(declaration, signature) },
+                { privateSymbolFactory(declaration) }
            )
        }
    }