IR: removing WrappedDescriptors from symbols

2020-11-30 12:36:50 +03:00
parent 989d4350b1
commit d714adacae
32 changed files with 266 additions and 282 deletions
@@ -21,8 +21,6 @@ import org.jetbrains.kotlin.backend.common.serialization.GlobalDeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.WrappedPropertyDescriptor
-import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy
 import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
@@ -113,7 +111,7 @@ class FakeOverrideBuilder(
        // But to create and link that symbol we should already have the signature computed.
        // To break this loop we use temp symbol in correspondingProperty.

-        val tempSymbol = IrPropertySymbolImpl(WrappedPropertyDescriptor()).also {
+        val tempSymbol = IrPropertySymbolImpl().also {
            it.bind(declaration as IrProperty)
        }
        declaration.getter?.let {
@@ -142,9 +140,9 @@ class FakeOverrideBuilder(
    private fun declareFunctionFakeOverride(declaration: IrFakeOverrideFunction, signature: IdSignature) {
        val parent = declaration.parentAsClass
        val symbol = linker.tryReferencingSimpleFunctionByLocalSignature(parent, signature)
-        val descriptor = symbol?.descriptor ?: WrappedSimpleFunctionDescriptor()
-        symbolTable.declareSimpleFunctionFromLinker(descriptor, signature) {
-            assert(it === symbol || symbol == null)
+            ?: symbolTable.referenceSimpleFunctionFromLinker(signature)
+        symbolTable.declareSimpleFunction(signature, { symbol }) {
+            assert(it === symbol)
            declaration.acquireSymbol(it)
        }
    }
@@ -152,9 +150,9 @@ class FakeOverrideBuilder(
    private fun declarePropertyFakeOverride(declaration: IrFakeOverrideProperty, signature: IdSignature) {
        val parent = declaration.parentAsClass
        val symbol = linker.tryReferencingPropertyByLocalSignature(parent, signature)
-        val descriptor = symbol?.descriptor ?: WrappedPropertyDescriptor()
-        symbolTable.declarePropertyFromLinker(descriptor, signature) {
-            assert(it === symbol || symbol == null)
+            ?: symbolTable.referencePropertyFromLinker(signature)
+        symbolTable.declareProperty(signature, { symbol }) {
+            assert(it === symbol)
            declaration.acquireSymbol(it)
        }
    }
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrPublicSymbolBase
+import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.*
 import org.jetbrains.kotlin.ir.util.*
@@ -1009,21 +1010,17 @@ abstract class IrFileDeserializer(
        val result = symbolTable.run {
            if (isGlobal) {
                val p = deserializeIrSymbolToDeclare(proto.base.symbol)
-                val symbol = p.first
+                val symbol = p.first as IrTypeParameterSymbol
                sig = p.second
-                val descriptor = (symbol as IrTypeParameterSymbol).descriptor
-                declareGlobalTypeParameterFromLinker(descriptor, sig, factory)
+                declareGlobalTypeParameter(sig, { symbol }, factory)
            } else {
                val symbolData = BinarySymbolData
                    .decode(proto.base.symbol)
                sig = deserializeIdSignature(symbolData.signatureId)
-                val descriptor = WrappedTypeParameterDescriptor()
-                declareScopedTypeParameterFromLinker(descriptor, sig, factory)
+                declareScopedTypeParameter(sig, { IrTypeParameterSymbolImpl() }, factory)
            }
        }

-        (result.descriptor as? WrappedTypeParameterDescriptor)?.bind(result)
-
        // make sure this symbol is known to linker
        referenceIrSymbol(result.symbol, sig)
        result.annotations += deserializeAnnotations(proto.base.annotationList)
@@ -1059,7 +1056,7 @@ abstract class IrFileDeserializer(
        withDeserializedIrDeclarationBase(proto.base) { symbol, signature, startOffset, endOffset, origin, fcode ->
            val flags = ClassFlags.decode(fcode)

-            symbolTable.declareClassFromLinker((symbol as IrClassSymbol).descriptor, signature) {
+            symbolTable.declareClass(signature, { symbol as IrClassSymbol }) {
                irFactory.createClass(
                    startOffset, endOffset, origin,
                    it,
@@ -1086,15 +1083,14 @@ abstract class IrFileDeserializer(

                thisReceiver = deserializeIrValueParameter(proto.thisReceiver, -1)

-                (descriptor as? WrappedClassDescriptor)?.bind(this)
-
                fakeOverrideBuilder.enqueueClass(this, signature)
            }
        }

    private fun deserializeIrTypeAlias(proto: ProtoTypeAlias): IrTypeAlias =
        withDeserializedIrDeclarationBase(proto.base) { symbol, uniqId, startOffset, endOffset, origin, fcode ->
-            symbolTable.declareTypeAliasFromLinker((symbol as IrTypeAliasSymbol).descriptor, uniqId) {
+            require(symbol is IrTypeAliasSymbol)
+            symbolTable.declareTypeAlias(uniqId, { symbol }) {
                val flags = TypeAliasFlags.decode(fcode)
                val nameType = BinaryNameAndType.decode(proto.nameType)
                irFactory.createTypeAlias(
@@ -1108,8 +1104,6 @@ abstract class IrFileDeserializer(
                )
            }.usingParent {
                typeParameters = deserializeTypeParameters(proto.typeParameterList, true)
-
-                (descriptor as? WrappedTypeAliasDescriptor)?.bind(this)
            }
        }

@@ -1204,7 +1198,7 @@ abstract class IrFileDeserializer(
        proto: ProtoFunctionBase,
        block: (IrFunctionSymbol, IdSignature, Int, Int, IrDeclarationOrigin, Long) -> T
    ): T = withDeserializedIrDeclarationBase(proto.base) { symbol, idSig, startOffset, endOffset, origin, fcode ->
-        symbolTable.withScope(symbol.descriptor) {
+        symbolTable.withScope(symbol) {
            block(symbol as IrFunctionSymbol, idSig, startOffset, endOffset, origin, fcode).usingParent {
                typeParameters = deserializeTypeParameters(proto.typeParameterList, false)
                val nameType = BinaryNameAndType.decode(proto.nameType)
@@ -1227,7 +1221,7 @@ abstract class IrFileDeserializer(
    private fun deserializeIrFunction(proto: ProtoFunction): IrSimpleFunction {
        return withDeserializedIrFunctionBase(proto.base) { symbol, idSig, startOffset, endOffset, origin, fcode ->
            val flags = FunctionFlags.decode(fcode)
-            symbolTable.declareSimpleFunctionFromLinker(symbol.descriptor, idSig) {
+            symbolTable.declareSimpleFunction(idSig, { symbol as IrSimpleFunctionSymbol }) {
                val nameType = BinaryNameAndType.decode(proto.base.nameType)
                irFactory.createFunction(
                    startOffset, endOffset, origin,
@@ -1275,15 +1269,13 @@ abstract class IrFileDeserializer(

    private fun deserializeIrEnumEntry(proto: ProtoEnumEntry): IrEnumEntry =
        withDeserializedIrDeclarationBase(proto.base) { symbol, uniqId, startOffset, endOffset, origin, _ ->
-            symbolTable.declareEnumEntryFromLinker((symbol as IrEnumEntrySymbol).descriptor, uniqId) {
+            symbolTable.declareEnumEntry(uniqId, { symbol as IrEnumEntrySymbol }) {
                irFactory.createEnumEntry(startOffset, endOffset, origin, it, deserializeName(proto.name))
            }.apply {
                if (proto.hasCorrespondingClass())
                    correspondingClass = deserializeIrClass(proto.correspondingClass)
                if (proto.hasInitializer())
                    initializerExpression = irFactory.createExpressionBody(deserializeExpressionBody(proto.initializer))
-
-                (descriptor as? WrappedEnumEntryDescriptor)?.bind(this)
            }
        }

@@ -1292,16 +1284,15 @@ abstract class IrFileDeserializer(
            irFactory.createAnonymousInitializer(startOffset, endOffset, origin, symbol as IrAnonymousInitializerSymbol).apply {
 //                body = deserializeBlockBody(proto.body.blockBody, startOffset, endOffset)
                body = deserializeStatementBody(proto.body) as IrBlockBody
-
-                (descriptor as? WrappedClassDescriptor)?.bind(parentsStack.peek() as IrClass)
            }
        }

    private fun deserializeIrConstructor(proto: ProtoConstructor): IrConstructor =
        withDeserializedIrFunctionBase(proto.base) { symbol, idSig, startOffset, endOffset, origin, fcode ->
+            require(symbol is IrConstructorSymbol)
            val flags = FunctionFlags.decode(fcode)
            val nameType = BinaryNameAndType.decode(proto.base.nameType)
-            symbolTable.declareConstructorFromLinker((symbol as IrConstructorSymbol).descriptor, idSig) {
+            symbolTable.declareConstructor(idSig, { symbol }) {
                irFactory.createConstructor(
                    startOffset, endOffset, origin,
                    it,
@@ -1313,8 +1304,6 @@ abstract class IrFileDeserializer(
                    flags.isPrimary,
                    flags.isExpect
                )
-            }.apply {
-                (descriptor as? WrappedClassConstructorDescriptor)?.bind(this)
            }
        }

@@ -1322,10 +1311,11 @@ abstract class IrFileDeserializer(

    private fun deserializeIrField(proto: ProtoField): IrField =
        withDeserializedIrDeclarationBase(proto.base) { symbol, uniqId, startOffset, endOffset, origin, fcode ->
+            require(symbol is IrFieldSymbol)
            val nameType = BinaryNameAndType.decode(proto.nameType)
            val type = deserializeIrType(nameType.typeIndex)
            val flags = FieldFlags.decode(fcode)
-            symbolTable.declareFieldFromLinker((symbol as IrFieldSymbol).descriptor, uniqId) {
+            symbolTable.declareField(uniqId, { symbol }) {
                irFactory.createField(
                    startOffset, endOffset, origin,
                    it,
@@ -1342,8 +1332,6 @@ abstract class IrFileDeserializer(
                        initializer = irFactory.createExpressionBody(deserializeExpressionBody(proto.initializer))
                    }
                }
-
-                (descriptor as? WrappedFieldDescriptor)?.bind(this)
            }
        }

@@ -1369,8 +1357,9 @@ abstract class IrFileDeserializer(

    private fun deserializeIrProperty(proto: ProtoProperty): IrProperty =
        withDeserializedIrDeclarationBase(proto.base) { symbol, uniqId, startOffset, endOffset, origin, fcode ->
+            require(symbol is IrPropertySymbol)
            val flags = PropertyFlags.decode(fcode)
-            symbolTable.declarePropertyFromLinker((symbol as IrPropertySymbol).descriptor, uniqId) {
+            symbolTable.declareProperty(uniqId, { symbol }) {
                irFactory.createProperty(
                    startOffset, endOffset, origin,
                    it,
@@ -502,21 +502,21 @@ abstract class KotlinIrLinker(

    private fun referenceDeserializedSymbol(symbolKind: BinarySymbolData.SymbolKind, idSig: IdSignature): IrSymbol = symbolTable.run {
        when (symbolKind) {
-            BinarySymbolData.SymbolKind.ANONYMOUS_INIT_SYMBOL -> IrAnonymousInitializerSymbolImpl(WrappedClassDescriptor())
-            BinarySymbolData.SymbolKind.CLASS_SYMBOL -> referenceClassFromLinker(WrappedClassDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.CONSTRUCTOR_SYMBOL -> referenceConstructorFromLinker(WrappedClassConstructorDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.TYPE_PARAMETER_SYMBOL -> referenceTypeParameterFromLinker(WrappedTypeParameterDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.ENUM_ENTRY_SYMBOL -> referenceEnumEntryFromLinker(WrappedEnumEntryDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.STANDALONE_FIELD_SYMBOL -> referenceFieldFromLinker(WrappedFieldDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.FIELD_SYMBOL -> referenceFieldFromLinker(WrappedPropertyDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.FUNCTION_SYMBOL -> referenceSimpleFunctionFromLinker(WrappedSimpleFunctionDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.TYPEALIAS_SYMBOL -> referenceTypeAliasFromLinker(WrappedTypeAliasDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.PROPERTY_SYMBOL -> referencePropertyFromLinker(WrappedPropertyDescriptor(), idSig)
-            BinarySymbolData.SymbolKind.VARIABLE_SYMBOL -> IrVariableSymbolImpl(WrappedVariableDescriptor())
-            BinarySymbolData.SymbolKind.VALUE_PARAMETER_SYMBOL -> IrValueParameterSymbolImpl(WrappedValueParameterDescriptor())
-            BinarySymbolData.SymbolKind.RECEIVER_PARAMETER_SYMBOL -> IrValueParameterSymbolImpl(WrappedReceiverParameterDescriptor())
+            BinarySymbolData.SymbolKind.ANONYMOUS_INIT_SYMBOL -> IrAnonymousInitializerSymbolImpl()
+            BinarySymbolData.SymbolKind.CLASS_SYMBOL -> referenceClassFromLinker(idSig)
+            BinarySymbolData.SymbolKind.CONSTRUCTOR_SYMBOL -> referenceConstructorFromLinker(idSig)
+            BinarySymbolData.SymbolKind.TYPE_PARAMETER_SYMBOL -> referenceTypeParameterFromLinker(idSig)
+            BinarySymbolData.SymbolKind.ENUM_ENTRY_SYMBOL -> referenceEnumEntryFromLinker(idSig)
+            BinarySymbolData.SymbolKind.STANDALONE_FIELD_SYMBOL -> referenceFieldFromLinker(idSig)
+            BinarySymbolData.SymbolKind.FIELD_SYMBOL -> referenceFieldFromLinker(idSig)
+            BinarySymbolData.SymbolKind.FUNCTION_SYMBOL -> referenceSimpleFunctionFromLinker(idSig)
+            BinarySymbolData.SymbolKind.TYPEALIAS_SYMBOL -> referenceTypeAliasFromLinker(idSig)
+            BinarySymbolData.SymbolKind.PROPERTY_SYMBOL -> referencePropertyFromLinker(idSig)
+            BinarySymbolData.SymbolKind.VARIABLE_SYMBOL -> IrVariableSymbolImpl()
+            BinarySymbolData.SymbolKind.VALUE_PARAMETER_SYMBOL -> IrValueParameterSymbolImpl()
+            BinarySymbolData.SymbolKind.RECEIVER_PARAMETER_SYMBOL -> IrValueParameterSymbolImpl()
            BinarySymbolData.SymbolKind.LOCAL_DELEGATED_PROPERTY_SYMBOL ->
-                IrLocalDelegatedPropertySymbolImpl(WrappedVariableDescriptorWithAccessor())
+                IrLocalDelegatedPropertySymbolImpl()
            else -> error("Unexpected classifier symbol kind: $symbolKind for signature $idSig")
        }
    }
@@ -553,6 +553,8 @@ abstract class KotlinIrLinker(
    protected open fun platformSpecificSymbol(symbol: IrSymbol): Boolean = false

    private fun tryResolveCustomDeclaration(symbol: IrSymbol): IrDeclaration? {
+        if (!symbol.hasDescriptor) return null
+
        val descriptor = symbol.descriptor

        if (descriptor is WrappedDeclarationDescriptor<*>) return null