azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2023-07-12 13:50:02 +03:00
committed by Space Team
parent 08400d930f
commit c2f9961d4f
5 changed files with 240 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt
+5 -5
View File
@@ -51,7 +51,7 @@ class SymbolTableWithBuiltInsDeduplication(
private inner class Extension : DescriptorSymbolTableExtension(this) { 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. * 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] * 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. * create a stub for the symbol if [referenceClass] was invoked from the stub generator.
*/ */
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol { override fun referenceClass(declaration: ClassDescriptor): IrClassSymbol {
val irBuiltIns = this@SymbolTableWithBuiltInsDeduplication.irBuiltIns ?: return super.referenceClass(descriptor) 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 // 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. // `irBuiltIns.findClass` uses `referenceClass` recursively.
val builtInDescriptor = irBuiltIns.findBuiltInClassDescriptor(descriptor) val builtInDescriptor = irBuiltIns.findBuiltInClassDescriptor(declaration)
if (builtInDescriptor != null) { if (builtInDescriptor != null) {
// We need to delegate to the supertype implementation here to break recursion. `findBuiltInClassDescriptor` will return // We need to delegate to the supertype implementation here to break recursion. `findBuiltInClassDescriptor` will return
// `descriptor` even if `descriptor` was found via `findBuiltInClassDescriptor`. // `descriptor` even if `descriptor` was found via `findBuiltInClassDescriptor`.
return super.referenceClass(builtInDescriptor) return super.referenceClass(builtInDescriptor)
} }
return super.referenceClass(descriptor) return super.referenceClass(declaration)
} }
} }
compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt
+5 -5
View File
@@ -34,12 +34,12 @@ class FragmentCompilerSymbolTableDecorator(
} }
private inner class ExtensionDecorator : DescriptorSymbolTableExtension(this) { private inner class ExtensionDecorator : DescriptorSymbolTableExtension(this) {
override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol { override fun referenceValueParameter(declaration: ParameterDescriptor): IrValueParameterSymbol {
val fi = fragmentInfo ?: return super.referenceValueParameter(descriptor) 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 -> is ExtensionReceiver, is ContextReceiver -> { (targetDescriptor, _): EvaluatorFragmentParameterInfo ->
receiverValue == (targetDescriptor as? ReceiverParameterDescriptor)?.value receiverValue == (targetDescriptor as? ReceiverParameterDescriptor)?.value
} }
@@ -54,7 +54,7 @@ class FragmentCompilerSymbolTableDecorator(
if (parameterPosition > -1) { if (parameterPosition > -1) {
return super.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition]) return super.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition])
} }
return super.referenceValueParameter(descriptor) return super.referenceValueParameter(declaration)
} }
override fun referenceValue(value: ValueDescriptor): IrValueSymbol { override fun referenceValue(value: ValueDescriptor): IrValueSymbol {
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt
+31 -31
View File
@@ -25,98 +25,98 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo
private inner class ExtensionWrapper : DescriptorSymbolTableExtension(originalTable) { private inner class ExtensionWrapper : DescriptorSymbolTableExtension(originalTable) {
private val delegate get() = originalTable.descriptorExtension private val delegate get() = originalTable.descriptorExtension
override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol { override fun referenceClass(declaration: ClassDescriptor): IrClassSymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceClass(descriptor).also { return delegate.referenceClass(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generateClassStub(descriptor) stubGenerator?.generateClassStub(declaration)
} }
} }
} }
} }
override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol { override fun referenceTypeAlias(declaration: TypeAliasDescriptor): IrTypeAliasSymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceTypeAlias(descriptor).also { return delegate.referenceTypeAlias(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generateTypeAliasStub(descriptor) stubGenerator?.generateTypeAliasStub(declaration)
} }
} }
} }
} }
override fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol { override fun referenceConstructor(declaration: ClassConstructorDescriptor): IrConstructorSymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceConstructor(descriptor).also { return delegate.referenceConstructor(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generateConstructorStub(descriptor) stubGenerator?.generateConstructorStub(declaration)
} }
} }
} }
} }
override fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol { override fun referenceEnumEntry(declaration: ClassDescriptor): IrEnumEntrySymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceEnumEntry(descriptor).also { return delegate.referenceEnumEntry(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generateEnumEntryStub(descriptor) stubGenerator?.generateEnumEntryStub(declaration)
} }
} }
} }
} }
override fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { override fun referenceSimpleFunction(declaration: FunctionDescriptor): IrSimpleFunctionSymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceSimpleFunction(descriptor).also { return delegate.referenceSimpleFunction(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generateFunctionStub(descriptor) stubGenerator?.generateFunctionStub(declaration)
} }
} }
} }
} }
override fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol { override fun referenceProperty(declaration: PropertyDescriptor): IrPropertySymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceProperty(descriptor).also { return delegate.referenceProperty(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generatePropertyStub(descriptor) stubGenerator?.generatePropertyStub(declaration)
} }
} }
} }
} }
override fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol { override fun referenceTypeParameter(declaration: TypeParameterDescriptor): IrTypeParameterSymbol {
synchronized(lock) { synchronized(lock) {
return delegate.referenceTypeParameter(classifier).also { return delegate.referenceTypeParameter(declaration).also {
if (!it.isBound) { if (!it.isBound) {
stubGenerator?.generateOrGetTypeParameterStub(classifier) stubGenerator?.generateOrGetTypeParameterStub(declaration)
} }
} }
} }
} }
override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol { override fun referenceValueParameter(declaration: ParameterDescriptor): IrValueParameterSymbol {
return delegate.referenceValueParameter(descriptor) return delegate.referenceValueParameter(declaration)
} }
override fun referenceValue(value: ValueDescriptor): IrValueSymbol { override fun referenceValue(value: ValueDescriptor): IrValueSymbol {
return delegate.referenceValue(value) return delegate.referenceValue(value)
} }
override fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol { override fun referenceScript(declaration: ScriptDescriptor): IrScriptSymbol {
return delegate.referenceScript(descriptor) return delegate.referenceScript(declaration)
} }
override fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol { override fun referenceField(declaration: PropertyDescriptor): IrFieldSymbol {
return delegate.referenceField(descriptor) return delegate.referenceField(declaration)
} }
override fun referenceDeclaredFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { override fun referenceDeclaredFunction(declaration: FunctionDescriptor): IrSimpleFunctionSymbol {
return delegate.referenceDeclaredFunction(descriptor) return delegate.referenceDeclaredFunction(declaration)
} }
override fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol { override fun referenceScopedTypeParameter(declaration: TypeParameterDescriptor): IrTypeParameterSymbol {
return delegate.referenceScopedTypeParameter(classifier) return delegate.referenceScopedTypeParameter(declaration)
} }
} }
} }
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorSymbolTableExtension.kt
+53 -53
View File
@@ -80,17 +80,17 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
return IrScriptImpl(symbol, nameProvider.nameForDeclaration(script), irFactory, startOffset, endOffset) return IrScriptImpl(symbol, nameProvider.nameForDeclaration(script), irFactory, startOffset, endOffset)
} }
override fun createScriptSymbol(descriptor: ScriptDescriptor, signature: IdSignature?): IrScriptSymbol { override fun createScriptSymbol(declaration: ScriptDescriptor, signature: IdSignature?): IrScriptSymbol {
return IrScriptSymbolImpl(descriptor) return IrScriptSymbolImpl(declaration)
} }
// ------------------------------------ class ------------------------------------ // ------------------------------------ class ------------------------------------
override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol { override fun referenceClass(declaration: ClassDescriptor): IrClassSymbol {
return if (descriptor is IrBasedClassDescriptor) { return if (declaration is IrBasedClassDescriptor) {
descriptor.owner.symbol declaration.owner.symbol
} else { } 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 { override fun createPublicClassSymbol(declaration: ClassDescriptor, signature: IdSignature): IrClassSymbol {
return IrClassPublicSymbolImpl(signature, descriptor) return IrClassPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateClassSymbol(descriptor: ClassDescriptor): IrClassSymbol { override fun createPrivateClassSymbol(descriptor: ClassDescriptor): IrClassSymbol {
@@ -130,12 +130,12 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
) )
} }
override fun createPublicConstructorSymbol(descriptor: ClassConstructorDescriptor, signature: IdSignature): IrConstructorSymbol { override fun createPublicConstructorSymbol(declaration: ClassConstructorDescriptor, signature: IdSignature): IrConstructorSymbol {
return IrConstructorPublicSymbolImpl(signature, descriptor) return IrConstructorPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateConstructorSymbol(descriptor: ClassConstructorDescriptor): IrConstructorSymbol { override fun createPrivateConstructorSymbol(declaration: ClassConstructorDescriptor): IrConstructorSymbol {
return IrConstructorSymbolImpl(descriptor) return IrConstructorSymbolImpl(declaration)
} }
// ------------------------------------ enum entry ------------------------------------ // ------------------------------------ enum entry ------------------------------------
@@ -155,12 +155,12 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
) )
} }
override fun createPublicEnumEntrySymbol(descriptor: ClassDescriptor, signature: IdSignature): IrEnumEntrySymbol { override fun createPublicEnumEntrySymbol(declaration: ClassDescriptor, signature: IdSignature): IrEnumEntrySymbol {
return IrEnumEntryPublicSymbolImpl(signature, descriptor) return IrEnumEntryPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateEnumEntrySymbol(descriptor: ClassDescriptor): IrEnumEntrySymbol { override fun createPrivateEnumEntrySymbol(declaration: ClassDescriptor): IrEnumEntrySymbol {
return IrEnumEntrySymbolImpl(descriptor) return IrEnumEntrySymbolImpl(declaration)
} }
override fun defaultEnumEntryFactory( override fun defaultEnumEntryFactory(
@@ -175,19 +175,19 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
// ------------------------------------ field ------------------------------------ // ------------------------------------ field ------------------------------------
override fun createPublicFieldSymbol(descriptor: PropertyDescriptor, signature: IdSignature): IrFieldSymbol { override fun createPublicFieldSymbol(declaration: PropertyDescriptor, signature: IdSignature): IrFieldSymbol {
return IrFieldPublicSymbolImpl(signature, descriptor) return IrFieldPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateFieldSymbol(descriptor: PropertyDescriptor): IrFieldSymbol { override fun createPrivateFieldSymbol(declaration: PropertyDescriptor): IrFieldSymbol {
return IrFieldSymbolImpl(descriptor) return IrFieldSymbolImpl(declaration)
} }
override fun defaultFieldFactory( override fun defaultFieldFactory(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: PropertyDescriptor, declaration: PropertyDescriptor,
type: IrType, type: IrType,
visibility: DescriptorVisibility?, visibility: DescriptorVisibility?,
symbol: IrFieldSymbol, symbol: IrFieldSymbol,
@@ -196,7 +196,7 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
startOffset = startOffset, startOffset = startOffset,
endOffset = endOffset, endOffset = endOffset,
origin = origin, origin = origin,
name = nameProvider.nameForDeclaration(descriptor), name = nameProvider.nameForDeclaration(declaration),
visibility = visibility ?: symbol.descriptor.visibility, visibility = visibility ?: symbol.descriptor.visibility,
symbol = symbol, symbol = symbol,
type = type, type = type,
@@ -225,19 +225,19 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
) )
} }
override fun createPublicPropertySymbol(descriptor: PropertyDescriptor, signature: IdSignature): IrPropertySymbol { override fun createPublicPropertySymbol(declaration: PropertyDescriptor, signature: IdSignature): IrPropertySymbol {
return IrPropertyPublicSymbolImpl(signature, descriptor) return IrPropertyPublicSymbolImpl(signature, declaration)
} }
override fun createPrivatePropertySymbol(descriptor: PropertyDescriptor): IrPropertySymbol { override fun createPrivatePropertySymbol(declaration: PropertyDescriptor): IrPropertySymbol {
return IrPropertySymbolImpl(descriptor) return IrPropertySymbolImpl(declaration)
} }
override fun defaultPropertyFactory( override fun defaultPropertyFactory(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: PropertyDescriptor, declaration: PropertyDescriptor,
isDelegated: Boolean, isDelegated: Boolean,
symbol: IrPropertySymbol, symbol: IrPropertySymbol,
): IrProperty { ): IrProperty {
@@ -245,17 +245,17 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
startOffset = startOffset, startOffset = startOffset,
endOffset = endOffset, endOffset = endOffset,
origin = origin, origin = origin,
name = nameProvider.nameForDeclaration(descriptor), name = nameProvider.nameForDeclaration(declaration),
visibility = descriptor.visibility, visibility = declaration.visibility,
modality = descriptor.modality, modality = declaration.modality,
symbol = symbol, symbol = symbol,
isVar = descriptor.isVar, isVar = declaration.isVar,
isConst = descriptor.isConst, isConst = declaration.isConst,
isLateinit = descriptor.isLateInit, isLateinit = declaration.isLateInit,
isDelegated = isDelegated, isDelegated = isDelegated,
isExternal = descriptor.isEffectivelyExternal(), isExternal = declaration.isEffectivelyExternal(),
isExpect = descriptor.isExpect, isExpect = declaration.isExpect,
isFakeOverride = descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE, isFakeOverride = declaration.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE,
).apply { ).apply {
metadata = DescriptorMetadataSource.Property(symbol.descriptor) metadata = DescriptorMetadataSource.Property(symbol.descriptor)
} }
@@ -263,12 +263,12 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
// ------------------------------------ typealias ------------------------------------ // ------------------------------------ typealias ------------------------------------
override fun createPublicTypeAliasSymbol(descriptor: TypeAliasDescriptor, signature: IdSignature): IrTypeAliasSymbol { override fun createPublicTypeAliasSymbol(declaration: TypeAliasDescriptor, signature: IdSignature): IrTypeAliasSymbol {
return IrTypeAliasPublicSymbolImpl(signature, descriptor) return IrTypeAliasPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateTypeAliasSymbol(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol { override fun createPrivateTypeAliasSymbol(declaration: TypeAliasDescriptor): IrTypeAliasSymbol {
return IrTypeAliasSymbolImpl(descriptor) return IrTypeAliasSymbolImpl(declaration)
} }
// ------------------------------------ function ------------------------------------ // ------------------------------------ function ------------------------------------
@@ -288,36 +288,36 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
) )
} }
override fun createPublicFunctionSymbol(descriptor: FunctionDescriptor, signature: IdSignature): IrSimpleFunctionSymbol { override fun createPublicFunctionSymbol(declaration: FunctionDescriptor, signature: IdSignature): IrSimpleFunctionSymbol {
return IrSimpleFunctionPublicSymbolImpl(signature, descriptor) return IrSimpleFunctionPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateFunctionSymbol(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { override fun createPrivateFunctionSymbol(declaration: FunctionDescriptor): IrSimpleFunctionSymbol {
return IrSimpleFunctionSymbolImpl(descriptor) return IrSimpleFunctionSymbolImpl(declaration)
} }
// ------------------------------------ type parameter ------------------------------------ // ------------------------------------ type parameter ------------------------------------
override fun createPublicTypeParameterSymbol(descriptor: TypeParameterDescriptor, signature: IdSignature): IrTypeParameterSymbol { override fun createPublicTypeParameterSymbol(declaration: TypeParameterDescriptor, signature: IdSignature): IrTypeParameterSymbol {
return IrTypeParameterPublicSymbolImpl(signature, descriptor) return IrTypeParameterPublicSymbolImpl(signature, declaration)
} }
override fun createPrivateTypeParameterSymbol(descriptor: TypeParameterDescriptor): IrTypeParameterSymbol { override fun createPrivateTypeParameterSymbol(declaration: TypeParameterDescriptor): IrTypeParameterSymbol {
return IrTypeParameterSymbolImpl(descriptor) return IrTypeParameterSymbolImpl(declaration)
} }
override fun defaultTypeParameterFactory( override fun defaultTypeParameterFactory(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: TypeParameterDescriptor, declaration: TypeParameterDescriptor,
symbol: IrTypeParameterSymbol, symbol: IrTypeParameterSymbol,
): IrTypeParameter { ): IrTypeParameter {
return irFactory.createTypeParameter( return irFactory.createTypeParameter(
startOffset = startOffset, startOffset = startOffset,
endOffset = endOffset, endOffset = endOffset,
origin = origin, origin = origin,
name = nameProvider.nameForDeclaration(descriptor), name = nameProvider.nameForDeclaration(declaration),
symbol = symbol, symbol = symbol,
variance = symbol.descriptor.variance, variance = symbol.descriptor.variance,
index = symbol.descriptor.index, index = symbol.descriptor.index,
@@ -399,9 +399,9 @@ open class DescriptorSymbolTableExtension(table: SymbolTable) : SymbolTableExten
valueParameterSlice.introduceLocal(irValueParameter.descriptor, irValueParameter.symbol) valueParameterSlice.introduceLocal(irValueParameter.descriptor, irValueParameter.symbol)
} }
override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol { override fun referenceValueParameter(declaration: ParameterDescriptor): IrValueParameterSymbol {
return valueParameterSlice.referenced(descriptor) { return valueParameterSlice.referenced(declaration) {
error("Undefined parameter referenced: $descriptor\n${valueParameterSlice.dump()}") error("Undefined parameter referenced: $declaration\n${valueParameterSlice.dump()}")
} }
} }
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt
+146 -146
View File
@@ -14,18 +14,18 @@ import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.utils.threadLocal import org.jetbrains.kotlin.utils.threadLocal
abstract class ReferenceSymbolTableExtension<Class, TypeAlias, Script, Function, Constructor, Property, ValueParameter, TypeParameter> { abstract class ReferenceSymbolTableExtension<Class, TypeAlias, Script, Function, Constructor, Property, ValueParameter, TypeParameter> {
abstract fun referenceScript(descriptor: Script): IrScriptSymbol abstract fun referenceScript(declaration: Script): IrScriptSymbol
abstract fun referenceClass(descriptor: Class): IrClassSymbol abstract fun referenceClass(declaration: Class): IrClassSymbol
abstract fun referenceConstructor(descriptor: Constructor): IrConstructorSymbol abstract fun referenceConstructor(declaration: Constructor): IrConstructorSymbol
abstract fun referenceEnumEntry(descriptor: Class): IrEnumEntrySymbol abstract fun referenceEnumEntry(declaration: Class): IrEnumEntrySymbol
abstract fun referenceField(descriptor: Property): IrFieldSymbol abstract fun referenceField(declaration: Property): IrFieldSymbol
abstract fun referenceProperty(descriptor: Property): IrPropertySymbol abstract fun referenceProperty(declaration: Property): IrPropertySymbol
abstract fun referenceSimpleFunction(descriptor: Function): IrSimpleFunctionSymbol abstract fun referenceSimpleFunction(declaration: Function): IrSimpleFunctionSymbol
abstract fun referenceDeclaredFunction(descriptor: Function): IrSimpleFunctionSymbol abstract fun referenceDeclaredFunction(declaration: Function): IrSimpleFunctionSymbol
abstract fun referenceValueParameter(descriptor: ValueParameter): IrValueParameterSymbol abstract fun referenceValueParameter(declaration: ValueParameter): IrValueParameterSymbol
abstract fun referenceTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol abstract fun referenceTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol
abstract fun referenceScopedTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol abstract fun referenceScopedTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol
abstract fun referenceTypeAlias(descriptor: TypeAlias): IrTypeAliasSymbol abstract fun referenceTypeAlias(declaration: TypeAlias): IrTypeAliasSymbol
} }
typealias SymbolFactory<Declaration, Symbol> = (Declaration, IdSignature?) -> Symbol typealias SymbolFactory<Declaration, Symbol> = (Declaration, IdSignature?) -> Symbol
@@ -92,50 +92,50 @@ abstract class SymbolTableExtension<
fun declareScript( fun declareScript(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
descriptor: Script, declaration: Script,
): IrScript { ): IrScript {
return declare( return declare(
descriptor, declaration,
scriptSlice, scriptSlice,
SymbolTable::declareScript, SymbolTable::declareScript,
symbolFactory = { createScriptSymbol(descriptor, it) }, symbolFactory = { createScriptSymbol(declaration, it) },
ownerFactory = { defaultScriptFactory(startOffset, endOffset, descriptor, it) } ownerFactory = { defaultScriptFactory(startOffset, endOffset, declaration, it) }
) )
} }
override fun referenceScript(descriptor: Script): IrScriptSymbol { override fun referenceScript(declaration: Script): IrScriptSymbol {
return scriptSlice.referenced(descriptor) { createScriptSymbol(descriptor, signature = null) } return scriptSlice.referenced(declaration) { createScriptSymbol(declaration, signature = null) }
} }
protected abstract fun defaultScriptFactory(startOffset: Int, endOffset: Int, script: Script, symbol: IrScriptSymbol): IrScript 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 ------------------------------------ // ------------------------------------ script ------------------------------------
fun declareClass(descriptor: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass { fun declareClass(declaration: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass {
return declare( return declare(
descriptor, declaration,
classSlice, classSlice,
SymbolTable::declareClass, SymbolTable::declareClass,
{ createClassSymbol(descriptor, it) }, { createClassSymbol(declaration, it) },
classFactory classFactory
) )
} }
fun declareClassIfNotExists(descriptor: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass { fun declareClassIfNotExists(declaration: Class, classFactory: (IrClassSymbol) -> IrClass): IrClass {
return declareIfNotExist( return declareIfNotExist(
descriptor, declaration,
classSlice, classSlice,
SymbolTable::declareClassIfNotExists, SymbolTable::declareClassIfNotExists,
{ createClassSymbol(descriptor, it) }, { createClassSymbol(declaration, it) },
classFactory classFactory
) )
} }
override fun referenceClass(descriptor: Class): IrClassSymbol { override fun referenceClass(declaration: Class): IrClassSymbol {
return reference( return reference(
descriptor, declaration,
classSlice, classSlice,
SymbolTable::referenceClassImpl, SymbolTable::referenceClassImpl,
::createClassSymbol, ::createClassSymbol,
@@ -144,41 +144,41 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createClassSymbol(descriptor: Class, signature: IdSignature?): IrClassSymbol { protected fun createClassSymbol(declaration: Class, signature: IdSignature?): IrClassSymbol {
return signature?.let { createPublicClassSymbol(descriptor, signature) } ?: createPrivateClassSymbol(descriptor) 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 protected abstract fun createPrivateClassSymbol(descriptor: Class): IrClassSymbol
// ------------------------------------ constructor ------------------------------------ // ------------------------------------ constructor ------------------------------------
fun declareConstructor(descriptor: Constructor, constructorFactory: (IrConstructorSymbol) -> IrConstructor): IrConstructor { fun declareConstructor(declaration: Constructor, constructorFactory: (IrConstructorSymbol) -> IrConstructor): IrConstructor {
return declare( return declare(
descriptor, declaration,
constructorSlice, constructorSlice,
SymbolTable::declareConstructor, SymbolTable::declareConstructor,
{ createConstructorSymbol(descriptor, it) }, { createConstructorSymbol(declaration, it) },
constructorFactory constructorFactory
) )
} }
fun declareConstructorIfNotExists( fun declareConstructorIfNotExists(
descriptor: Constructor, declaration: Constructor,
constructorFactory: (IrConstructorSymbol) -> IrConstructor, constructorFactory: (IrConstructorSymbol) -> IrConstructor,
): IrConstructor { ): IrConstructor {
return declareIfNotExist( return declareIfNotExist(
descriptor, declaration,
constructorSlice, constructorSlice,
SymbolTable::declareConstructorIfNotExists, SymbolTable::declareConstructorIfNotExists,
{ createConstructorSymbol(descriptor, it) }, { createConstructorSymbol(declaration, it) },
constructorFactory constructorFactory
) )
} }
override fun referenceConstructor(descriptor: Constructor): IrConstructorSymbol { override fun referenceConstructor(declaration: Constructor): IrConstructorSymbol {
return reference( return reference(
descriptor, declaration,
constructorSlice, constructorSlice,
SymbolTable::referenceConstructorImpl, SymbolTable::referenceConstructorImpl,
::createConstructorSymbol, ::createConstructorSymbol,
@@ -187,46 +187,46 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createConstructorSymbol(descriptor: Constructor, signature: IdSignature?): IrConstructorSymbol { protected fun createConstructorSymbol(declaration: Constructor, signature: IdSignature?): IrConstructorSymbol {
return signature?.let { createPublicConstructorSymbol(descriptor, signature) } ?: createPrivateConstructorSymbol(descriptor) return signature?.let { createPublicConstructorSymbol(declaration, signature) } ?: createPrivateConstructorSymbol(declaration)
} }
protected abstract fun createPublicConstructorSymbol(descriptor: Constructor, signature: IdSignature): IrConstructorSymbol protected abstract fun createPublicConstructorSymbol(declaration: Constructor, signature: IdSignature): IrConstructorSymbol
protected abstract fun createPrivateConstructorSymbol(descriptor: Constructor): IrConstructorSymbol protected abstract fun createPrivateConstructorSymbol(declaration: Constructor): IrConstructorSymbol
// ------------------------------------ enum entry ------------------------------------ // ------------------------------------ enum entry ------------------------------------
fun declareEnumEntry(descriptor: Class, enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry { fun declareEnumEntry(declaration: Class, enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry {
return declare( return declare(
descriptor, declaration,
enumEntrySlice, enumEntrySlice,
SymbolTable::declareEnumEntry, SymbolTable::declareEnumEntry,
{ createEnumEntrySymbol(descriptor, it) }, { createEnumEntrySymbol(declaration, it) },
enumEntryFactory, enumEntryFactory,
::calculateEnumEntrySignature ::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( return declareEnumEntry(
descriptor declaration
) { enumEntrySymbol -> defaultEnumEntryFactory(startOffset, endOffset, origin, descriptor, enumEntrySymbol) } ) { 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( return declareIfNotExist(
descriptor, declaration,
enumEntrySlice, enumEntrySlice,
SymbolTable::declareEnumEntryIfNotExists, SymbolTable::declareEnumEntryIfNotExists,
{ createEnumEntrySymbol(descriptor, it) }, { createEnumEntrySymbol(declaration, it) },
enumEntryFactory, enumEntryFactory,
::calculateEnumEntrySignature ::calculateEnumEntrySignature
) )
} }
override fun referenceEnumEntry(descriptor: Class): IrEnumEntrySymbol { override fun referenceEnumEntry(declaration: Class): IrEnumEntrySymbol {
return reference( return reference(
descriptor, declaration,
enumEntrySlice, enumEntrySlice,
SymbolTable::referenceEnumEntryImpl, SymbolTable::referenceEnumEntryImpl,
::createEnumEntrySymbol, ::createEnumEntrySymbol,
@@ -236,12 +236,12 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createEnumEntrySymbol(descriptor: Class, signature: IdSignature?): IrEnumEntrySymbol { protected fun createEnumEntrySymbol(declaration: Class, signature: IdSignature?): IrEnumEntrySymbol {
return signature?.let { createPublicEnumEntrySymbol(descriptor, signature) } ?: createPrivateEnumEntrySymbol(descriptor) return signature?.let { createPublicEnumEntrySymbol(declaration, signature) } ?: createPrivateEnumEntrySymbol(declaration)
} }
protected abstract fun createPublicEnumEntrySymbol(descriptor: Class, signature: IdSignature): IrEnumEntrySymbol protected abstract fun createPublicEnumEntrySymbol(declaration: Class, signature: IdSignature): IrEnumEntrySymbol
protected abstract fun createPrivateEnumEntrySymbol(descriptor: Class): IrEnumEntrySymbol protected abstract fun createPrivateEnumEntrySymbol(declaration: Class): IrEnumEntrySymbol
protected abstract fun defaultEnumEntryFactory( protected abstract fun defaultEnumEntryFactory(
startOffset: Int, startOffset: Int,
@@ -257,7 +257,7 @@ abstract class SymbolTableExtension<
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: Property, declaration: Property,
type: IrType, type: IrType,
visibility: DescriptorVisibility? = null, visibility: DescriptorVisibility? = null,
fieldFactory: (IrFieldSymbol) -> IrField = { fieldFactory: (IrFieldSymbol) -> IrField = {
@@ -265,7 +265,7 @@ abstract class SymbolTableExtension<
startOffset, startOffset,
endOffset, endOffset,
origin, origin,
descriptor, declaration,
type, type,
visibility, visibility,
it it
@@ -273,10 +273,10 @@ abstract class SymbolTableExtension<
}, },
): IrField { ): IrField {
return declare( return declare(
descriptor, declaration,
fieldSlice, fieldSlice,
SymbolTable::declareField, SymbolTable::declareField,
{ createFieldSymbol(descriptor, it) }, { createFieldSymbol(declaration, it) },
fieldFactory, fieldFactory,
::calculateFieldSignature ::calculateFieldSignature
) )
@@ -286,18 +286,18 @@ abstract class SymbolTableExtension<
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: Property, declaration: Property,
type: IrType, type: IrType,
irInitializer: IrExpressionBody?, irInitializer: IrExpressionBody?,
): IrField { ): IrField {
return declareField(startOffset, endOffset, origin, descriptor, type).apply { return declareField(startOffset, endOffset, origin, declaration, type).apply {
initializer = irInitializer initializer = irInitializer
} }
} }
override fun referenceField(descriptor: Property): IrFieldSymbol { override fun referenceField(declaration: Property): IrFieldSymbol {
return reference( return reference(
descriptor, declaration,
fieldSlice, fieldSlice,
SymbolTable::referenceFieldImpl, SymbolTable::referenceFieldImpl,
::createFieldSymbol, ::createFieldSymbol,
@@ -307,18 +307,18 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createFieldSymbol(descriptor: Property, signature: IdSignature?): IrFieldSymbol { protected fun createFieldSymbol(declaration: Property, signature: IdSignature?): IrFieldSymbol {
return signature?.let { createPublicFieldSymbol(descriptor, signature) } ?: createPrivateFieldSymbol(descriptor) return signature?.let { createPublicFieldSymbol(declaration, signature) } ?: createPrivateFieldSymbol(declaration)
} }
protected abstract fun createPublicFieldSymbol(descriptor: Property, signature: IdSignature): IrFieldSymbol protected abstract fun createPublicFieldSymbol(declaration: Property, signature: IdSignature): IrFieldSymbol
protected abstract fun createPrivateFieldSymbol(descriptor: Property): IrFieldSymbol protected abstract fun createPrivateFieldSymbol(declaration: Property): IrFieldSymbol
protected abstract fun defaultFieldFactory( protected abstract fun defaultFieldFactory(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: Property, declaration: Property,
type: IrType, type: IrType,
visibility: DescriptorVisibility?, visibility: DescriptorVisibility?,
symbol: IrFieldSymbol, symbol: IrFieldSymbol,
@@ -326,12 +326,12 @@ abstract class SymbolTableExtension<
// ------------------------------------ property ------------------------------------ // ------------------------------------ property ------------------------------------
fun declareProperty(descriptor: Property, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty { fun declareProperty(declaration: Property, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty {
return declare( return declare(
descriptor, declaration,
propertySlice, propertySlice,
SymbolTable::declareProperty, SymbolTable::declareProperty,
{ createPropertySymbol(descriptor, it) }, { createPropertySymbol(declaration, it) },
propertyFactory propertyFactory
) )
} }
@@ -340,27 +340,27 @@ abstract class SymbolTableExtension<
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: Property, declaration: Property,
isDelegated: Boolean isDelegated: Boolean
): IrProperty { ): IrProperty {
return declareProperty(descriptor) { propertySymbol -> return declareProperty(declaration) { propertySymbol ->
defaultPropertyFactory(startOffset, endOffset, origin, descriptor, isDelegated, 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( return declareIfNotExist(
descriptor, declaration,
propertySlice, propertySlice,
SymbolTable::declarePropertyIfNotExists, SymbolTable::declarePropertyIfNotExists,
{ createPropertySymbol(descriptor, it) }, { createPropertySymbol(declaration, it) },
propertyFactory propertyFactory
) )
} }
override fun referenceProperty(descriptor: Property): IrPropertySymbol { override fun referenceProperty(declaration: Property): IrPropertySymbol {
return reference( return reference(
descriptor, declaration,
propertySlice, propertySlice,
SymbolTable::referencePropertyImpl, SymbolTable::referencePropertyImpl,
::createPropertySymbol, ::createPropertySymbol,
@@ -369,47 +369,47 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createPropertySymbol(descriptor: Property, signature: IdSignature?): IrPropertySymbol { protected fun createPropertySymbol(declaration: Property, signature: IdSignature?): IrPropertySymbol {
return signature?.let { createPublicPropertySymbol(descriptor, signature) } ?: createPrivatePropertySymbol(descriptor) return signature?.let { createPublicPropertySymbol(declaration, signature) } ?: createPrivatePropertySymbol(declaration)
} }
protected abstract fun createPublicPropertySymbol(descriptor: Property, signature: IdSignature): IrPropertySymbol protected abstract fun createPublicPropertySymbol(declaration: Property, signature: IdSignature): IrPropertySymbol
protected abstract fun createPrivatePropertySymbol(descriptor: Property): IrPropertySymbol protected abstract fun createPrivatePropertySymbol(declaration: Property): IrPropertySymbol
protected abstract fun defaultPropertyFactory( protected abstract fun defaultPropertyFactory(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: Property, declaration: Property,
isDelegated: Boolean, isDelegated: Boolean,
symbol: IrPropertySymbol, symbol: IrPropertySymbol,
): IrProperty ): IrProperty
// ------------------------------------ typealias ------------------------------------ // ------------------------------------ typealias ------------------------------------
fun declareTypeAlias(descriptor: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias { fun declareTypeAlias(declaration: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias {
return declare( return declare(
descriptor, declaration,
typeAliasSlice, typeAliasSlice,
SymbolTable::declareTypeAlias, SymbolTable::declareTypeAlias,
{ createTypeAliasSymbol(descriptor, it) }, { createTypeAliasSymbol(declaration, it) },
typeAliasFactory typeAliasFactory
) )
} }
fun declareTypeAliasIfNotExists(descriptor: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias { fun declareTypeAliasIfNotExists(declaration: TypeAlias, typeAliasFactory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias {
return declareIfNotExist( return declareIfNotExist(
descriptor, declaration,
typeAliasSlice, typeAliasSlice,
SymbolTable::declareTypeAliasIfNotExists, SymbolTable::declareTypeAliasIfNotExists,
{ createTypeAliasSymbol(descriptor, it) }, { createTypeAliasSymbol(declaration, it) },
typeAliasFactory typeAliasFactory
) )
} }
override fun referenceTypeAlias(descriptor: TypeAlias): IrTypeAliasSymbol { override fun referenceTypeAlias(declaration: TypeAlias): IrTypeAliasSymbol {
return reference( return reference(
descriptor, declaration,
typeAliasSlice, typeAliasSlice,
SymbolTable::referenceTypeAliasImpl, SymbolTable::referenceTypeAliasImpl,
::createTypeAliasSymbol, ::createTypeAliasSymbol,
@@ -418,41 +418,41 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createTypeAliasSymbol(descriptor: TypeAlias, signature: IdSignature?): IrTypeAliasSymbol { protected fun createTypeAliasSymbol(declaration: TypeAlias, signature: IdSignature?): IrTypeAliasSymbol {
return signature?.let { createPublicTypeAliasSymbol(descriptor, signature) } ?: createPrivateTypeAliasSymbol(descriptor) return signature?.let { createPublicTypeAliasSymbol(declaration, signature) } ?: createPrivateTypeAliasSymbol(declaration)
} }
protected abstract fun createPublicTypeAliasSymbol(descriptor: TypeAlias, signature: IdSignature): IrTypeAliasSymbol protected abstract fun createPublicTypeAliasSymbol(declaration: TypeAlias, signature: IdSignature): IrTypeAliasSymbol
protected abstract fun createPrivateTypeAliasSymbol(descriptor: TypeAlias): IrTypeAliasSymbol protected abstract fun createPrivateTypeAliasSymbol(declaration: TypeAlias): IrTypeAliasSymbol
// ------------------------------------ function ------------------------------------ // ------------------------------------ function ------------------------------------
fun declareSimpleFunction(descriptor: Function, functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction): IrSimpleFunction { fun declareSimpleFunction(declaration: Function, functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction): IrSimpleFunction {
return declare( return declare(
descriptor, declaration,
functionSlice, functionSlice,
SymbolTable::declareSimpleFunction, SymbolTable::declareSimpleFunction,
{ createFunctionSymbol(descriptor, it) }, { createFunctionSymbol(declaration, it) },
functionFactory functionFactory
) )
} }
fun declareSimpleFunctionIfNotExists( fun declareSimpleFunctionIfNotExists(
descriptor: Function, declaration: Function,
functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction, functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction,
): IrSimpleFunction { ): IrSimpleFunction {
return declareIfNotExist( return declareIfNotExist(
descriptor, declaration,
functionSlice, functionSlice,
SymbolTable::declareSimpleFunctionIfNotExists, SymbolTable::declareSimpleFunctionIfNotExists,
{ createFunctionSymbol(descriptor, it) }, { createFunctionSymbol(declaration, it) },
functionFactory functionFactory
) )
} }
override fun referenceSimpleFunction(descriptor: Function): IrSimpleFunctionSymbol { override fun referenceSimpleFunction(declaration: Function): IrSimpleFunctionSymbol {
return reference( return reference(
descriptor, declaration,
functionSlice, functionSlice,
SymbolTable::referenceSimpleFunctionImpl, SymbolTable::referenceSimpleFunctionImpl,
::createFunctionSymbol, ::createFunctionSymbol,
@@ -461,11 +461,11 @@ abstract class SymbolTableExtension<
) )
} }
override fun referenceDeclaredFunction(descriptor: Function): IrSimpleFunctionSymbol { override fun referenceDeclaredFunction(declaration: Function): IrSimpleFunctionSymbol {
fun throwError(): Nothing = error("Function is not declared: $descriptor") fun throwError(): Nothing = error("Function is not declared: $declaration")
return reference( return reference(
descriptor, declaration,
functionSlice, functionSlice,
SymbolTable::referenceSimpleFunctionImpl, SymbolTable::referenceSimpleFunctionImpl,
{ _, _ -> throwError() }, { _, _ -> throwError() },
@@ -474,24 +474,24 @@ abstract class SymbolTableExtension<
) )
} }
protected fun createFunctionSymbol(descriptor: Function, signature: IdSignature?): IrSimpleFunctionSymbol { protected fun createFunctionSymbol(declaration: Function, signature: IdSignature?): IrSimpleFunctionSymbol {
return signature?.let { createPublicFunctionSymbol(descriptor, signature) } ?: createPrivateFunctionSymbol(descriptor) return signature?.let { createPublicFunctionSymbol(declaration, signature) } ?: createPrivateFunctionSymbol(declaration)
} }
protected abstract fun createPublicFunctionSymbol(descriptor: Function, signature: IdSignature): IrSimpleFunctionSymbol protected abstract fun createPublicFunctionSymbol(declaration: Function, signature: IdSignature): IrSimpleFunctionSymbol
protected abstract fun createPrivateFunctionSymbol(descriptor: Function): IrSimpleFunctionSymbol protected abstract fun createPrivateFunctionSymbol(declaration: Function): IrSimpleFunctionSymbol
// ------------------------------------ type parameter ------------------------------------ // ------------------------------------ type parameter ------------------------------------
fun declareGlobalTypeParameter( fun declareGlobalTypeParameter(
descriptor: TypeParameter, declaration: TypeParameter,
typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter, typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter,
): IrTypeParameter { ): IrTypeParameter {
return declare( return declare(
descriptor, declaration,
globalTypeParameterSlice, globalTypeParameterSlice,
SymbolTable::declareGlobalTypeParameter, SymbolTable::declareGlobalTypeParameter,
{ createTypeParameterSymbol(descriptor, it) }, { createTypeParameterSymbol(declaration, it) },
typeParameterFactory typeParameterFactory
) )
} }
@@ -500,10 +500,10 @@ abstract class SymbolTableExtension<
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: TypeParameter, declaration: TypeParameter,
): IrTypeParameter { ): IrTypeParameter {
return declareGlobalTypeParameter(descriptor) { return declareGlobalTypeParameter(declaration) {
defaultTypeParameterFactory(startOffset, endOffset, origin, descriptor, it) defaultTypeParameterFactory(startOffset, endOffset, origin, declaration, it)
} }
} }
@@ -511,22 +511,22 @@ abstract class SymbolTableExtension<
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: TypeParameter, declaration: TypeParameter,
typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter = { typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter = {
defaultTypeParameterFactory(startOffset, endOffset, origin, descriptor, it) defaultTypeParameterFactory(startOffset, endOffset, origin, declaration, it)
}, },
): IrTypeParameter { ): IrTypeParameter {
return scopedTypeParameterSlice.declare( return scopedTypeParameterSlice.declare(
descriptor, declaration,
{ createTypeParameterSymbol(descriptor, calculateSignature(descriptor)) }, { createTypeParameterSymbol(declaration, calculateSignature(declaration)) },
typeParameterFactory typeParameterFactory
) )
} }
override fun referenceTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol { override fun referenceTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol {
scopedTypeParameterSlice.get(classifier)?.let { return it } scopedTypeParameterSlice.get(declaration)?.let { return it }
return reference( return reference(
classifier, declaration,
globalTypeParameterSlice, globalTypeParameterSlice,
SymbolTable::referenceTypeParameterImpl, SymbolTable::referenceTypeParameterImpl,
::createTypeParameterSymbol, ::createTypeParameterSymbol,
@@ -535,28 +535,28 @@ abstract class SymbolTableExtension<
) )
} }
override fun referenceScopedTypeParameter(classifier: TypeParameter): IrTypeParameterSymbol { override fun referenceScopedTypeParameter(declaration: TypeParameter): IrTypeParameterSymbol {
return scopedTypeParameterSlice.referenced(classifier) { createTypeParameterSymbol(classifier, calculateSignature(classifier)) } return scopedTypeParameterSlice.referenced(declaration) { createTypeParameterSymbol(declaration, calculateSignature(declaration)) }
} }
protected fun createTypeParameterSymbol(descriptor: TypeParameter, signature: IdSignature?): IrTypeParameterSymbol { protected fun createTypeParameterSymbol(declaration: TypeParameter, signature: IdSignature?): IrTypeParameterSymbol {
return signature?.let { createPublicTypeParameterSymbol(descriptor, signature) } ?: createPrivateTypeParameterSymbol(descriptor) return signature?.let { createPublicTypeParameterSymbol(declaration, signature) } ?: createPrivateTypeParameterSymbol(declaration)
} }
protected abstract fun createPublicTypeParameterSymbol(descriptor: TypeParameter, signature: IdSignature): IrTypeParameterSymbol protected abstract fun createPublicTypeParameterSymbol(declaration: TypeParameter, signature: IdSignature): IrTypeParameterSymbol
protected abstract fun createPrivateTypeParameterSymbol(descriptor: TypeParameter): IrTypeParameterSymbol protected abstract fun createPrivateTypeParameterSymbol(declaration: TypeParameter): IrTypeParameterSymbol
protected abstract fun defaultTypeParameterFactory( protected abstract fun defaultTypeParameterFactory(
startOffset: Int, startOffset: Int,
endOffset: Int, endOffset: Int,
origin: IrDeclarationOrigin, origin: IrDeclarationOrigin,
descriptor: TypeParameter, declaration: TypeParameter,
symbol: IrTypeParameterSymbol, symbol: IrTypeParameterSymbol,
): IrTypeParameter ): IrTypeParameter
// ------------------------------------ value parameter ------------------------------------ // ------------------------------------ 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") 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( private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declare(
descriptor: D, declaration: D,
slice: SymbolTableSlice<D, SymbolOwner, Symbol>, slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner, declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
crossinline symbolFactory: (IdSignature?) -> Symbol, crossinline symbolFactory: (IdSignature?) -> Symbol,
@@ -629,7 +629,7 @@ abstract class SymbolTableExtension<
specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) } specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) }
): SymbolOwner { ): SymbolOwner {
return declare( return declare(
descriptor, declaration,
slice, slice,
declareBySignature, declareBySignature,
SymbolTableSlice<D, SymbolOwner, Symbol>::declare, SymbolTableSlice<D, SymbolOwner, Symbol>::declare,
@@ -640,7 +640,7 @@ abstract class SymbolTableExtension<
} }
private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declareIfNotExist( private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declareIfNotExist(
descriptor: D, declaration: D,
slice: SymbolTableSlice<D, SymbolOwner, Symbol>, slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner, declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
crossinline symbolFactory: (IdSignature?) -> Symbol, crossinline symbolFactory: (IdSignature?) -> Symbol,
@@ -648,7 +648,7 @@ abstract class SymbolTableExtension<
specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) } specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) }
): SymbolOwner { ): SymbolOwner {
return declare( return declare(
descriptor, declaration,
slice, slice,
declareBySignature, declareBySignature,
SymbolTableSlice<D, SymbolOwner, Symbol>::declareIfNotExists, SymbolTableSlice<D, SymbolOwner, Symbol>::declareIfNotExists,
@@ -659,7 +659,7 @@ abstract class SymbolTableExtension<
} }
private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declare( private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> declare(
descriptor: D, declaration: D,
slice: SymbolTableSlice<D, SymbolOwner, Symbol>, slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner, declareBySignature: SymbolTable.(IdSignature, () -> Symbol, OwnerFactory<Symbol, SymbolOwner>) -> SymbolOwner,
declareByDeclaration: SymbolTableSlice<D, SymbolOwner, Symbol>.(D, () -> 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>, noinline ownerFactory: OwnerFactory<Symbol, SymbolOwner>,
specificCalculateSignature: (D) -> IdSignature? specificCalculateSignature: (D) -> IdSignature?
): SymbolOwner { ): SymbolOwner {
return when (val signature = specificCalculateSignature(descriptor)) { return when (val signature = specificCalculateSignature(declaration)) {
null -> slice.declareByDeclaration(descriptor, { symbolFactory(signature) }, ownerFactory) null -> slice.declareByDeclaration(declaration, { symbolFactory(signature) }, ownerFactory)
else -> table.declareBySignature(signature, { symbolFactory(signature) }, ownerFactory) else -> table.declareBySignature(signature, { symbolFactory(signature) }, ownerFactory)
} }
} }
private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> reference( private inline fun <D : Declaration, Symbol : IrBindableSymbol<*, SymbolOwner>, SymbolOwner : IrSymbolOwner> reference(
descriptor: D, declaration: D,
slice: SymbolTableSlice<D, SymbolOwner, Symbol>, slice: SymbolTableSlice<D, SymbolOwner, Symbol>,
referenceBySignature: SymbolTable.(IdSignature, () -> Symbol, () -> Symbol) -> Symbol, referenceBySignature: SymbolTable.(IdSignature, () -> Symbol, () -> Symbol) -> Symbol,
crossinline symbolFactory: (D, IdSignature?) -> Symbol, crossinline symbolFactory: (D, IdSignature?) -> Symbol,
@@ -682,12 +682,12 @@ abstract class SymbolTableExtension<
crossinline privateSymbolFactory: (D) -> Symbol, crossinline privateSymbolFactory: (D) -> Symbol,
specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) } specificCalculateSignature: (D) -> IdSignature? = { calculateSignature(it) }
): Symbol { ): Symbol {
return when (val signature = specificCalculateSignature(descriptor)) { return when (val signature = specificCalculateSignature(declaration)) {
null -> slice.referenced(descriptor) { symbolFactory(descriptor, signature) } null -> slice.referenced(declaration) { symbolFactory(declaration, signature) }
else -> table.referenceBySignature( else -> table.referenceBySignature(
signature, signature,
{ publicSymbolFactory(descriptor, signature) }, { publicSymbolFactory(declaration, signature) },
{ privateSymbolFactory(descriptor) } { privateSymbolFactory(declaration) }
) )
} }
} }