From c2f9961d4f732af4331835844d33526bcafc775d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 12 Jul 2023 13:50:02 +0300 Subject: [PATCH] [IR] Get rid of parameter name `descriptor` from methods of SymbolTableExtension --- .../SymbolTableWithBuiltInsDeduplication.kt | 10 +- .../FragmentCompilerSymbolTableDecorator.kt | 10 +- .../ir/declarations/lazy/IrLazySymbolTable.kt | 62 ++-- .../ir/util/DescriptorSymbolTableExtension.kt | 106 +++---- .../kotlin/ir/util/SymbolTableExtension.kt | 292 +++++++++--------- 5 files changed, 240 insertions(+), 240 deletions(-) diff --git a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt index 7febe68e12a..88840ec16aa 100644 --- a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt +++ b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt @@ -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) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt index 4851879cf95..1b3fc82ca2e 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt @@ -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 { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt index 3bf8635e826..2524e087eb2 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt @@ -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) } } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorSymbolTableExtension.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorSymbolTableExtension.kt index cb89674d9fd..8076ebd362e 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorSymbolTableExtension.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorSymbolTableExtension.kt @@ -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()}") } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt index 52cf5797247..9e2b0e00954 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt @@ -14,18 +14,18 @@ import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.utils.threadLocal abstract class ReferenceSymbolTableExtension { - 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, 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 , SymbolOwner : IrSymbolOwner> declare( - descriptor: D, + declaration: D, slice: SymbolTableSlice, declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory) -> 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::declare, @@ -640,7 +640,7 @@ abstract class SymbolTableExtension< } private inline fun , SymbolOwner : IrSymbolOwner> declareIfNotExist( - descriptor: D, + declaration: D, slice: SymbolTableSlice, declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory) -> 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::declareIfNotExists, @@ -659,7 +659,7 @@ abstract class SymbolTableExtension< } private inline fun , SymbolOwner : IrSymbolOwner> declare( - descriptor: D, + declaration: D, slice: SymbolTableSlice, declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory) -> SymbolOwner, declareByDeclaration: SymbolTableSlice.(D, () -> Symbol, OwnerFactory) -> SymbolOwner, @@ -667,14 +667,14 @@ abstract class SymbolTableExtension< noinline ownerFactory: OwnerFactory, 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 , SymbolOwner : IrSymbolOwner> reference( - descriptor: D, + declaration: D, slice: SymbolTableSlice, 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) } ) } }