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

IR: slightly optimize IdSignature calculation in SymbolTable

Browse Source 
Do not compute IdSignature for descriptor a second time when adding a
new symbol. Instead, pass the calculated signature to the lambda in
declare/declareIfNotExists/referenced, and use it in `reference*`
methods.
This commit is contained in:
Alexander Udalov
2021-08-27 01:13:18 +02:00
parent 1c735948d1
commit 4da4719246
1 changed files with 88 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt
+88 -109
View File
@@ -76,17 +76,20 @@ open class SymbolTable(
private abstract class SymbolTableBase<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>>(val lock: IrLock) { private abstract class SymbolTableBase<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>>(val lock: IrLock) {
val unboundSymbols = linkedSetOf<S>() val unboundSymbols = linkedSetOf<S>()
abstract fun get(d: D): S? protected abstract fun signature(descriptor: D): IdSignature?
abstract fun get(d: D, sig: IdSignature?): S?
abstract fun set(s: S) abstract fun set(s: S)
abstract fun get(sig: IdSignature): S? abstract fun get(sig: IdSignature): S?
abstract fun set(sig: IdSignature, s: S) abstract fun set(sig: IdSignature, s: S)
inline fun declare(d: D, createSymbol: () -> S, createOwner: (S) -> B): B { inline fun declare(d: D, createSymbol: (IdSignature?) -> S, createOwner: (S) -> B): B {
synchronized(lock) { synchronized(lock) {
val existing = get(d) val signature = signature(d)
val existing = get(d, signature)
val symbol = if (existing == null) { val symbol = if (existing == null) {
checkOriginal(d) checkOriginal(d)
val new = createSymbol() val new = createSymbol(signature)
set(new) set(new)
new new
} else { } else {
@@ -113,12 +116,13 @@ open class SymbolTable(
} }
} }
inline fun declareIfNotExists(d: D, createSymbol: () -> S, createOwner: (S) -> B): B { inline fun declareIfNotExists(d: D, createSymbol: (IdSignature?) -> S, createOwner: (S) -> B): B {
synchronized(lock) { synchronized(lock) {
val existing = get(d) val signature = signature(d)
val existing = get(d, signature)
val symbol = if (existing == null) { val symbol = if (existing == null) {
checkOriginal(d) checkOriginal(d)
val new = createSymbol() val new = createSymbol(signature)
set(new) set(new)
new new
} else { } else {
@@ -145,12 +149,13 @@ open class SymbolTable(
} }
} }
inline fun referenced(d: D, reg: Boolean = true, orElse: () -> S): S { inline fun referenced(d: D, reg: Boolean = true, orElse: (IdSignature?) -> S): S {
synchronized(lock) { synchronized(lock) {
val s = get(d) val signature = signature(d)
val s = get(d, signature)
if (s == null) { if (s == null) {
checkOriginal(d) checkOriginal(d)
val new = orElse() val new = orElse(signature)
if (reg) { if (reg) {
assert(unboundSymbols.add(new)) { assert(unboundSymbols.add(new)) {
"Symbol for $new was already referenced" "Symbol for $new was already referenced"
@@ -192,16 +197,15 @@ open class SymbolTable(
val descriptorToSymbol = hashMapOf<D, S>() val descriptorToSymbol = hashMapOf<D, S>()
val idSigToSymbol = hashMapOf<IdSignature, S>() val idSigToSymbol = hashMapOf<IdSignature, S>()
protected open fun signature(descriptor: D): IdSignature? = signaturer.composeSignature(descriptor) override fun signature(descriptor: D): IdSignature? =
signaturer.composeSignature(descriptor)
override fun get(d: D): S? { override fun get(d: D, sig: IdSignature?): S? =
val sig = signature(d) if (sig != null) {
return if (sig != null) {
idSigToSymbol[sig] idSigToSymbol[sig]
} else { } else {
descriptorToSymbol[d] descriptorToSymbol[d]
} }
}
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
override fun set(s: S) { override fun set(s: S) {
@@ -234,22 +238,18 @@ open class SymbolTable(
private val descriptorToSymbol = hashMapOf<D, S>() private val descriptorToSymbol = hashMapOf<D, S>()
private val idSigToSymbol = hashMapOf<IdSignature, S>() private val idSigToSymbol = hashMapOf<IdSignature, S>()
private fun getByDescriptor(d: D): S? { private fun getByDescriptor(d: D): S? =
return descriptorToSymbol[d] ?: parent?.getByDescriptor(d) descriptorToSymbol[d] ?: parent?.getByDescriptor(d)
}
private fun getByIdSignature(sig: IdSignature): S? { private fun getByIdSignature(sig: IdSignature): S? =
return idSigToSymbol[sig] ?: parent?.getByIdSignature(sig) idSigToSymbol[sig] ?: parent?.getByIdSignature(sig)
}
operator fun get(d: D): S? { operator fun get(d: D, sig: IdSignature?): S? =
val sig = signaturer.composeSignature(d) if (sig != null) {
return if (sig != null) {
getByIdSignature(sig) getByIdSignature(sig)
} else { } else {
getByDescriptor(d) getByDescriptor(d)
} }
}
fun getLocal(d: D) = descriptorToSymbol[d] fun getLocal(d: D) = descriptorToSymbol[d]
@@ -264,7 +264,8 @@ open class SymbolTable(
} }
} }
operator fun get(sig: IdSignature): S? = idSigToSymbol[sig] ?: parent?.get(sig) operator fun get(sig: IdSignature): S? =
idSigToSymbol[sig] ?: parent?.get(sig)
operator fun set(sig: IdSignature, s: S) { operator fun set(sig: IdSignature, s: S) {
idSigToSymbol[sig] = s idSigToSymbol[sig] = s
@@ -285,9 +286,12 @@ open class SymbolTable(
private var currentScope: Scope? = null private var currentScope: Scope? = null
override fun get(d: D): S? { override fun signature(descriptor: D): IdSignature? =
signaturer.composeSignature(descriptor)
override fun get(d: D, sig: IdSignature?): S? {
val scope = currentScope ?: return null val scope = currentScope ?: return null
return scope[d] return scope[d, sig]
} }
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
@@ -314,7 +318,7 @@ open class SymbolTable(
fun introduceLocal(descriptor: D, symbol: S) { fun introduceLocal(descriptor: D, symbol: S) {
val scope = currentScope ?: throw AssertionError("No active scope") val scope = currentScope ?: throw AssertionError("No active scope")
scope[descriptor]?.let { scope[descriptor, signature(descriptor)]?.let {
throw AssertionError("$descriptor is already bound to $it") throw AssertionError("$descriptor is already bound to $it")
} }
scope[descriptor] = symbol scope[descriptor] = symbol
@@ -426,13 +430,11 @@ open class SymbolTable(
) )
} }
override fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol { override fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol =
return scriptSymbolTable.referenced(descriptor) { IrScriptSymbolImpl(descriptor) } scriptSymbolTable.referenced(descriptor) { IrScriptSymbolImpl(descriptor) }
}
private fun createClassSymbol(descriptor: ClassDescriptor): IrClassSymbol { private fun createClassSymbol(descriptor: ClassDescriptor, signature: IdSignature?): IrClassSymbol =
return signaturer.composeSignature(descriptor)?.let { IrClassPublicSymbolImpl(it, descriptor) } ?: IrClassSymbolImpl(descriptor) signature?.let { IrClassPublicSymbolImpl(it, descriptor) } ?: IrClassSymbolImpl(descriptor)
}
fun declareClass( fun declareClass(
descriptor: ClassDescriptor, descriptor: ClassDescriptor,
@@ -440,7 +442,7 @@ open class SymbolTable(
): IrClass { ): IrClass {
return classSymbolTable.declare( return classSymbolTable.declare(
descriptor, descriptor,
{ createClassSymbol(descriptor) }, { createClassSymbol(descriptor, signaturer.composeSignature(descriptor)) },
classFactory classFactory
) )
} }
@@ -457,9 +459,8 @@ open class SymbolTable(
) )
} }
fun declareClassIfNotExists(descriptor: ClassDescriptor, classFactory: (IrClassSymbol) -> IrClass): IrClass { fun declareClassIfNotExists(descriptor: ClassDescriptor, classFactory: (IrClassSymbol) -> IrClass): IrClass =
return classSymbolTable.declareIfNotExists(descriptor, { createClassSymbol(descriptor) }, classFactory) classSymbolTable.declareIfNotExists(descriptor, { signature -> createClassSymbol(descriptor, signature) }, classFactory)
}
fun declareClassFromLinker(descriptor: ClassDescriptor, sig: IdSignature, factory: (IrClassSymbol) -> IrClass): IrClass { fun declareClassFromLinker(descriptor: ClassDescriptor, sig: IdSignature, factory: (IrClassSymbol) -> IrClass): IrClass {
return classSymbolTable.run { return classSymbolTable.run {
@@ -471,8 +472,8 @@ open class SymbolTable(
} }
} }
override fun referenceClass(descriptor: ClassDescriptor) = override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol =
classSymbolTable.referenced(descriptor) { createClassSymbol(descriptor) } classSymbolTable.referenced(descriptor) { signature -> createClassSymbol(descriptor, signature) }
fun referenceClass( fun referenceClass(
sig: IdSignature, sig: IdSignature,
@@ -492,11 +493,8 @@ open class SymbolTable(
val unboundClasses: Set<IrClassSymbol> get() = classSymbolTable.unboundSymbols val unboundClasses: Set<IrClassSymbol> get() = classSymbolTable.unboundSymbols
private fun createConstructorSymbol(descriptor: ClassConstructorDescriptor): IrConstructorSymbol { private fun createConstructorSymbol(descriptor: ClassConstructorDescriptor, signature: IdSignature?): IrConstructorSymbol =
return signaturer.composeSignature(descriptor)?.let { IrConstructorPublicSymbolImpl(it, descriptor) } ?: IrConstructorSymbolImpl( signature?.let { IrConstructorPublicSymbolImpl(it, descriptor) } ?: IrConstructorSymbolImpl(descriptor)
descriptor
)
}
fun declareConstructor( fun declareConstructor(
descriptor: ClassConstructorDescriptor, descriptor: ClassConstructorDescriptor,
@@ -504,7 +502,7 @@ open class SymbolTable(
): IrConstructor = ): IrConstructor =
constructorSymbolTable.declare( constructorSymbolTable.declare(
descriptor, descriptor,
{ createConstructorSymbol(descriptor) }, { signature -> createConstructorSymbol(descriptor, signature) },
constructorFactory constructorFactory
) )
@@ -526,7 +524,7 @@ open class SymbolTable(
): IrConstructor = ): IrConstructor =
constructorSymbolTable.declareIfNotExists( constructorSymbolTable.declareIfNotExists(
descriptor, descriptor,
{ createConstructorSymbol(descriptor) }, { signature -> createConstructorSymbol(descriptor, signature) },
constructorFactory constructorFactory
) )
@@ -534,8 +532,8 @@ open class SymbolTable(
constructorSymbolTable.set(sig, symbol) constructorSymbolTable.set(sig, symbol)
} }
override fun referenceConstructor(descriptor: ClassConstructorDescriptor) = override fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol =
constructorSymbolTable.referenced(descriptor) { createConstructorSymbol(descriptor) } constructorSymbolTable.referenced(descriptor) { signature -> createConstructorSymbol(descriptor, signature) }
fun referenceConstructorIfAny(sig: IdSignature): IrConstructorSymbol? = fun referenceConstructorIfAny(sig: IdSignature): IrConstructorSymbol? =
constructorSymbolTable.get(sig) constructorSymbolTable.get(sig)
@@ -562,10 +560,8 @@ open class SymbolTable(
val unboundConstructors: Set<IrConstructorSymbol> get() = constructorSymbolTable.unboundSymbols val unboundConstructors: Set<IrConstructorSymbol> get() = constructorSymbolTable.unboundSymbols
private fun createEnumEntrySymbol(descriptor: ClassDescriptor): IrEnumEntrySymbol { private fun createEnumEntrySymbol(descriptor: ClassDescriptor, signature: IdSignature?): IrEnumEntrySymbol =
return signaturer.composeEnumEntrySignature(descriptor)?.let { IrEnumEntryPublicSymbolImpl(it, descriptor) } signature?.let { IrEnumEntryPublicSymbolImpl(it, descriptor) } ?: IrEnumEntrySymbolImpl(descriptor)
?: IrEnumEntrySymbolImpl(descriptor)
}
fun declareEnumEntry( fun declareEnumEntry(
startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: ClassDescriptor, startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: ClassDescriptor,
@@ -575,7 +571,7 @@ open class SymbolTable(
): IrEnumEntry = ): IrEnumEntry =
enumEntrySymbolTable.declare( enumEntrySymbolTable.declare(
descriptor, descriptor,
{ createEnumEntrySymbol(descriptor) }, { signature -> createEnumEntrySymbol(descriptor, signature) },
factory factory
) )
@@ -585,9 +581,8 @@ open class SymbolTable(
enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry
): IrEnumEntry = enumEntrySymbolTable.declare(sig, symbolFactory, enumEntryFactory) ): IrEnumEntry = enumEntrySymbolTable.declare(sig, symbolFactory, enumEntryFactory)
fun declareEnumEntryIfNotExists(descriptor: ClassDescriptor, factory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry { fun declareEnumEntryIfNotExists(descriptor: ClassDescriptor, factory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry =
return enumEntrySymbolTable.declareIfNotExists(descriptor, { createEnumEntrySymbol(descriptor) }, factory) enumEntrySymbolTable.declareIfNotExists(descriptor, { signature -> createEnumEntrySymbol(descriptor, signature) }, factory)
}
fun declareEnumEntryFromLinker( fun declareEnumEntryFromLinker(
descriptor: ClassDescriptor, descriptor: ClassDescriptor,
@@ -603,8 +598,8 @@ open class SymbolTable(
} }
} }
override fun referenceEnumEntry(descriptor: ClassDescriptor) = override fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol =
enumEntrySymbolTable.referenced(descriptor) { createEnumEntrySymbol(descriptor) } enumEntrySymbolTable.referenced(descriptor) { signature -> createEnumEntrySymbol(descriptor, signature) }
override fun referenceEnumEntryFromLinker(sig: IdSignature) = override fun referenceEnumEntryFromLinker(sig: IdSignature) =
enumEntrySymbolTable.run { enumEntrySymbolTable.run {
@@ -614,10 +609,8 @@ open class SymbolTable(
val unboundEnumEntries: Set<IrEnumEntrySymbol> get() = enumEntrySymbolTable.unboundSymbols val unboundEnumEntries: Set<IrEnumEntrySymbol> get() = enumEntrySymbolTable.unboundSymbols
private fun createFieldSymbol(descriptor: PropertyDescriptor): IrFieldSymbol { private fun createFieldSymbol(descriptor: PropertyDescriptor, signature: IdSignature?): IrFieldSymbol =
return signaturer.composeFieldSignature(descriptor)?.let { IrFieldPublicSymbolImpl(it, descriptor) } signature?.let { IrFieldPublicSymbolImpl(it, descriptor) } ?: IrFieldSymbolImpl(descriptor)
?: IrFieldSymbolImpl(descriptor)
}
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
fun declareField( fun declareField(
@@ -639,7 +632,7 @@ open class SymbolTable(
): IrField = ): IrField =
fieldSymbolTable.declare( fieldSymbolTable.declare(
descriptor, descriptor,
{ createFieldSymbol(descriptor) }, { signature -> createFieldSymbol(descriptor, signature) },
fieldFactory fieldFactory
) )
@@ -674,8 +667,8 @@ open class SymbolTable(
} }
} }
override fun referenceField(descriptor: PropertyDescriptor) = override fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol =
fieldSymbolTable.referenced(descriptor) { createFieldSymbol(descriptor) } fieldSymbolTable.referenced(descriptor) { signature -> createFieldSymbol(descriptor, signature) }
override fun referenceFieldFromLinker(sig: IdSignature): IrFieldSymbol = override fun referenceFieldFromLinker(sig: IdSignature): IrFieldSymbol =
fieldSymbolTable.run { fieldSymbolTable.run {
@@ -691,12 +684,8 @@ open class SymbolTable(
@Suppress("DEPRECATION") @Suppress("DEPRECATION")
propertyTable.getOrPut(descriptor, generate) propertyTable.getOrPut(descriptor, generate)
private fun createPropertySymbol(descriptor: PropertyDescriptor): IrPropertySymbol { private fun createPropertySymbol(descriptor: PropertyDescriptor, signature: IdSignature?): IrPropertySymbol =
return signaturer.composeSignature(descriptor)?.let { IrPropertyPublicSymbolImpl(it, descriptor) } ?: IrPropertySymbolImpl( signature?.let { IrPropertyPublicSymbolImpl(it, descriptor) } ?: IrPropertySymbolImpl(descriptor)
descriptor
)
}
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
fun declareProperty( fun declareProperty(
@@ -724,7 +713,7 @@ open class SymbolTable(
): IrProperty = ): IrProperty =
propertySymbolTable.declare( propertySymbolTable.declare(
descriptor, descriptor,
{ createPropertySymbol(descriptor) }, { signature -> createPropertySymbol(descriptor, signature) },
propertyFactory propertyFactory
) )
@@ -741,7 +730,7 @@ open class SymbolTable(
} }
fun declarePropertyIfNotExists(descriptor: PropertyDescriptor, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty = fun declarePropertyIfNotExists(descriptor: PropertyDescriptor, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty =
propertySymbolTable.declareIfNotExists(descriptor, { createPropertySymbol(descriptor) }, propertyFactory) propertySymbolTable.declareIfNotExists(descriptor, { signature -> createPropertySymbol(descriptor, signature) }, propertyFactory)
fun declarePropertyFromLinker(descriptor: PropertyDescriptor, sig: IdSignature, factory: (IrPropertySymbol) -> IrProperty): IrProperty { fun declarePropertyFromLinker(descriptor: PropertyDescriptor, sig: IdSignature, factory: (IrPropertySymbol) -> IrProperty): IrProperty {
return propertySymbolTable.run { return propertySymbolTable.run {
@@ -754,7 +743,7 @@ open class SymbolTable(
} }
override fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol = override fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol =
propertySymbolTable.referenced(descriptor) { createPropertySymbol(descriptor) } propertySymbolTable.referenced(descriptor) { signature -> createPropertySymbol(descriptor, signature) }
fun referencePropertyIfAny(sig: IdSignature): IrPropertySymbol? = fun referencePropertyIfAny(sig: IdSignature): IrPropertySymbol? =
propertySymbolTable.get(sig) propertySymbolTable.get(sig)
@@ -767,14 +756,11 @@ open class SymbolTable(
val unboundProperties: Set<IrPropertySymbol> get() = propertySymbolTable.unboundSymbols val unboundProperties: Set<IrPropertySymbol> get() = propertySymbolTable.unboundSymbols
private fun createTypeAliasSymbol(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol { private fun createTypeAliasSymbol(descriptor: TypeAliasDescriptor, signature: IdSignature?): IrTypeAliasSymbol =
return signaturer.composeSignature(descriptor)?.let { IrTypeAliasPublicSymbolImpl(it, descriptor) } ?: IrTypeAliasSymbolImpl( signature?.let { IrTypeAliasPublicSymbolImpl(it, descriptor) } ?: IrTypeAliasSymbolImpl(descriptor)
descriptor
)
}
override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol = override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol =
typeAliasSymbolTable.referenced(descriptor) { createTypeAliasSymbol(descriptor) } typeAliasSymbolTable.referenced(descriptor) { signature -> createTypeAliasSymbol(descriptor, signature) }
override fun referenceTypeAliasFromLinker(sig: IdSignature) = override fun referenceTypeAliasFromLinker(sig: IdSignature) =
typeAliasSymbolTable.run { typeAliasSymbolTable.run {
@@ -783,7 +769,7 @@ open class SymbolTable(
} }
fun declareTypeAlias(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias = fun declareTypeAlias(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias =
typeAliasSymbolTable.declare(descriptor, { createTypeAliasSymbol(descriptor) }, factory) typeAliasSymbolTable.declare(descriptor, { signature -> createTypeAliasSymbol(descriptor, signature) }, factory)
fun declareTypeAlias( fun declareTypeAlias(
sig: IdSignature, sig: IdSignature,
@@ -794,14 +780,12 @@ open class SymbolTable(
} }
fun declareTypeAliasIfNotExists(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias = fun declareTypeAliasIfNotExists(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias =
typeAliasSymbolTable.declareIfNotExists(descriptor, { createTypeAliasSymbol(descriptor) }, factory) typeAliasSymbolTable.declareIfNotExists(descriptor, { signature -> createTypeAliasSymbol(descriptor, signature) }, factory)
val unboundTypeAliases: Set<IrTypeAliasSymbol> get() = typeAliasSymbolTable.unboundSymbols val unboundTypeAliases: Set<IrTypeAliasSymbol> get() = typeAliasSymbolTable.unboundSymbols
private fun createSimpleFunctionSymbol(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { private fun createSimpleFunctionSymbol(descriptor: FunctionDescriptor, signature: IdSignature?): IrSimpleFunctionSymbol =
return signaturer.composeSignature(descriptor)?.let { IrSimpleFunctionPublicSymbolImpl(it, descriptor) } signature?.let { IrSimpleFunctionPublicSymbolImpl(it, descriptor) } ?: IrSimpleFunctionSymbolImpl(descriptor)
?: IrSimpleFunctionSymbolImpl(descriptor)
}
fun declareSimpleFunction( fun declareSimpleFunction(
descriptor: FunctionDescriptor, descriptor: FunctionDescriptor,
@@ -809,7 +793,7 @@ open class SymbolTable(
): IrSimpleFunction { ): IrSimpleFunction {
return simpleFunctionSymbolTable.declare( return simpleFunctionSymbolTable.declare(
descriptor, descriptor,
{ createSimpleFunctionSymbol(descriptor) }, { signature -> createSimpleFunctionSymbol(descriptor, signature) },
functionFactory functionFactory
) )
} }
@@ -829,9 +813,10 @@ open class SymbolTable(
fun declareSimpleFunctionIfNotExists( fun declareSimpleFunctionIfNotExists(
descriptor: FunctionDescriptor, descriptor: FunctionDescriptor,
functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction
): IrSimpleFunction { ): IrSimpleFunction =
return simpleFunctionSymbolTable.declareIfNotExists(descriptor, { createSimpleFunctionSymbol(descriptor) }, functionFactory) simpleFunctionSymbolTable.declareIfNotExists(
} descriptor, { signature -> createSimpleFunctionSymbol(descriptor, signature) }, functionFactory
)
fun declareSimpleFunctionFromLinker( fun declareSimpleFunctionFromLinker(
descriptor: FunctionDescriptor?, descriptor: FunctionDescriptor?,
@@ -847,8 +832,8 @@ open class SymbolTable(
} }
} }
override fun referenceSimpleFunction(descriptor: FunctionDescriptor) = override fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol =
simpleFunctionSymbolTable.referenced(descriptor) { createSimpleFunctionSymbol(descriptor) } simpleFunctionSymbolTable.referenced(descriptor) { signature -> createSimpleFunctionSymbol(descriptor, signature) }
fun referenceSimpleFunctionIfAny(sig: IdSignature): IrSimpleFunctionSymbol? = fun referenceSimpleFunctionIfAny(sig: IdSignature): IrSimpleFunctionSymbol? =
simpleFunctionSymbolTable.get(sig) simpleFunctionSymbolTable.get(sig)
@@ -865,10 +850,8 @@ open class SymbolTable(
val unboundSimpleFunctions: Set<IrSimpleFunctionSymbol> get() = simpleFunctionSymbolTable.unboundSymbols val unboundSimpleFunctions: Set<IrSimpleFunctionSymbol> get() = simpleFunctionSymbolTable.unboundSymbols
private fun createTypeParameterSymbol(descriptor: TypeParameterDescriptor): IrTypeParameterSymbol { private fun createTypeParameterSymbol(descriptor: TypeParameterDescriptor, signature: IdSignature?): IrTypeParameterSymbol =
return signaturer.composeSignature(descriptor)?.let { IrTypeParameterPublicSymbolImpl(it, descriptor) } signature?.let { IrTypeParameterPublicSymbolImpl(it, descriptor) } ?: IrTypeParameterSymbolImpl(descriptor)
?: IrTypeParameterSymbolImpl(descriptor)
}
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
fun declareGlobalTypeParameter( fun declareGlobalTypeParameter(
@@ -885,7 +868,7 @@ open class SymbolTable(
): IrTypeParameter = ): IrTypeParameter =
globalTypeParameterSymbolTable.declare( globalTypeParameterSymbolTable.declare(
descriptor, descriptor,
{ createTypeParameterSymbol(descriptor) }, { signature -> createTypeParameterSymbol(descriptor, signature) },
typeParameterFactory typeParameterFactory
) )
@@ -912,7 +895,7 @@ open class SymbolTable(
): IrTypeParameter = ): IrTypeParameter =
scopedTypeParameterSymbolTable.declare( scopedTypeParameterSymbolTable.declare(
descriptor, descriptor,
{ createTypeParameterSymbol(descriptor) }, { signature -> createTypeParameterSymbol(descriptor, signature) },
typeParameterFactory typeParameterFactory
) )
@@ -976,20 +959,16 @@ open class SymbolTable(
} }
override fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol = override fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol =
scopedTypeParameterSymbolTable.get(classifier) ?: globalTypeParameterSymbolTable.referenced(classifier) { scopedTypeParameterSymbolTable.get(classifier, signaturer.composeSignature(classifier))
createTypeParameterSymbol(classifier) ?: globalTypeParameterSymbolTable.referenced(classifier) { signature -> createTypeParameterSymbol(classifier, signature) }
}
override fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol = override fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol =
scopedTypeParameterSymbolTable.referenced(classifier) { scopedTypeParameterSymbolTable.referenced(classifier) { signature -> createTypeParameterSymbol(classifier, signature) }
createTypeParameterSymbol(classifier)
}
override fun referenceGlobalTypeParameterFromLinker(sig: IdSignature): IrTypeParameterSymbol { override fun referenceGlobalTypeParameterFromLinker(sig: IdSignature): IrTypeParameterSymbol =
return globalTypeParameterSymbolTable.referenced(sig, false) { globalTypeParameterSymbolTable.referenced(sig, false) {
if (sig.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(sig) else IrTypeParameterSymbolImpl() if (sig.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(sig) else IrTypeParameterSymbolImpl()
} }
}
fun declareVariable( fun declareVariable(
startOffset: Int, startOffset: Int,