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

[IR] Give generic parameters proper names in IrSymbol-related classes

Browse Source 
Single-letter names were very confusing, especially in declarations like

```kotlin
private inline fun <
        reified D : IrDeclaration,
        reified ES : IrDelegatingSymbol<AS, D, *>,
        reified AS : IrBindableSymbol<*, D>
        > finalizeExpectActual(
    expectSymbol: ES,
    actualSymbol: IrSymbol,
    noinline actualizer: (e: D, a: D) -> Unit
)
```
This commit is contained in:
Sergej Jaskiewicz
2023-05-10 14:23:28 +02:00
committed by Space Team
parent 88d68f77e5
commit e473eaa5d6
6 changed files with 245 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrDelegatingSymbol.kt
+8 -6
View File
@@ -10,12 +10,14 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.util.IdSignature import org.jetbrains.kotlin.ir.util.IdSignature
abstract class IrDelegatingSymbol<S : IrBindableSymbol<D, B>, B : IrSymbolOwner, D : DeclarationDescriptor>(var delegate: S) : abstract class IrDelegatingSymbol<DelegateSymbol, Owner, Descriptor>(var delegate: DelegateSymbol) : IrBindableSymbol<Descriptor, Owner>
IrBindableSymbol<D, B> { where DelegateSymbol : IrBindableSymbol<Descriptor, Owner>,
override val owner: B get() = delegate.owner Owner : IrSymbolOwner,
Descriptor : DeclarationDescriptor {
override val owner: Owner get() = delegate.owner
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override val descriptor: D get() = delegate.descriptor override val descriptor: Descriptor get() = delegate.descriptor
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override val hasDescriptor: Boolean override val hasDescriptor: Boolean
@@ -26,7 +28,7 @@ abstract class IrDelegatingSymbol<S : IrBindableSymbol<D, B>, B : IrSymbolOwner,
override val signature: IdSignature? override val signature: IdSignature?
get() = delegate.signature get() = delegate.signature
override fun bind(owner: B) = delegate.bind(owner) override fun bind(owner: Owner) = delegate.bind(owner)
override fun hashCode() = delegate.hashCode() override fun hashCode() = delegate.hashCode()
override fun equals(other: Any?): Boolean { override fun equals(other: Any?): Boolean {
if (this === other) return true if (this === other) return true
@@ -59,7 +61,7 @@ class IrDelegatingPropertySymbolImpl(delegate: IrPropertySymbol) :
class IrDelegatingTypeAliasSymbolImpl(delegate: IrTypeAliasSymbol) : class IrDelegatingTypeAliasSymbolImpl(delegate: IrTypeAliasSymbol) :
IrTypeAliasSymbol, IrDelegatingSymbol<IrTypeAliasSymbol, IrTypeAlias, TypeAliasDescriptor>(delegate) IrTypeAliasSymbol, IrDelegatingSymbol<IrTypeAliasSymbol, IrTypeAlias, TypeAliasDescriptor>(delegate)
fun wrapInDelegatedSymbol(delegate: IrSymbol) = when(delegate) { fun wrapInDelegatedSymbol(delegate: IrSymbol) = when (delegate) {
is IrClassSymbol -> IrDelegatingClassSymbolImpl(delegate) is IrClassSymbol -> IrDelegatingClassSymbolImpl(delegate)
is IrEnumEntrySymbol -> IrDelegatingEnumEntrySymbolImpl(delegate) is IrEnumEntrySymbol -> IrDelegatingEnumEntrySymbolImpl(delegate)
is IrSimpleFunctionSymbol -> IrDelegatingSimpleFunctionSymbolImpl(delegate) is IrSimpleFunctionSymbol -> IrDelegatingSimpleFunctionSymbolImpl(delegate)
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt
+4 -4
View File
@@ -45,13 +45,13 @@ interface IrSymbol {
val IrSymbol.isPublicApi: Boolean val IrSymbol.isPublicApi: Boolean
get() = signature != null get() = signature != null
interface IrBindableSymbol<out D : DeclarationDescriptor, B : IrSymbolOwner> : IrSymbol { interface IrBindableSymbol<out Descriptor : DeclarationDescriptor, Owner : IrSymbolOwner> : IrSymbol {
override val owner: B override val owner: Owner
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override val descriptor: D override val descriptor: Descriptor
fun bind(owner: B) fun bind(owner: Owner)
} }
sealed interface IrPackageFragmentSymbol : IrSymbol { sealed interface IrPackageFragmentSymbol : IrSymbol {
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPrivateSymbolBase.kt
+12 -9
View File
@@ -15,13 +15,13 @@ import org.jetbrains.kotlin.ir.util.IdSignature
import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.ir.util.render
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
abstract class IrSymbolBase<out D : DeclarationDescriptor>( abstract class IrSymbolBase<out Descriptor : DeclarationDescriptor>(
private val _descriptor: D? private val _descriptor: Descriptor?
) : IrSymbol { ) : IrSymbol {
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
override val descriptor: D override val descriptor: Descriptor
get() = _descriptor ?: (owner as IrDeclaration).toIrBasedDescriptor() as D get() = _descriptor ?: (owner as IrDeclaration).toIrBasedDescriptor() as Descriptor
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override val hasDescriptor: Boolean override val hasDescriptor: Boolean
@@ -34,8 +34,11 @@ abstract class IrSymbolBase<out D : DeclarationDescriptor>(
} }
} }
abstract class IrBindableSymbolBase<out D : DeclarationDescriptor, B : IrSymbolOwner>(descriptor: D?) : abstract class IrBindableSymbolBase<out Descriptor, Owner>(
IrBindableSymbol<D, B>, IrSymbolBase<D>(descriptor) { descriptor: Descriptor?,
) : IrSymbolBase<Descriptor>(descriptor), IrBindableSymbol<Descriptor, Owner>
where Descriptor : DeclarationDescriptor,
Owner : IrSymbolOwner {
init { init {
assert(descriptor == null || isOriginalDescriptor(descriptor)) { assert(descriptor == null || isOriginalDescriptor(descriptor)) {
@@ -54,11 +57,11 @@ abstract class IrBindableSymbolBase<out D : DeclarationDescriptor, B : IrSymbolO
descriptor is ValueParameterDescriptor && isOriginalDescriptor(descriptor.containingDeclaration) || descriptor is ValueParameterDescriptor && isOriginalDescriptor(descriptor.containingDeclaration) ||
descriptor == descriptor.original descriptor == descriptor.original
private var _owner: B? = null private var _owner: Owner? = null
override val owner: B override val owner: Owner
get() = _owner ?: throw IllegalStateException("Symbol with ${javaClass.simpleName} is unbound") get() = _owner ?: throw IllegalStateException("Symbol with ${javaClass.simpleName} is unbound")
override fun bind(owner: B) { override fun bind(owner: Owner) {
if (_owner == null) { if (_owner == null) {
_owner = owner _owner = owner
} else { } else {
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrPublicSymbolBase.kt
+13 -9
View File
@@ -13,14 +13,14 @@ import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.util.IdSignature import org.jetbrains.kotlin.ir.util.IdSignature
import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.ir.util.render
abstract class IrPublicSymbolBase<out D : DeclarationDescriptor> constructor( abstract class IrPublicSymbolBase<out Descriptor : DeclarationDescriptor>(
override val signature: IdSignature, override val signature: IdSignature,
private val _descriptor: D? private val _descriptor: Descriptor?
) : IrSymbol { ) : IrSymbol {
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
override val descriptor: D override val descriptor: Descriptor
get() = _descriptor ?: (owner as IrDeclaration).toIrBasedDescriptor() as D get() = _descriptor ?: (owner as IrDeclaration).toIrBasedDescriptor() as Descriptor
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override val hasDescriptor: Boolean override val hasDescriptor: Boolean
@@ -32,8 +32,12 @@ abstract class IrPublicSymbolBase<out D : DeclarationDescriptor> constructor(
} }
} }
abstract class IrBindablePublicSymbolBase<out D : DeclarationDescriptor, B : IrSymbolOwner>(sig: IdSignature, descriptor: D?) : abstract class IrBindablePublicSymbolBase<out Descriptor, Owner>(
IrBindableSymbol<D, B>, IrPublicSymbolBase<D>(sig, descriptor) { sig: IdSignature,
descriptor: Descriptor?,
) : IrPublicSymbolBase<Descriptor>(sig, descriptor), IrBindableSymbol<Descriptor, Owner>
where Descriptor : DeclarationDescriptor,
Owner : IrSymbolOwner {
init { init {
assert(descriptor == null || isOriginalDescriptor(descriptor)) { assert(descriptor == null || isOriginalDescriptor(descriptor)) {
@@ -47,11 +51,11 @@ abstract class IrBindablePublicSymbolBase<out D : DeclarationDescriptor, B : IrS
descriptor is ValueParameterDescriptor && isOriginalDescriptor(descriptor.containingDeclaration) || descriptor is ValueParameterDescriptor && isOriginalDescriptor(descriptor.containingDeclaration) ||
descriptor == descriptor.original descriptor == descriptor.original
private var _owner: B? = null private var _owner: Owner? = null
override val owner: B override val owner: Owner
get() = _owner ?: throw IllegalStateException("Symbol for $signature is unbound") get() = _owner ?: throw IllegalStateException("Symbol for $signature is unbound")
override fun bind(owner: B) { override fun bind(owner: Owner) {
if (_owner == null) { if (_owner == null) {
_owner = owner _owner = owner
} else { } else {
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt
+200 -179
View File
@@ -26,33 +26,33 @@ import org.jetbrains.kotlin.utils.threadLocal
interface ReferenceSymbolTable { interface ReferenceSymbolTable {
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol
fun referenceClass(sig: IdSignature): IrClassSymbol fun referenceClass(signature: IdSignature): IrClassSymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol
fun referenceConstructor(sig: IdSignature): IrConstructorSymbol fun referenceConstructor(signature: IdSignature): IrConstructorSymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol
fun referenceEnumEntry(sig: IdSignature): IrEnumEntrySymbol fun referenceEnumEntry(signature: IdSignature): IrEnumEntrySymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol
fun referenceField(sig: IdSignature): IrFieldSymbol fun referenceField(signature: IdSignature): IrFieldSymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol
fun referenceProperty(sig: IdSignature): IrPropertySymbol fun referenceProperty(signature: IdSignature): IrPropertySymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceProperty(descriptor: PropertyDescriptor, generate: () -> IrProperty): IrProperty fun referenceProperty(descriptor: PropertyDescriptor, generate: () -> IrProperty): IrProperty
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol
fun referenceSimpleFunction(sig: IdSignature): IrSimpleFunctionSymbol fun referenceSimpleFunction(signature: IdSignature): IrSimpleFunctionSymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceDeclaredFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol fun referenceDeclaredFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol
@@ -62,7 +62,7 @@ interface ReferenceSymbolTable {
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol
fun referenceTypeParameter(sig: IdSignature): IrTypeParameterSymbol fun referenceTypeParameter(signature: IdSignature): IrTypeParameterSymbol
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol
@@ -72,12 +72,12 @@ interface ReferenceSymbolTable {
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol
fun referenceTypeAlias(sig: IdSignature): IrTypeAliasSymbol fun referenceTypeAlias(signature: IdSignature): IrTypeAliasSymbol
fun enterScope(owner: IrSymbol) fun enterScope(symbol: IrSymbol)
fun enterScope(owner: IrDeclaration) fun enterScope(owner: IrDeclaration)
fun leaveScope(owner: IrSymbol) fun leaveScope(symbol: IrSymbol)
fun leaveScope(owner: IrDeclaration) fun leaveScope(owner: IrDeclaration)
} }
@@ -93,7 +93,10 @@ open class SymbolTable(
val lazyWrapper = IrLazySymbolTable(this) val lazyWrapper = IrLazySymbolTable(this)
@Suppress("DuplicatedCode") @Suppress("DuplicatedCode")
private abstract class SymbolTableBase<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>>(val lock: IrLock) { private abstract class SymbolTableBase<Descriptor, SymbolOwner, Symbol>(val lock: IrLock)
where Descriptor : DeclarationDescriptor,
SymbolOwner : IrSymbolOwner,
Symbol : IrBindableSymbol<Descriptor, SymbolOwner> {
/** /**
* With the partial linkage turned on it's hard to predict whether a newly created [IrSymbol] that is added to the [SymbolTable] * With the partial linkage turned on it's hard to predict whether a newly created [IrSymbol] that is added to the [SymbolTable]
* via one of referenceXXX() calls will or won't be bound to some declaration. The latter may happen in certain cases, * via one of referenceXXX() calls will or won't be bound to some declaration. The latter may happen in certain cases,
@@ -106,22 +109,26 @@ open class SymbolTable(
* *
* For the future: Consider implementing the optimization once again for the new "flat" ID signatures. * For the future: Consider implementing the optimization once again for the new "flat" ID signatures.
*/ */
val unboundSymbols = linkedSetOf<S>() val unboundSymbols = linkedSetOf<Symbol>()
protected abstract fun signature(descriptor: D): IdSignature? protected abstract fun signature(descriptor: Descriptor): IdSignature?
// TODO: consider replacing paired get/set calls by java.util.Map.computeIfAbsent() which would be more performant // TODO: consider replacing paired get/set calls by java.util.Map.computeIfAbsent() which would be more performant
abstract fun get(d: D, sig: IdSignature?): S? abstract fun get(descriptor: Descriptor, signature: IdSignature?): Symbol?
abstract fun set(s: S) abstract fun set(symbol: Symbol)
abstract fun get(sig: IdSignature): S? abstract fun get(signature: IdSignature): Symbol?
abstract fun set(sig: IdSignature, s: S) abstract fun set(signature: IdSignature, symbol: Symbol)
inline fun declare(d: D, createSymbol: (IdSignature?) -> S, createOwner: (S) -> B): B { inline fun declare(
descriptor: Descriptor,
createSymbol: (IdSignature?) -> Symbol,
createOwner: (Symbol) -> SymbolOwner,
): SymbolOwner {
synchronized(lock) { synchronized(lock) {
val signature = signature(d) val signature = signature(descriptor)
val existing = get(d, signature) val existing = get(descriptor, signature)
val symbol = if (existing == null) { val symbol = if (existing == null) {
checkOriginal(d) checkOriginal(descriptor)
val new = createSymbol(signature) val new = createSymbol(signature)
set(new) set(new)
new new
@@ -133,9 +140,9 @@ open class SymbolTable(
} }
} }
inline fun declare(sig: IdSignature, createSymbol: () -> S, createOwner: (S) -> B): B { inline fun declare(signature: IdSignature, createSymbol: () -> Symbol, createOwner: (Symbol) -> SymbolOwner): SymbolOwner {
synchronized(lock) { synchronized(lock) {
val existing = get(sig) val existing = get(signature)
val symbol = if (existing == null) { val symbol = if (existing == null) {
createSymbol() createSymbol()
} else { } else {
@@ -150,12 +157,16 @@ open class SymbolTable(
} }
} }
inline fun declareIfNotExists(d: D, createSymbol: (IdSignature?) -> S, createOwner: (S) -> B): B { inline fun declareIfNotExists(
descriptor: Descriptor,
createSymbol: (IdSignature?) -> Symbol,
createOwner: (Symbol) -> SymbolOwner,
): SymbolOwner {
synchronized(lock) { synchronized(lock) {
val signature = signature(d) val signature = signature(descriptor)
val existing = get(d, signature) val existing = get(descriptor, signature)
val symbol = if (existing == null) { val symbol = if (existing == null) {
checkOriginal(d) checkOriginal(descriptor)
val new = createSymbol(signature) val new = createSymbol(signature)
set(new) set(new)
new new
@@ -170,11 +181,16 @@ open class SymbolTable(
} }
} }
inline fun declare(sig: IdSignature, d: D?, createSymbol: () -> S, createOwner: (S) -> B): B { inline fun declare(
signature: IdSignature,
descriptor: Descriptor?,
createSymbol: () -> Symbol,
createOwner: (Symbol) -> SymbolOwner,
): SymbolOwner {
synchronized(lock) { synchronized(lock) {
val existing = get(sig) val existing = get(signature)
val symbol = if (existing == null) { val symbol = if (existing == null) {
checkOriginal(d) checkOriginal(descriptor)
val new = createSymbol() val new = createSymbol()
set(new) set(new)
new new
@@ -186,11 +202,11 @@ open class SymbolTable(
} }
} }
inline fun referenced(d: D, orElse: (IdSignature?) -> S): S { inline fun referenced(descriptor: Descriptor, orElse: (IdSignature?) -> Symbol): Symbol {
synchronized(lock) { synchronized(lock) {
val signature = signature(d) val signature = signature(descriptor)
return get(d, signature) ?: run { return get(descriptor, signature) ?: run {
checkOriginal(d) checkOriginal(descriptor)
val new = orElse(signature) val new = orElse(signature)
assert(unboundSymbols.add(new)) { "Symbol for $new was already referenced" } assert(unboundSymbols.add(new)) { "Symbol for $new was already referenced" }
set(new) set(new)
@@ -199,9 +215,9 @@ open class SymbolTable(
} }
} }
inline fun referenced(sig: IdSignature, orElse: () -> S): S { inline fun referenced(signature: IdSignature, orElse: () -> Symbol): Symbol {
synchronized(lock) { synchronized(lock) {
return get(sig) ?: run { return get(signature) ?: run {
val new = orElse() val new = orElse()
assert(unboundSymbols.add(new)) { "Symbol for ${new.signature} was already referenced" } assert(unboundSymbols.add(new)) { "Symbol for ${new.signature} was already referenced" }
set(new) set(new)
@@ -210,15 +226,15 @@ open class SymbolTable(
} }
} }
private fun checkOriginal(d: D?) { private fun checkOriginal(descriptor: Descriptor?) {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
val d0 = d?.original as D val descriptor0 = descriptor?.original as Descriptor
assert(d0 === d) { assert(descriptor0 === descriptor) {
"Non-original descriptor in declaration: $d\n\tExpected: $d0" "Non-original descriptor in declaration: $descriptor\n\tExpected: $descriptor0"
} }
} }
protected inline fun createOwnerSafe(symbol: S, createOwner: (S) -> B): B { protected inline fun createOwnerSafe(symbol: Symbol, createOwner: (Symbol) -> SymbolOwner): SymbolOwner {
val owner = createOwner(symbol) val owner = createOwner(symbol)
require(symbol.isBound) require(symbol.isBound)
require(symbol.owner === owner) { require(symbol.owner === owner) {
@@ -228,35 +244,37 @@ open class SymbolTable(
} }
} }
private open inner class FlatSymbolTable<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>> : private open inner class FlatSymbolTable<Descriptor, SymbolOwner, Symbol> : SymbolTableBase<Descriptor, SymbolOwner, Symbol>(lock)
SymbolTableBase<D, B, S>(lock) { where Descriptor : DeclarationDescriptor,
val descriptorToSymbol = hashMapOf<D, S>() SymbolOwner : IrSymbolOwner,
val idSigToSymbol = hashMapOf<IdSignature, S>() Symbol : IrBindableSymbol<Descriptor, SymbolOwner> {
val descriptorToSymbol = hashMapOf<Descriptor, Symbol>()
val idSignatureToSymbol = hashMapOf<IdSignature, Symbol>()
override fun signature(descriptor: D): IdSignature? = override fun signature(descriptor: Descriptor): IdSignature? =
signaturer.composeSignature(descriptor) signaturer.composeSignature(descriptor)
override fun get(d: D, sig: IdSignature?): S? = override fun get(descriptor: Descriptor, signature: IdSignature?): Symbol? =
if (sig != null) { if (signature != null) {
idSigToSymbol[sig] idSignatureToSymbol[signature]
} else { } else {
descriptorToSymbol[d] descriptorToSymbol[descriptor]
} }
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
override fun set(s: S) { override fun set(symbol: Symbol) {
val signature = s.signature val signature = symbol.signature
if (signature != null) { if (signature != null) {
idSigToSymbol[signature] = s idSignatureToSymbol[signature] = symbol
} else if (s.hasDescriptor) { } else if (symbol.hasDescriptor) {
descriptorToSymbol[s.descriptor] = s descriptorToSymbol[symbol.descriptor] = symbol
} }
} }
override fun get(sig: IdSignature): S? = idSigToSymbol[sig] override fun get(signature: IdSignature): Symbol? = idSignatureToSymbol[signature]
override fun set(sig: IdSignature, s: S) { override fun set(signature: IdSignature, symbol: Symbol) {
idSigToSymbol[sig] = s idSignatureToSymbol[signature] = symbol
} }
} }
@@ -268,43 +286,45 @@ open class SymbolTable(
override fun signature(descriptor: PropertyDescriptor): IdSignature? = signaturer.composeFieldSignature(descriptor) override fun signature(descriptor: PropertyDescriptor): IdSignature? = signaturer.composeFieldSignature(descriptor)
} }
private inner class ScopedSymbolTable<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>> private inner class ScopedSymbolTable<Descriptor, SymbolOwner, Symbol> : SymbolTableBase<Descriptor, SymbolOwner, Symbol>(lock)
: SymbolTableBase<D, B, S>(lock) { where Descriptor : DeclarationDescriptor,
SymbolOwner : IrSymbolOwner,
Symbol : IrBindableSymbol<Descriptor, SymbolOwner> {
inner class Scope(val owner: IrSymbol, val parent: Scope?) { inner class Scope(val owner: IrSymbol, val parent: Scope?) {
private val descriptorToSymbol = hashMapOf<D, S>() private val descriptorToSymbol = hashMapOf<Descriptor, Symbol>()
private val idSigToSymbol = hashMapOf<IdSignature, S>() private val idSignatureToSymbol = hashMapOf<IdSignature, Symbol>()
private fun getByDescriptor(d: D): S? = private fun getByDescriptor(descriptor: Descriptor): Symbol? =
descriptorToSymbol[d] ?: parent?.getByDescriptor(d) descriptorToSymbol[descriptor] ?: parent?.getByDescriptor(descriptor)
private fun getByIdSignature(sig: IdSignature): S? = private fun getByIdSignature(signature: IdSignature): Symbol? =
idSigToSymbol[sig] ?: parent?.getByIdSignature(sig) idSignatureToSymbol[signature] ?: parent?.getByIdSignature(signature)
operator fun get(d: D, sig: IdSignature?): S? = operator fun get(descriptor: Descriptor, signature: IdSignature?): Symbol? =
if (sig != null) { if (signature != null) {
getByIdSignature(sig) getByIdSignature(signature)
} else { } else {
getByDescriptor(d) getByDescriptor(descriptor)
} }
fun getLocal(d: D) = descriptorToSymbol[d] fun getLocal(descriptor: Descriptor) = descriptorToSymbol[descriptor]
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
operator fun set(d: D, s: S) { operator fun set(descriptor: Descriptor, symbol: Symbol) {
s.signature?.let { symbol.signature?.let {
require(d is TypeParameterDescriptor) require(descriptor is TypeParameterDescriptor)
idSigToSymbol[it] = s idSignatureToSymbol[it] = symbol
} ?: run { } ?: run {
assert(s.hasDescriptor) assert(symbol.hasDescriptor)
descriptorToSymbol[s.descriptor] = s descriptorToSymbol[symbol.descriptor] = symbol
} }
} }
operator fun get(sig: IdSignature): S? = operator fun get(signature: IdSignature): Symbol? =
idSigToSymbol[sig] ?: parent?.get(sig) idSignatureToSymbol[signature] ?: parent?.get(signature)
operator fun set(sig: IdSignature, s: S) { operator fun set(signature: IdSignature, symbol: Symbol) {
idSigToSymbol[sig] = s idSignatureToSymbol[signature] = symbol
} }
fun dumpTo(stringBuilder: StringBuilder): StringBuilder = fun dumpTo(stringBuilder: StringBuilder): StringBuilder =
@@ -322,37 +342,37 @@ open class SymbolTable(
private var currentScope: Scope? = null private var currentScope: Scope? = null
override fun signature(descriptor: D): IdSignature? = override fun signature(descriptor: Descriptor): IdSignature? =
signaturer.composeSignature(descriptor) signaturer.composeSignature(descriptor)
override fun get(d: D, sig: IdSignature?): S? { override fun get(descriptor: Descriptor, signature: IdSignature?): Symbol? {
val scope = currentScope ?: return null val scope = currentScope ?: return null
return scope[d, sig] return scope[descriptor, signature]
} }
@OptIn(ObsoleteDescriptorBasedAPI::class) @OptIn(ObsoleteDescriptorBasedAPI::class)
override fun set(s: S) { override fun set(symbol: Symbol) {
val scope = currentScope ?: throw AssertionError("No active scope") val scope = currentScope ?: throw AssertionError("No active scope")
scope[s.descriptor] = s scope[symbol.descriptor] = symbol
} }
override fun get(sig: IdSignature): S? { override fun get(signature: IdSignature): Symbol? {
val scope = currentScope ?: return null val scope = currentScope ?: return null
return scope[sig] return scope[signature]
} }
override fun set(sig: IdSignature, s: S) { override fun set(signature: IdSignature, symbol: Symbol) {
val scope = currentScope ?: throw AssertionError("No active scope") val scope = currentScope ?: throw AssertionError("No active scope")
scope[sig] = s scope[signature] = symbol
} }
inline fun declareLocal(d: D, createSymbol: () -> S, createOwner: (S) -> B): B { inline fun declareLocal(descriptor: Descriptor, createSymbol: () -> Symbol, createOwner: (Symbol) -> SymbolOwner): SymbolOwner {
val scope = currentScope ?: throw AssertionError("No active scope") val scope = currentScope ?: throw AssertionError("No active scope")
val symbol = scope.getLocal(d) ?: createSymbol().also { scope[d] = it } val symbol = scope.getLocal(descriptor) ?: createSymbol().also { scope[descriptor] = it }
return createOwnerSafe(symbol, createOwner) return createOwnerSafe(symbol, createOwner)
} }
fun introduceLocal(descriptor: D, symbol: S) { fun introduceLocal(descriptor: Descriptor, symbol: Symbol) {
val scope = currentScope ?: throw AssertionError("No active scope") val scope = currentScope ?: throw AssertionError("No active scope")
scope[descriptor, signature(descriptor)]?.let { scope[descriptor, signature(descriptor)]?.let {
throw AssertionError("$descriptor is already bound to $it") throw AssertionError("$descriptor is already bound to $it")
@@ -460,12 +480,12 @@ open class SymbolTable(
} }
fun declareScript( fun declareScript(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrScriptSymbol, symbolFactory: () -> IrScriptSymbol,
scriptFactory: (IrScriptSymbol) -> IrScript scriptFactory: (IrScriptSymbol) -> IrScript
): IrScript { ): IrScript {
return scriptSymbolTable.declare( return scriptSymbolTable.declare(
sig, signature,
symbolFactory, symbolFactory,
scriptFactory scriptFactory
) )
@@ -491,19 +511,19 @@ open class SymbolTable(
} }
fun declareClass( fun declareClass(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrClassSymbol, symbolFactory: () -> IrClassSymbol,
classFactory: (IrClassSymbol) -> IrClass classFactory: (IrClassSymbol) -> IrClass
): IrClass { ): IrClass {
return classSymbolTable.declare( return classSymbolTable.declare(
sig, signature,
symbolFactory, symbolFactory,
classFactory classFactory
) )
} }
fun declareClassWithSignature(sig: IdSignature, symbol: IrClassSymbol) { fun declareClassWithSignature(signature: IdSignature, symbol: IrClassSymbol) {
classSymbolTable.set(sig, symbol) classSymbolTable.set(signature, symbol)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@@ -513,10 +533,10 @@ open class SymbolTable(
// Note: used in native // Note: used in native
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@Suppress("unused") @Suppress("unused")
fun declareClassFromLinker(descriptor: ClassDescriptor, sig: IdSignature, factory: (IrClassSymbol) -> IrClass): IrClass { fun declareClassFromLinker(descriptor: ClassDescriptor, signature: IdSignature, factory: (IrClassSymbol) -> IrClass): IrClass {
return classSymbolTable.run { return classSymbolTable.run {
if (sig.isPubliclyVisible) { if (signature.isPubliclyVisible) {
declare(sig, descriptor, { IrClassPublicSymbolImpl(sig, descriptor) }, factory) declare(signature, descriptor, { IrClassPublicSymbolImpl(signature, descriptor) }, factory)
} else { } else {
declare(descriptor, { IrClassSymbolImpl(descriptor) }, factory) declare(descriptor, { IrClassSymbolImpl(descriptor) }, factory)
} }
@@ -538,17 +558,17 @@ open class SymbolTable(
classSymbolTable.referenced(descriptor) { signature -> createClassSymbol(descriptor, signature) } classSymbolTable.referenced(descriptor) { signature -> createClassSymbol(descriptor, signature) }
fun referenceClass( fun referenceClass(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrClassSymbol, symbolFactory: () -> IrClassSymbol,
classFactory: (IrClassSymbol) -> IrClass classFactory: (IrClassSymbol) -> IrClass
) = ) =
classSymbolTable.referenced(sig) { declareClass(sig, symbolFactory, classFactory).symbol } classSymbolTable.referenced(signature) { declareClass(signature, symbolFactory, classFactory).symbol }
override fun referenceClass(sig: IdSignature): IrClassSymbol = override fun referenceClass(signature: IdSignature): IrClassSymbol =
classSymbolTable.run { classSymbolTable.run {
if (sig.isPubliclyVisible) referenced(sig) { IrClassPublicSymbolImpl(sig) } if (signature.isPubliclyVisible) referenced(signature) { IrClassPublicSymbolImpl(signature) }
else IrClassSymbolImpl().also { else IrClassSymbolImpl().also {
it.privateSignature = sig it.privateSignature = signature
} }
} }
@@ -569,12 +589,12 @@ open class SymbolTable(
) )
fun declareConstructor( fun declareConstructor(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrConstructorSymbol, symbolFactory: () -> IrConstructorSymbol,
constructorFactory: (IrConstructorSymbol) -> IrConstructor constructorFactory: (IrConstructorSymbol) -> IrConstructor
): IrConstructor { ): IrConstructor {
return constructorSymbolTable.declare( return constructorSymbolTable.declare(
sig, signature,
symbolFactory, symbolFactory,
constructorFactory constructorFactory
) )
@@ -591,37 +611,37 @@ open class SymbolTable(
constructorFactory constructorFactory
) )
fun declareConstructorWithSignature(sig: IdSignature, symbol: IrConstructorSymbol) { fun declareConstructorWithSignature(signature: IdSignature, symbol: IrConstructorSymbol) {
constructorSymbolTable.set(sig, symbol) constructorSymbolTable.set(signature, symbol)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol = override fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol =
constructorSymbolTable.referenced(descriptor) { signature -> createConstructorSymbol(descriptor, signature) } constructorSymbolTable.referenced(descriptor) { signature -> createConstructorSymbol(descriptor, signature) }
fun referenceConstructorIfAny(sig: IdSignature): IrConstructorSymbol? = fun referenceConstructorIfAny(signature: IdSignature): IrConstructorSymbol? =
constructorSymbolTable.get(sig) constructorSymbolTable.get(signature)
// Note: used in native // Note: used in native
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@Suppress("unused") @Suppress("unused")
fun declareConstructorFromLinker( fun declareConstructorFromLinker(
descriptor: ClassConstructorDescriptor, descriptor: ClassConstructorDescriptor,
sig: IdSignature, signature: IdSignature,
constructorFactory: (IrConstructorSymbol) -> IrConstructor constructorFactory: (IrConstructorSymbol) -> IrConstructor
): IrConstructor { ): IrConstructor {
return constructorSymbolTable.run { return constructorSymbolTable.run {
if (sig.isPubliclyVisible) { if (signature.isPubliclyVisible) {
declare(sig, descriptor, { IrConstructorPublicSymbolImpl(sig, descriptor) }, constructorFactory) declare(signature, descriptor, { IrConstructorPublicSymbolImpl(signature, descriptor) }, constructorFactory)
} else { } else {
declare(descriptor, { IrConstructorSymbolImpl(descriptor) }, constructorFactory) declare(descriptor, { IrConstructorSymbolImpl(descriptor) }, constructorFactory)
} }
} }
} }
override fun referenceConstructor(sig: IdSignature): IrConstructorSymbol = override fun referenceConstructor(signature: IdSignature): IrConstructorSymbol =
constructorSymbolTable.run { constructorSymbolTable.run {
if (sig.isPubliclyVisible) referenced(sig) { IrConstructorPublicSymbolImpl(sig) } if (signature.isPubliclyVisible) referenced(signature) { IrConstructorPublicSymbolImpl(signature) }
else IrConstructorSymbolImpl() else IrConstructorSymbolImpl()
} }
@@ -644,10 +664,10 @@ open class SymbolTable(
) )
fun declareEnumEntry( fun declareEnumEntry(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrEnumEntrySymbol, symbolFactory: () -> IrEnumEntrySymbol,
enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry enumEntryFactory: (IrEnumEntrySymbol) -> IrEnumEntry
): IrEnumEntry = enumEntrySymbolTable.declare(sig, symbolFactory, enumEntryFactory) ): IrEnumEntry = enumEntrySymbolTable.declare(signature, symbolFactory, enumEntryFactory)
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
fun declareEnumEntryIfNotExists(descriptor: ClassDescriptor, factory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry = fun declareEnumEntryIfNotExists(descriptor: ClassDescriptor, factory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry =
@@ -658,12 +678,12 @@ open class SymbolTable(
@Suppress("unused") @Suppress("unused")
fun declareEnumEntryFromLinker( fun declareEnumEntryFromLinker(
descriptor: ClassDescriptor, descriptor: ClassDescriptor,
sig: IdSignature, signature: IdSignature,
factory: (IrEnumEntrySymbol) -> IrEnumEntry factory: (IrEnumEntrySymbol) -> IrEnumEntry
): IrEnumEntry { ): IrEnumEntry {
return enumEntrySymbolTable.run { return enumEntrySymbolTable.run {
if (sig.isPubliclyVisible) { if (signature.isPubliclyVisible) {
declare(sig, descriptor, { IrEnumEntryPublicSymbolImpl(sig, descriptor) }, factory) declare(signature, descriptor, { IrEnumEntryPublicSymbolImpl(signature, descriptor) }, factory)
} else { } else {
declare(descriptor, { IrEnumEntrySymbolImpl(descriptor) }, factory) declare(descriptor, { IrEnumEntrySymbolImpl(descriptor) }, factory)
} }
@@ -674,9 +694,9 @@ open class SymbolTable(
override fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol = override fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol =
enumEntrySymbolTable.referenced(descriptor) { signature -> createEnumEntrySymbol(descriptor, signature) } enumEntrySymbolTable.referenced(descriptor) { signature -> createEnumEntrySymbol(descriptor, signature) }
override fun referenceEnumEntry(sig: IdSignature) = override fun referenceEnumEntry(signature: IdSignature) =
enumEntrySymbolTable.run { enumEntrySymbolTable.run {
if (sig.isPubliclyVisible) referenced(sig) { IrEnumEntryPublicSymbolImpl(sig) } if (signature.isPubliclyVisible) referenced(signature) { IrEnumEntryPublicSymbolImpl(signature) }
else IrEnumEntrySymbolImpl() else IrEnumEntrySymbolImpl()
} }
@@ -723,29 +743,29 @@ open class SymbolTable(
} }
fun declareField( fun declareField(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrFieldSymbol, symbolFactory: () -> IrFieldSymbol,
propertyFactory: (IrFieldSymbol) -> IrField propertyFactory: (IrFieldSymbol) -> IrField
): IrField { ): IrField {
return fieldSymbolTable.declare( return fieldSymbolTable.declare(
sig, signature,
symbolFactory, symbolFactory,
propertyFactory propertyFactory
) )
} }
fun declareFieldWithSignature(sig: IdSignature, symbol: IrFieldSymbol) { fun declareFieldWithSignature(signature: IdSignature, symbol: IrFieldSymbol) {
fieldSymbolTable.set(sig, symbol) fieldSymbolTable.set(signature, symbol)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol = override fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol =
fieldSymbolTable.referenced(descriptor) { signature -> createFieldSymbol(descriptor, signature) } fieldSymbolTable.referenced(descriptor) { signature -> createFieldSymbol(descriptor, signature) }
override fun referenceField(sig: IdSignature): IrFieldSymbol = override fun referenceField(signature: IdSignature): IrFieldSymbol =
fieldSymbolTable.run { fieldSymbolTable.run {
if (sig.isPubliclyVisible) { if (signature.isPubliclyVisible) {
referenced(sig) { IrFieldPublicSymbolImpl(sig) } referenced(signature) { IrFieldPublicSymbolImpl(signature) }
} else IrFieldSymbolImpl() } else IrFieldSymbolImpl()
} }
@@ -793,12 +813,12 @@ open class SymbolTable(
) )
fun declareProperty( fun declareProperty(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrPropertySymbol, symbolFactory: () -> IrPropertySymbol,
propertyFactory: (IrPropertySymbol) -> IrProperty propertyFactory: (IrPropertySymbol) -> IrProperty
): IrProperty { ): IrProperty {
return propertySymbolTable.declare( return propertySymbolTable.declare(
sig, signature,
symbolFactory, symbolFactory,
propertyFactory propertyFactory
) )
@@ -808,33 +828,35 @@ open class SymbolTable(
fun declarePropertyIfNotExists(descriptor: PropertyDescriptor, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty = fun declarePropertyIfNotExists(descriptor: PropertyDescriptor, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty =
propertySymbolTable.declareIfNotExists(descriptor, { signature -> createPropertySymbol(descriptor, signature) }, propertyFactory) propertySymbolTable.declareIfNotExists(descriptor, { signature -> createPropertySymbol(descriptor, signature) }, propertyFactory)
// Note: used in native
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@Suppress("unused") fun declarePropertyFromLinker(
fun declarePropertyFromLinker(descriptor: PropertyDescriptor, sig: IdSignature, factory: (IrPropertySymbol) -> IrProperty): IrProperty { descriptor: PropertyDescriptor,
signature: IdSignature,
factory: (IrPropertySymbol) -> IrProperty,
): IrProperty {
return propertySymbolTable.run { return propertySymbolTable.run {
if (sig.isPubliclyVisible) { if (signature.isPubliclyVisible) {
declare(sig, descriptor, { IrPropertyPublicSymbolImpl(sig, descriptor) }, factory) declare(signature, descriptor, { IrPropertyPublicSymbolImpl(signature, descriptor) }, factory)
} else { } else {
declare(descriptor, { IrPropertySymbolImpl(descriptor) }, factory) declare(descriptor, { IrPropertySymbolImpl(descriptor) }, factory)
} }
} }
} }
fun declarePropertyWithSignature(sig: IdSignature, symbol: IrPropertySymbol) { fun declarePropertyWithSignature(signature: IdSignature, symbol: IrPropertySymbol) {
propertySymbolTable.set(sig, symbol) propertySymbolTable.set(signature, symbol)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol = override fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol =
propertySymbolTable.referenced(descriptor) { signature -> createPropertySymbol(descriptor, signature) } propertySymbolTable.referenced(descriptor) { signature -> createPropertySymbol(descriptor, signature) }
fun referencePropertyIfAny(sig: IdSignature): IrPropertySymbol? = fun referencePropertyIfAny(signature: IdSignature): IrPropertySymbol? =
propertySymbolTable.get(sig) propertySymbolTable.get(signature)
override fun referenceProperty(sig: IdSignature): IrPropertySymbol = override fun referenceProperty(signature: IdSignature): IrPropertySymbol =
propertySymbolTable.run { propertySymbolTable.run {
if (sig.isPubliclyVisible) referenced(sig) { IrPropertyPublicSymbolImpl(sig) } if (signature.isPubliclyVisible) referenced(signature) { IrPropertyPublicSymbolImpl(signature) }
else IrPropertySymbolImpl() else IrPropertySymbolImpl()
} }
@@ -847,9 +869,9 @@ open class SymbolTable(
override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol = override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol =
typeAliasSymbolTable.referenced(descriptor) { signature -> createTypeAliasSymbol(descriptor, signature) } typeAliasSymbolTable.referenced(descriptor) { signature -> createTypeAliasSymbol(descriptor, signature) }
override fun referenceTypeAlias(sig: IdSignature) = override fun referenceTypeAlias(signature: IdSignature) =
typeAliasSymbolTable.run { typeAliasSymbolTable.run {
if (sig.isPubliclyVisible) referenced(sig) { IrTypeAliasPublicSymbolImpl(sig) } if (signature.isPubliclyVisible) referenced(signature) { IrTypeAliasPublicSymbolImpl(signature) }
else IrTypeAliasSymbolImpl() else IrTypeAliasSymbolImpl()
} }
@@ -858,11 +880,11 @@ open class SymbolTable(
typeAliasSymbolTable.declare(descriptor, { signature -> createTypeAliasSymbol(descriptor, signature) }, factory) typeAliasSymbolTable.declare(descriptor, { signature -> createTypeAliasSymbol(descriptor, signature) }, factory)
fun declareTypeAlias( fun declareTypeAlias(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrTypeAliasSymbol, symbolFactory: () -> IrTypeAliasSymbol,
factory: (IrTypeAliasSymbol) -> IrTypeAlias factory: (IrTypeAliasSymbol) -> IrTypeAlias
): IrTypeAlias { ): IrTypeAlias {
return typeAliasSymbolTable.declare(sig, symbolFactory, factory) return typeAliasSymbolTable.declare(signature, symbolFactory, factory)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@@ -887,12 +909,12 @@ open class SymbolTable(
} }
fun declareSimpleFunction( fun declareSimpleFunction(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrSimpleFunctionSymbol, symbolFactory: () -> IrSimpleFunctionSymbol,
functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction
): IrSimpleFunction { ): IrSimpleFunction {
return simpleFunctionSymbolTable.declare( return simpleFunctionSymbolTable.declare(
sig, signature,
symbolFactory, symbolFactory,
functionFactory functionFactory
) )
@@ -907,39 +929,37 @@ open class SymbolTable(
descriptor, { signature -> createSimpleFunctionSymbol(descriptor, signature) }, functionFactory descriptor, { signature -> createSimpleFunctionSymbol(descriptor, signature) }, functionFactory
) )
// Note: used in native
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@Suppress("unused")
fun declareSimpleFunctionFromLinker( fun declareSimpleFunctionFromLinker(
descriptor: FunctionDescriptor?, descriptor: FunctionDescriptor?,
sig: IdSignature, signature: IdSignature,
functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction
): IrSimpleFunction { ): IrSimpleFunction {
return simpleFunctionSymbolTable.run { return simpleFunctionSymbolTable.run {
if (sig.isPubliclyVisible) { if (signature.isPubliclyVisible) {
declare(sig, descriptor, { IrSimpleFunctionPublicSymbolImpl(sig, descriptor) }, functionFactory) declare(signature, descriptor, { IrSimpleFunctionPublicSymbolImpl(signature, descriptor) }, functionFactory)
} else { } else {
declare(descriptor!!, { IrSimpleFunctionSymbolImpl(descriptor) }, functionFactory) declare(descriptor!!, { IrSimpleFunctionSymbolImpl(descriptor) }, functionFactory)
} }
} }
} }
fun declareSimpleFunctionWithSignature(sig: IdSignature, symbol: IrSimpleFunctionSymbol) { fun declareSimpleFunctionWithSignature(signature: IdSignature, symbol: IrSimpleFunctionSymbol) {
simpleFunctionSymbolTable.set(sig, symbol) simpleFunctionSymbolTable.set(signature, symbol)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
override fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol = override fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol =
simpleFunctionSymbolTable.referenced(descriptor) { signature -> createSimpleFunctionSymbol(descriptor, signature) } simpleFunctionSymbolTable.referenced(descriptor) { signature -> createSimpleFunctionSymbol(descriptor, signature) }
fun referenceSimpleFunctionIfAny(sig: IdSignature): IrSimpleFunctionSymbol? = fun referenceSimpleFunctionIfAny(signature: IdSignature): IrSimpleFunctionSymbol? =
simpleFunctionSymbolTable.get(sig) simpleFunctionSymbolTable.get(signature)
override fun referenceSimpleFunction(sig: IdSignature): IrSimpleFunctionSymbol { override fun referenceSimpleFunction(signature: IdSignature): IrSimpleFunctionSymbol {
return simpleFunctionSymbolTable.run { return simpleFunctionSymbolTable.run {
if (sig.isPubliclyVisible) referenced(sig) { IrSimpleFunctionPublicSymbolImpl(sig) } if (signature.isPubliclyVisible) referenced(signature) { IrSimpleFunctionPublicSymbolImpl(signature) }
else IrSimpleFunctionSymbolImpl().also { else IrSimpleFunctionSymbolImpl().also {
it.privateSignature = sig it.privateSignature = signature
} }
} }
} }
@@ -973,11 +993,11 @@ open class SymbolTable(
) )
fun declareGlobalTypeParameter( fun declareGlobalTypeParameter(
sig: IdSignature, signature: IdSignature,
symbolFactory: () -> IrTypeParameterSymbol, symbolFactory: () -> IrTypeParameterSymbol,
typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter
): IrTypeParameter { ): IrTypeParameter {
return globalTypeParameterSymbolTable.declare(sig, symbolFactory, typeParameterFactory) return globalTypeParameterSymbolTable.declare(signature, symbolFactory, typeParameterFactory)
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@@ -1000,11 +1020,11 @@ open class SymbolTable(
) )
fun declareScopedTypeParameter( fun declareScopedTypeParameter(
sig: IdSignature, signature: IdSignature,
symbolFactory: (IdSignature) -> IrTypeParameterSymbol, symbolFactory: (IdSignature) -> IrTypeParameterSymbol,
typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter
): IrTypeParameter { ): IrTypeParameter {
return typeParameterFactory(symbolFactory(sig)) return typeParameterFactory(symbolFactory(signature))
} }
val unboundTypeParameters: Set<IrTypeParameterSymbol> get() = globalTypeParameterSymbolTable.unboundSymbols val unboundTypeParameters: Set<IrTypeParameterSymbol> get() = globalTypeParameterSymbolTable.unboundSymbols
@@ -1054,9 +1074,9 @@ open class SymbolTable(
override fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol = override fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol =
scopedTypeParameterSymbolTable.referenced(classifier) { signature -> createTypeParameterSymbol(classifier, signature) } scopedTypeParameterSymbolTable.referenced(classifier) { signature -> createTypeParameterSymbol(classifier, signature) }
override fun referenceTypeParameter(sig: IdSignature): IrTypeParameterSymbol = override fun referenceTypeParameter(signature: IdSignature): IrTypeParameterSymbol =
globalTypeParameterSymbolTable.referenced(sig) { globalTypeParameterSymbolTable.referenced(signature) {
if (sig.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(sig) else IrTypeParameterSymbolImpl() if (signature.isPubliclyVisible) IrTypeParameterPublicSymbolImpl(signature) else IrTypeParameterSymbolImpl()
} }
@ObsoleteDescriptorBasedAPI @ObsoleteDescriptorBasedAPI
@@ -1123,16 +1143,16 @@ open class SymbolTable(
throw AssertionError("Undefined local delegated property referenced: $descriptor") throw AssertionError("Undefined local delegated property referenced: $descriptor")
} }
override fun enterScope(owner: IrSymbol) { override fun enterScope(symbol: IrSymbol) {
scopedSymbolTables.forEach { it.enterScope(owner) } scopedSymbolTables.forEach { it.enterScope(symbol) }
} }
override fun enterScope(owner: IrDeclaration) { override fun enterScope(owner: IrDeclaration) {
enterScope(owner.symbol) enterScope(owner.symbol)
} }
override fun leaveScope(owner: IrSymbol) { override fun leaveScope(symbol: IrSymbol) {
scopedSymbolTables.forEach { it.leaveScope(owner) } scopedSymbolTables.forEach { it.leaveScope(symbol) }
} }
override fun leaveScope(owner: IrDeclaration) { override fun leaveScope(owner: IrDeclaration) {
@@ -1150,11 +1170,12 @@ open class SymbolTable(
throw IllegalArgumentException("Unexpected value descriptor: $value") throw IllegalArgumentException("Unexpected value descriptor: $value")
} }
private inline fun <D : DeclarationDescriptor, IR : IrSymbolOwner, S : IrBindableSymbol<D, IR>> FlatSymbolTable<D, IR, S>.forEachSymbolImpl( private inline fun <Descriptor, Owner, Symbol> FlatSymbolTable<Descriptor, Owner, Symbol>.forEachSymbolImpl(block: (IrSymbol) -> Unit)
block: (IrSymbol) -> Unit where Descriptor : DeclarationDescriptor,
) { Owner : IrSymbolOwner,
idSigToSymbol.forEach { (_, sym) -> Symbol : IrBindableSymbol<Descriptor, Owner> {
block(sym) idSignatureToSymbol.forEach { (_, symbol) ->
block(symbol)
} }
} }
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt
+8 -6
View File
@@ -286,12 +286,14 @@ abstract class KotlinIrLinker(
} }
} }
private inline fun < private inline fun <reified Owner, reified DelegatingSymbol, reified DelegateSymbol> finalizeExpectActual(
reified D : IrDeclaration, expectSymbol: DelegatingSymbol,
reified ES : IrDelegatingSymbol<AS, D, *>, actualSymbol: IrSymbol,
reified AS : IrBindableSymbol<*, D> noinline actualizer: (e: Owner, a: Owner) -> Unit,
> finalizeExpectActual(expectSymbol: ES, actualSymbol: IrSymbol, noinline actualizer: (e: D, a: D) -> Unit) { ) where Owner : IrDeclaration,
require(actualSymbol is AS) DelegatingSymbol : IrDelegatingSymbol<DelegateSymbol, Owner, *>,
DelegateSymbol : IrBindableSymbol<*, Owner> {
require(actualSymbol is DelegateSymbol)
val expectDeclaration = expectSymbol.owner val expectDeclaration = expectSymbol.owner
val actualDeclaration = actualSymbol.owner val actualDeclaration = actualSymbol.owner
actualizer(expectDeclaration, actualDeclaration) actualizer(expectDeclaration, actualDeclaration)