From 8ad202eb8bb1ff2535a178cd87da74d010687c2c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 11 Jul 2023 12:17:59 +0300 Subject: [PATCH] [IR] Remove descriptor-related methods from SymbolTable Replace them with calls to SymbolTableExtension --- .../fir/backend/Fir2IrDeclarationStorage.kt | 7 +- .../ir/backend/js/JsCommonBackendContext.kt | 8 +- .../kotlin/ir/backend/js/JsIntrinsics.kt | 32 +- .../ir/backend/js/JsIrBackendContext.kt | 62 +-- .../calls/ExceptionHelperCallsTransformer.kt | 2 +- .../backend/jvm/JvmGeneratorExtensionsImpl.kt | 2 +- .../SymbolTableWithBuiltInsDeduplication.kt | 6 +- .../backend/jvm/UndiscoveredExpectUtils.kt | 6 +- .../kotlin/backend/jvm/JvmBackendContext.kt | 8 +- .../kotlin/backend/wasm/WasmSymbols.kt | 24 +- .../descriptors/IrBuiltInsOverDescriptors.kt | 36 +- .../IrDescriptorBasedFunctionFactory.kt | 25 +- .../AnonymousInitializerGenerator.kt | 2 +- .../generators/ArgumentsGenerationUtils.kt | 20 +- .../psi2ir/generators/AssignmentGenerator.kt | 22 +- .../kotlin/psi2ir/generators/BodyGenerator.kt | 14 +- .../kotlin/psi2ir/generators/CallGenerator.kt | 24 +- .../psi2ir/generators/ClassGenerator.kt | 27 +- .../generators/DataClassMembersGenerator.kt | 2 +- .../psi2ir/generators/DeclarationGenerator.kt | 5 +- .../generators/DelegatedPropertyGenerator.kt | 6 +- .../generators/EnumClassMembersGenerator.kt | 5 +- .../generators/ExpectDependencyGenerator.kt | 14 +- .../psi2ir/generators/FunctionGenerator.kt | 9 +- .../psi2ir/generators/LocalClassGenerator.kt | 2 +- .../generators/LoopExpressionGenerator.kt | 2 +- .../psi2ir/generators/ModuleGenerator.kt | 2 +- .../generators/OperatorExpressionGenerator.kt | 2 +- .../psi2ir/generators/PropertyGenerator.kt | 10 +- .../ReflectionReferencesGenerator.kt | 18 +- .../psi2ir/generators/ScriptGenerator.kt | 10 +- .../StandaloneDeclarationGenerator.kt | 4 +- .../psi2ir/generators/StatementGenerator.kt | 10 +- .../SyntheticDeclarationsGenerator.kt | 16 +- .../FragmentCompilerSymbolTableDecorator.kt | 16 +- .../fragments/FragmentDeclarationGenerator.kt | 5 +- .../SourceDeclarationsPreprocessor.kt | 2 +- .../transformations/InsertImplicitCasts.kt | 4 +- .../ir/declarations/lazy/IrLazySymbolTable.kt | 14 +- .../ir/util/DeclarationStubGenerator.kt | 40 +- .../jetbrains/kotlin/ir/util/SymbolTable.kt | 364 ------------------ .../kotlin/ir/util/SymbolTableExtension.kt | 2 +- .../org/jetbrains/kotlin/ir/util/overrides.kt | 3 +- ...BuiltInFictitiousFunctionIrClassFactory.kt | 29 +- .../konan/cexport/CAdapterGenerator.kt | 5 +- .../jetbrains/kotlin/backend/konan/ir/Ir.kt | 14 +- .../interop/DescriptorToIrTranslationUtils.kt | 7 +- .../IrProviderForCEnumAndCStructStubs.kt | 14 +- .../ir/interop/cenum/CEnumClassGenerator.kt | 11 +- .../interop/cenum/CEnumCompanionGenerator.kt | 6 +- .../interop/cenum/CEnumVarClassGenerator.kt | 10 +- .../cstruct/CStructVarClassGenerator.kt | 6 +- .../cstruct/CStructVarCompanionGenerator.kt | 6 +- .../konan/objcexport/ObjCExportCodeSpec.kt | 20 +- .../plugin/impl/KJvmReplCompilerBase.kt | 2 +- 55 files changed, 349 insertions(+), 675 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index f932292f8e4..9e8f450ff5e 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -640,7 +640,12 @@ class Fir2IrDeclarationStorage( irParent: IrClass ): IrAnonymousInitializer = convertCatching(anonymousInitializer) { return anonymousInitializer.convertWithOffsets { startOffset, endOffset -> - symbolTable.declareAnonymousInitializer(startOffset, endOffset, IrDeclarationOrigin.DEFINED, irParent.descriptor).apply { + symbolTable.descriptorExtension.declareAnonymousInitializer( + startOffset, + endOffset, + IrDeclarationOrigin.DEFINED, + irParent.descriptor + ).apply { this.parent = irParent initializerCache[anonymousInitializer] = this } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsCommonBackendContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsCommonBackendContext.kt index 7d1165092cb..6a31f980f6f 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsCommonBackendContext.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsCommonBackendContext.kt @@ -64,7 +64,7 @@ class JsCommonCoroutineSymbols( val coroutineIntrinsicsPackage = module.getPackage(COROUTINE_INTRINSICS_PACKAGE_FQNAME) val coroutineImpl = - symbolTable.referenceClass(findClass(coroutinePackage.memberScope, COROUTINE_IMPL_NAME)) + symbolTable.descriptorExtension.referenceClass(findClass(coroutinePackage.memberScope, COROUTINE_IMPL_NAME)) val coroutineImplLabelPropertyGetter by lazy(LazyThreadSafetyMode.NONE) { coroutineImpl.getPropertyGetter("state")!!.owner } val coroutineImplLabelPropertySetter by lazy(LazyThreadSafetyMode.NONE) { coroutineImpl.getPropertySetter("state")!!.owner } @@ -75,14 +75,14 @@ class JsCommonCoroutineSymbols( val coroutineImplExceptionStatePropertyGetter by lazy(LazyThreadSafetyMode.NONE) { coroutineImpl.getPropertyGetter("exceptionState")!!.owner } val coroutineImplExceptionStatePropertySetter by lazy(LazyThreadSafetyMode.NONE) { coroutineImpl.getPropertySetter("exceptionState")!!.owner } - val continuationClass = symbolTable.referenceClass( + val continuationClass = symbolTable.descriptorExtension.referenceClass( coroutinePackage.memberScope.getContributedClassifier( CONTINUATION_NAME, NoLookupLocation.FROM_BACKEND ) as ClassDescriptor ) - val coroutineSuspendedGetter = symbolTable.referenceSimpleFunction( + val coroutineSuspendedGetter = symbolTable.descriptorExtension.referenceSimpleFunction( coroutineIntrinsicsPackage.memberScope.getContributedVariables( COROUTINE_SUSPENDED_NAME, NoLookupLocation.FROM_BACKEND @@ -154,4 +154,4 @@ interface JsCommonInlineClassesUtils : InlineClassesUtils { * An intrinsic for obtaining the underlying value from an instance of an inline class. */ val unboxIntrinsic: IrSimpleFunctionSymbol -} \ No newline at end of file +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt index 9d51d22421a..2c2193496b6 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt @@ -204,12 +204,12 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC val metadataObjectConstructorSymbol = getInternalFunction("objectMeta") val metadataClassConstructorSymbol = getInternalFunction("classMeta") - val longToDouble = context.symbolTable.referenceSimpleFunction( + val longToDouble = context.symbolTable.descriptorExtension.referenceSimpleFunction( context.getClass(FqName("kotlin.Long")).unsubstitutedMemberScope.findSingleFunction( Name.identifier("toDouble") ) ) - val longToFloat = context.symbolTable.referenceSimpleFunction( + val longToFloat = context.symbolTable.descriptorExtension.referenceSimpleFunction( context.getClass(FqName("kotlin.Long")).unsubstitutedMemberScope.findSingleFunction( Name.identifier("toFloat") ) @@ -323,12 +323,13 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC val jsBind = getInternalFunction("jsBind") // TODO move to IntrinsifyCallsLowering - val doNotIntrinsifyAnnotationSymbol = context.symbolTable.referenceClass(context.getJsInternalClass("DoNotIntrinsify")) - val jsFunAnnotationSymbol = context.symbolTable.referenceClass(context.getJsInternalClass("JsFun")) - val jsNameAnnotationSymbol = context.symbolTable.referenceClass(context.getJsInternalClass("JsName")) + val doNotIntrinsifyAnnotationSymbol = + context.symbolTable.descriptorExtension.referenceClass(context.getJsInternalClass("DoNotIntrinsify")) + val jsFunAnnotationSymbol = context.symbolTable.descriptorExtension.referenceClass(context.getJsInternalClass("JsFun")) + val jsNameAnnotationSymbol = context.symbolTable.descriptorExtension.referenceClass(context.getJsInternalClass("JsName")) val jsExportAnnotationSymbol by lazy(LazyThreadSafetyMode.NONE) { - context.symbolTable.referenceClass(context.getJsInternalClass("JsExport")) + context.symbolTable.descriptorExtension.referenceClass(context.getJsInternalClass("JsExport")) } val jsExportIgnoreAnnotationSymbol by lazy(LazyThreadSafetyMode.NONE) { @@ -337,10 +338,11 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC ?.symbol ?: error("can't find kotlin.js.JsExport.Ignore annotation") } - val jsImplicitExportAnnotationSymbol = context.symbolTable.referenceClass(context.getJsInternalClass("JsImplicitExport")) + val jsImplicitExportAnnotationSymbol = + context.symbolTable.descriptorExtension.referenceClass(context.getJsInternalClass("JsImplicitExport")) // TODO move CharSequence-related stiff to IntrinsifyCallsLowering - val charSequenceClassSymbol = context.symbolTable.referenceClass(context.getClass(FqName("kotlin.CharSequence"))) + val charSequenceClassSymbol = context.symbolTable.descriptorExtension.referenceClass(context.getClass(FqName("kotlin.CharSequence"))) val charSequenceLengthPropertyGetterSymbol by context.lazy2 { with(charSequenceClassSymbol.owner.declarations) { filterIsInstance().firstOrNull { it.name.asString() == "length" }?.getter ?: @@ -381,22 +383,24 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC // Helpers: private fun getInternalFunction(name: String) = - context.symbolTable.referenceSimpleFunction(context.getJsInternalFunction(name)) + context.symbolTable.descriptorExtension.referenceSimpleFunction(context.getJsInternalFunction(name)) private fun getInternalProperty(name: String) = - context.symbolTable.referenceProperty(context.getJsInternalProperty(name)) + context.symbolTable.descriptorExtension.referenceProperty(context.getJsInternalProperty(name)) private fun getInternalWithoutPackage(name: String) = - context.symbolTable.referenceSimpleFunction(context.getFunctions(FqName(name)).single()) + context.symbolTable.descriptorExtension.referenceSimpleFunction(context.getFunctions(FqName(name)).single()) private fun getInternalWithoutPackageOrNull(name: String): IrSimpleFunctionSymbol? { val descriptor = context.getFunctions(FqName(name)).singleOrNull() ?: return null - return context.symbolTable.referenceSimpleFunction(descriptor) + return context.symbolTable.descriptorExtension.referenceSimpleFunction(descriptor) } private fun getFunctionInKotlinPackage(name: String) = - context.symbolTable.referenceSimpleFunction(context.getFunctions(kotlinPackageFqn.child(Name.identifier(name))).single()) + context.symbolTable.descriptorExtension.referenceSimpleFunction( + context.getFunctions(kotlinPackageFqn.child(Name.identifier(name))).single() + ) private fun getInternalClassWithoutPackage(fqName: String) = - context.symbolTable.referenceClass(context.getClass(FqName(fqName))) + context.symbolTable.descriptorExtension.referenceClass(context.getClass(FqName(fqName))) } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt index ab280c942e7..ffb9169bfb5 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt @@ -160,7 +160,7 @@ class JsIrBackendContext( override val propertyLazyInitialization: PropertyLazyInitialization = PropertyLazyInitialization( enabled = configuration.get(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION, true), - eagerInitialization = symbolTable.referenceClass(getJsInternalClass("EagerInitialization")) + eagerInitialization = symbolTable.descriptorExtension.referenceClass(getJsInternalClass("EagerInitialization")) ) override val catchAllThrowableType: IrType @@ -194,36 +194,36 @@ class JsIrBackendContext( override val enumEntries = getIrClass(ENUMS_PACKAGE_FQNAME.child(Name.identifier("EnumEntries"))) override val createEnumEntries = getFunctions(ENUMS_PACKAGE_FQNAME.child(Name.identifier("enumEntries"))) .find { it.valueParameters.firstOrNull()?.type?.isFunctionType == false } - .let { symbolTable.referenceSimpleFunction(it!!) } + .let { symbolTable.descriptorExtension.referenceSimpleFunction(it!!) } override val ir = object : Ir(this) { override val symbols = object : Symbols(irBuiltIns, symbolTable) { private val context = this@JsIrBackendContext override val throwNullPointerException = - symbolTable.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_NPE"))).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_NPE"))).single()) init { - symbolTable.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("noWhenBranchMatchedException"))).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("noWhenBranchMatchedException"))).single()) } override val throwTypeCastException = - symbolTable.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_CCE"))).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_CCE"))).single()) override val throwUninitializedPropertyAccessException = - symbolTable.referenceSimpleFunction(getFunctions(FqName("kotlin.throwUninitializedPropertyAccessException")).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(FqName("kotlin.throwUninitializedPropertyAccessException")).single()) override val throwKotlinNothingValueException: IrSimpleFunctionSymbol = - symbolTable.referenceSimpleFunction(getFunctions(FqName("kotlin.throwKotlinNothingValueException")).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(FqName("kotlin.throwKotlinNothingValueException")).single()) override val defaultConstructorMarker = - symbolTable.referenceClass(context.getJsInternalClass("DefaultConstructorMarker")) + symbolTable.descriptorExtension.referenceClass(context.getJsInternalClass("DefaultConstructorMarker")) override val throwISE: IrSimpleFunctionSymbol = - symbolTable.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_ISE"))).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_ISE"))).single()) override val throwIAE: IrSimpleFunctionSymbol = - symbolTable.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_IAE"))).single()) + symbolTable.descriptorExtension.referenceSimpleFunction(getFunctions(kotlinPackageFqn.child(Name.identifier("THROW_IAE"))).single()) override val stringBuilder get() = TODO("not implemented") @@ -234,7 +234,7 @@ class JsIrBackendContext( private val _arraysContentEquals = getFunctions(FqName("kotlin.collections.contentEquals")).mapNotNull { if (it.extensionReceiverParameter != null && it.extensionReceiverParameter!!.type.isNullable()) - symbolTable.referenceSimpleFunction(it) + symbolTable.descriptorExtension.referenceSimpleFunction(it) else null } @@ -242,19 +242,21 @@ class JsIrBackendContext( override val arraysContentEquals: Map get() = _arraysContentEquals.associateBy { it.owner.extensionReceiverParameter!!.type.makeNotNull() } - override val getContinuation = symbolTable.referenceSimpleFunction(getJsInternalFunction("getContinuation")) + override val getContinuation = symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction("getContinuation")) override val continuationClass = context.coroutineSymbols.continuationClass override val coroutineContextGetter = - symbolTable.referenceSimpleFunction(context.coroutineSymbols.coroutineContextProperty.getter!!) + symbolTable.descriptorExtension.referenceSimpleFunction(context.coroutineSymbols.coroutineContextProperty.getter!!) override val suspendCoroutineUninterceptedOrReturn = - symbolTable.referenceSimpleFunction(getJsInternalFunction(COROUTINE_SUSPEND_OR_RETURN_JS_NAME)) + symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction(COROUTINE_SUSPEND_OR_RETURN_JS_NAME)) - override val coroutineGetContext = symbolTable.referenceSimpleFunction(getJsInternalFunction(GET_COROUTINE_CONTEXT_NAME)) + override val coroutineGetContext = + symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction(GET_COROUTINE_CONTEXT_NAME)) - override val returnIfSuspended = symbolTable.referenceSimpleFunction(getJsInternalFunction("returnIfSuspended")) + override val returnIfSuspended = + symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction("returnIfSuspended")) override val functionAdapter: IrClassSymbol get() = TODO("Not implemented") @@ -300,7 +302,7 @@ class JsIrBackendContext( // classes forced to be loaded val errorCodeSymbol: IrSimpleFunctionSymbol? = - if (errorPolicy.allowErrors) symbolTable.referenceSimpleFunction(getJsInternalFunction("errorCode")) else null + if (errorPolicy.allowErrors) symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction("errorCode")) else null val throwableClass = getIrClass(JsIrBackendContext.KOTLIN_PACKAGE_FQN.child(Name.identifier("Throwable"))) @@ -311,7 +313,7 @@ class JsIrBackendContext( // Top-level functions forced to be loaded - val coroutineEmptyContinuation = symbolTable.referenceProperty( + val coroutineEmptyContinuation = symbolTable.descriptorExtension.referenceProperty( getProperty( FqName.fromSegments( listOf( @@ -326,20 +328,28 @@ class JsIrBackendContext( ) - val newThrowableSymbol = symbolTable.referenceSimpleFunction(getJsInternalFunction("newThrowable")) - val extendThrowableSymbol = symbolTable.referenceSimpleFunction(getJsInternalFunction("extendThrowable")) + val newThrowableSymbol = symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction("newThrowable")) + val extendThrowableSymbol = symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction("extendThrowable")) val setPropertiesToThrowableInstanceSymbol = - symbolTable.referenceSimpleFunction(getJsInternalFunction("setPropertiesToThrowableInstance")) + symbolTable.descriptorExtension.referenceSimpleFunction(getJsInternalFunction("setPropertiesToThrowableInstance")) - override val suiteFun = getFunctions(FqName("kotlin.test.suite")).singleOrNull()?.let { symbolTable.referenceSimpleFunction(it) } - override val testFun = getFunctions(FqName("kotlin.test.test")).singleOrNull()?.let { symbolTable.referenceSimpleFunction(it) } + override val suiteFun = getFunctions(FqName("kotlin.test.suite")).singleOrNull()?.let { + symbolTable.descriptorExtension.referenceSimpleFunction(it) + } + override val testFun = getFunctions(FqName("kotlin.test.test")).singleOrNull()?.let { + symbolTable.descriptorExtension.referenceSimpleFunction(it) + } val throwableConstructors by lazy2 { throwableClass.owner.declarations.filterIsInstance().map { it.symbol } } val defaultThrowableCtor by lazy2 { throwableConstructors.single { !it.owner.isPrimary && it.owner.valueParameters.size == 0 } } - val kpropertyBuilder = getFunctions(FqName("kotlin.js.getPropertyCallableRef")).single().let { symbolTable.referenceSimpleFunction(it) } + val kpropertyBuilder = getFunctions(FqName("kotlin.js.getPropertyCallableRef")).single().let { + symbolTable.descriptorExtension.referenceSimpleFunction(it) + } val klocalDelegateBuilder = - getFunctions(FqName("kotlin.js.getLocalDelegateReference")).single().let { symbolTable.referenceSimpleFunction(it) } + getFunctions(FqName("kotlin.js.getLocalDelegateReference")).single().let { + symbolTable.descriptorExtension.referenceSimpleFunction(it) + } private fun referenceOperators(): Map>> { val primitiveIrSymbols = irBuiltIns.primitiveIrTypes.map { it.classifierOrFail as IrClassSymbol } @@ -365,7 +375,7 @@ class JsIrBackendContext( internal fun getProperty(fqName: FqName): PropertyDescriptor = findProperty(module.getPackage(fqName.parent()).memberScope, fqName.shortName()).single() - internal fun getIrClass(fqName: FqName): IrClassSymbol = symbolTable.referenceClass(getClass(fqName)) + internal fun getIrClass(fqName: FqName): IrClassSymbol = symbolTable.descriptorExtension.referenceClass(getClass(fqName)) internal fun getJsInternalFunction(name: String): SimpleFunctionDescriptor = findFunctions(internalPackage.memberScope, Name.identifier(name)).singleOrNull() ?: error("Internal function '$name' not found") diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt index b0729487d47..585d0c32f63 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt @@ -19,7 +19,7 @@ class ExceptionHelperCallsTransformer(private val context: JsIrBackendContext) : @OptIn(ObsoleteDescriptorBasedAPI::class) private fun referenceFunction(fqn: FqName) = context.getFunctions(fqn).singleOrNull()?.let { - context.symbolTable.referenceSimpleFunction(it) + context.symbolTable.descriptorExtension.referenceSimpleFunction(it) } ?: throw AssertionError("Function not found: $fqn") private val helperMapping = mapOf( diff --git a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt index 66562742c95..385a8377edd 100644 --- a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt +++ b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt @@ -172,7 +172,7 @@ open class JvmGeneratorExtensionsImpl( return IrDelegatingConstructorCallImpl.fromSymbolDescriptor( ktPureClassOrObject.pureStartOffset, ktPureClassOrObject.pureEndOffset, context.irBuiltIns.unitType, - context.symbolTable.referenceConstructor(recordConstructor) + context.symbolTable.descriptorExtension.referenceConstructor(recordConstructor) ) } diff --git a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt index 9e1c7eb3dd1..92b514fba0f 100644 --- a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt +++ b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/SymbolTableWithBuiltInsDeduplication.kt @@ -54,7 +54,7 @@ class SymbolTableWithBuiltInsDeduplication( */ @ObsoleteDescriptorBasedAPI override fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol { - val irBuiltIns = this.irBuiltIns ?: return super.referenceClass(descriptor) + val irBuiltIns = this.irBuiltIns ?: return super.descriptorExtension.referenceClass(descriptor) // 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. @@ -62,10 +62,10 @@ class SymbolTableWithBuiltInsDeduplication( if (builtInDescriptor != null) { // We need to delegate to the supertype implementation here to break recursion. `findBuiltInClassDescriptor` will return // `descriptor` even if `descriptor` was found via `findBuiltInClassDescriptor`. - return super.referenceClass(builtInDescriptor) + return super.descriptorExtension.referenceClass(builtInDescriptor) } - return super.referenceClass(descriptor) + return super.descriptorExtension.referenceClass(descriptor) } private fun IrBuiltInsOverDescriptors.findBuiltInClassDescriptor(descriptor: ClassDescriptor): ClassDescriptor? { diff --git a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/UndiscoveredExpectUtils.kt b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/UndiscoveredExpectUtils.kt index 3c7f16cf899..2adfa80280b 100644 --- a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/UndiscoveredExpectUtils.kt +++ b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/UndiscoveredExpectUtils.kt @@ -36,12 +36,12 @@ class UndiscoveredExpectVisitor( ) : KtTreeVisitorVoid() { override fun visitClassOrObject(classOrObject: KtClassOrObject) { super.visitClassOrObject(classOrObject) - symbolTable.referenceClass(classOrObject.findExpectForActual(BindingContext.CLASS) ?: return) + symbolTable.descriptorExtension.referenceClass(classOrObject.findExpectForActual(BindingContext.CLASS) ?: return) } override fun visitTypeAlias(typeAlias: KtTypeAlias) { super.visitTypeAlias(typeAlias) - symbolTable.referenceTypeAlias(typeAlias.findExpectForActual(BindingContext.TYPE_ALIAS) ?: return) + symbolTable.descriptorExtension.referenceTypeAlias(typeAlias.findExpectForActual(BindingContext.TYPE_ALIAS) ?: return) } override fun visitPrimaryConstructor(constructor: KtPrimaryConstructor) { @@ -65,7 +65,7 @@ class UndiscoveredExpectVisitor( override fun visitProperty(property: KtProperty) { super.visitProperty(property) - symbolTable.referenceProperty( + symbolTable.descriptorExtension.referenceProperty( property.findExpectForActualOfType(BindingContext.VARIABLE) ?: return ) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index 90c4c6ee4ff..40494d1e6bd 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.IrBuiltIns import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope import org.jetbrains.kotlin.ir.builders.irBlock import org.jetbrains.kotlin.ir.declarations.* @@ -41,6 +42,7 @@ import org.jetbrains.kotlin.resolve.jvm.JvmClassName import org.jetbrains.org.objectweb.asm.Type import java.util.concurrent.ConcurrentHashMap +@OptIn(ObsoleteDescriptorBasedAPI::class) class JvmBackendContext( val state: GenerationState, override val irBuiltIns: IrBuiltIns, @@ -192,7 +194,7 @@ class JvmBackendContext( } state.multiFieldValueClassUnboxInfo = lambda@{ descriptor -> - val irClass = symbolTable.lazyWrapper.referenceClass(descriptor).owner + val irClass = symbolTable.lazyWrapper.descriptorExtension.referenceClass(descriptor).owner val node = multiFieldValueClassReplacements.getRootMfvcNodeOrNull(irClass) ?: return@lambda null val leavesInfo = node.leaves.map { Triple(defaultTypeMapper.mapType(it.type), it.fullMethodName.asString(), it.fullFieldName.asString()) } @@ -201,10 +203,10 @@ class JvmBackendContext( } fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol = - symbolTable.lazyWrapper.referenceClass(descriptor) + symbolTable.lazyWrapper.descriptorExtension.referenceClass(descriptor) internal fun referenceTypeParameter(descriptor: TypeParameterDescriptor): IrTypeParameterSymbol = - symbolTable.lazyWrapper.referenceTypeParameter(descriptor) + symbolTable.lazyWrapper.descriptorExtension.referenceTypeParameter(descriptor) override fun log(message: () -> String) { /*TODO*/ diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt index 6231a0e8aff..3b8a55992aa 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmSymbols.kt @@ -71,7 +71,7 @@ class WasmSymbols( internal val eagerInitialization: IrClassSymbol = getIrClass(FqName("kotlin.EagerInitialization")) - internal val isNotFirstWasmExportCall: IrPropertySymbol = symbolTable.referenceProperty( + internal val isNotFirstWasmExportCall: IrPropertySymbol = symbolTable.descriptorExtension.referenceProperty( getProperty(FqName.fromSegments(listOf("kotlin", "wasm", "internal", "isNotFirstWasmExportCall"))) ) @@ -103,7 +103,7 @@ class WasmSymbols( override val continuationClass = context.coroutineSymbols.continuationClass override val coroutineContextGetter = - symbolTable.referenceSimpleFunction(context.coroutineSymbols.coroutineContextProperty.getter!!) + symbolTable.descriptorExtension.referenceSimpleFunction(context.coroutineSymbols.coroutineContextProperty.getter!!) override val suspendCoroutineUninterceptedOrReturn = getInternalFunction("suspendCoroutineUninterceptedOrReturn") override val coroutineGetContext = @@ -114,12 +114,12 @@ class WasmSymbols( val enumEntries = getIrClass(FqName.fromSegments(listOf("kotlin", "enums", "EnumEntries"))) val createEnumEntries = findFunctions(enumsInternalPackage.memberScope, Name.identifier("enumEntries")) .find { it.valueParameters.firstOrNull()?.type?.isFunctionType == false } - .let { symbolTable.referenceSimpleFunction(it!!) } + .let { symbolTable.descriptorExtension.referenceSimpleFunction(it!!) } val enumValueOfIntrinsic = getInternalFunction("enumValueOfIntrinsic") val enumValuesIntrinsic = getInternalFunction("enumValuesIntrinsic") - val coroutineEmptyContinuation: IrPropertySymbol = symbolTable.referenceProperty( + val coroutineEmptyContinuation: IrPropertySymbol = symbolTable.descriptorExtension.referenceProperty( getProperty(FqName.fromSegments(listOf("kotlin", "wasm", "internal", "EmptyContinuation"))) ) @@ -142,7 +142,7 @@ class WasmSymbols( context.irBuiltIns.floatType to getInternalFunction("consumeFloatIntoVoid"), context.irBuiltIns.doubleType to getInternalFunction("consumeDoubleIntoVoid") ) - + fun findVoidConsumer(type: IrType): IrSimpleFunctionSymbol = consumePrimitiveIntoVoid[type] ?: consumeAnyIntoVoid @@ -209,7 +209,9 @@ class WasmSymbols( val intToLong = getInternalFunction("wasm_i64_extend_i32_s") val rangeCheck = getInternalFunction("rangeCheck") - val assertFuncs = findFunctions(kotlinTopLevelPackage.memberScope, Name.identifier("assert")).map { symbolTable.referenceSimpleFunction(it) } + val assertFuncs = findFunctions(kotlinTopLevelPackage.memberScope, Name.identifier("assert")).map { + symbolTable.descriptorExtension.referenceSimpleFunction(it) + } val boxIntrinsic: IrSimpleFunctionSymbol = getInternalFunction("boxIntrinsic") val unboxIntrinsic: IrSimpleFunctionSymbol = getInternalFunction("unboxIntrinsic") @@ -256,15 +258,15 @@ class WasmSymbols( val kTypeStub = getInternalFunction("kTypeStub") val arraysCopyInto = findFunctions(collectionsPackage.memberScope, Name.identifier("copyInto")) - .map { symbolTable.referenceSimpleFunction(it) } + .map { symbolTable.descriptorExtension.referenceSimpleFunction(it) } private val contentToString: List = findFunctions(collectionsPackage.memberScope, Name.identifier("contentToString")) - .map { symbolTable.referenceSimpleFunction(it) } + .map { symbolTable.descriptorExtension.referenceSimpleFunction(it) } private val contentHashCode: List = findFunctions(collectionsPackage.memberScope, Name.identifier("contentHashCode")) - .map { symbolTable.referenceSimpleFunction(it) } + .map { symbolTable.descriptorExtension.referenceSimpleFunction(it) } private fun findOverloadForReceiver(arrayType: IrType, overloadsList: List): IrSimpleFunctionSymbol = overloadsList.first { @@ -375,12 +377,12 @@ class WasmSymbols( val tmp = findFunctions(ownerPackage.memberScope, Name.identifier(name)) if (tmp.isEmpty()) return null - return symbolTable.referenceSimpleFunction(tmp.single()) + return symbolTable.descriptorExtension.referenceSimpleFunction(tmp.single()) } private fun getInternalFunction(name: String) = getFunction(name, wasmInternalPackage) - private fun getIrClass(fqName: FqName): IrClassSymbol = symbolTable.referenceClass(getClass(fqName)) + private fun getIrClass(fqName: FqName): IrClassSymbol = symbolTable.descriptorExtension.referenceClass(getClass(fqName)) private fun getInternalClass(name: String): IrClassSymbol = getIrClass(FqName("kotlin.wasm.internal.$name")) fun getKFunctionType(type: IrType, list: List): IrType { return irBuiltIns.functionN(list.size).typeWith(list + type) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt index c9cb6682df3..ba5d832cb60 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt @@ -83,11 +83,15 @@ class IrBuiltInsOverDescriptors( private val packageFragmentDescriptor = IrBuiltinsPackageFragmentDescriptorImpl(builtInsModule, KOTLIN_INTERNAL_IR_FQN) override val operatorsPackageFragment: IrExternalPackageFragment = - IrExternalPackageFragmentImpl(symbolTable.referenceExternalPackageFragment(packageFragmentDescriptor), KOTLIN_INTERNAL_IR_FQN) + IrExternalPackageFragmentImpl( + symbolTable.descriptorExtension.referenceExternalPackageFragment(packageFragmentDescriptor), + KOTLIN_INTERNAL_IR_FQN + ) private fun ClassDescriptor.toIrSymbol(): IrClassSymbol { - return symbolTable.referenceClass(this) + return symbolTable.descriptorExtension.referenceClass(this) } + private fun KotlinType.toIrType() = typeTranslator.translateType(this) private fun defineOperator( @@ -104,7 +108,7 @@ class IrBuiltInsOverDescriptors( ) } - val symbol = symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) { + val symbol = symbolTable.descriptorExtension.declareSimpleFunctionIfNotExists(operatorDescriptor) { val operator = irFactory.createSimpleFunction( startOffset = UNDEFINED_OFFSET, endOffset = UNDEFINED_OFFSET, @@ -198,8 +202,8 @@ class IrBuiltInsOverDescriptors( ) } - return symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) { operatorSymbol -> - val typeParameter = symbolTable.declareGlobalTypeParameter( + return symbolTable.descriptorExtension.declareSimpleFunctionIfNotExists(operatorDescriptor) { operatorSymbol -> + val typeParameter = symbolTable.descriptorExtension.declareGlobalTypeParameter( UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, typeParameterDescriptor @@ -456,7 +460,7 @@ class IrBuiltInsOverDescriptors( val booleanNot = builtIns.boolean.unsubstitutedMemberScope.getContributedFunctions(Name.identifier("not"), NoLookupLocation.FROM_BACKEND).single() - override val booleanNotSymbol = symbolTable.referenceSimpleFunction(booleanNot) + override val booleanNotSymbol = symbolTable.descriptorExtension.referenceSimpleFunction(booleanNot) override val eqeqeqSymbol = defineOperator(BuiltInOperatorNames.EQEQEQ, booleanType, listOf(anyNType, anyNType)) override val eqeqSymbol = defineOperator(BuiltInOperatorNames.EQEQ, booleanType, listOf(anyNType, anyNType), isIntrinsicConst = true) @@ -481,17 +485,17 @@ class IrBuiltInsOverDescriptors( override val intTimesSymbol: IrSimpleFunctionSymbol = builtIns.int.unsubstitutedMemberScope.findFirstFunction("times") { KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int) - }.let { symbolTable.referenceSimpleFunction(it) } + }.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) } override val intXorSymbol: IrSimpleFunctionSymbol = builtIns.int.unsubstitutedMemberScope.findFirstFunction("xor") { KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int) - }.let { symbolTable.referenceSimpleFunction(it) } + }.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) } override val intPlusSymbol: IrSimpleFunctionSymbol = builtIns.int.unsubstitutedMemberScope.findFirstFunction("plus") { KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int) - }.let { symbolTable.referenceSimpleFunction(it) } + }.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) } override val arrayOf = findFunctions(Name.identifier("arrayOf")).first { it.descriptor.extensionReceiverParameter == null && it.descriptor.dispatchReceiverParameter == null && @@ -512,27 +516,27 @@ class IrBuiltInsOverDescriptors( override fun findFunctions(name: Name, vararg packageNameSegments: String): Iterable = builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND).map { - symbolTable.referenceSimpleFunction(it) + symbolTable.descriptorExtension.referenceSimpleFunction(it) } override fun findFunctions(name: Name, packageFqName: FqName): Iterable = builtIns.builtInsModule.getPackage(packageFqName).memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND).map { - symbolTable.referenceSimpleFunction(it) + symbolTable.descriptorExtension.referenceSimpleFunction(it) } override fun findProperties(name: Name, packageFqName: FqName): Iterable = builtIns.builtInsModule.getPackage(packageFqName).memberScope.getContributedVariables(name, NoLookupLocation.FROM_BACKEND).map { - symbolTable.referenceProperty(it) + symbolTable.descriptorExtension.referenceProperty(it) } override fun findClass(name: Name, vararg packageNameSegments: String): IrClassSymbol? = (builtInsPackage(*packageNameSegments).getContributedClassifier( name, NoLookupLocation.FROM_BACKEND - ) as? ClassDescriptor)?.let { symbolTable.referenceClass(it) } + ) as? ClassDescriptor)?.let { symbolTable.descriptorExtension.referenceClass(it) } override fun findClass(name: Name, packageFqName: FqName): IrClassSymbol? = - findClassDescriptor(name, packageFqName)?.let { symbolTable.referenceClass(it) } + findClassDescriptor(name, packageFqName)?.let { symbolTable.descriptorExtension.referenceClass(it) } fun findClassDescriptor(name: Name, packageFqName: FqName): ClassDescriptor? = builtIns.builtInsModule.getPackage(packageFqName).memberScope.getContributedClassifier( @@ -543,7 +547,7 @@ class IrBuiltInsOverDescriptors( override fun findBuiltInClassMemberFunctions(builtInClass: IrClassSymbol, name: Name): Iterable = builtInClass.descriptor.unsubstitutedMemberScope .getContributedFunctions(name, NoLookupLocation.FROM_BACKEND) - .map { symbolTable.referenceSimpleFunction(it) } + .map { symbolTable.descriptorExtension.referenceSimpleFunction(it) } private val binaryOperatorCache = mutableMapOf, IrSimpleFunctionSymbol>() @@ -587,7 +591,7 @@ class IrBuiltInsOverDescriptors( val result = mutableMapOf() for (d in builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)) { makeKey(d)?.let { key -> - result[key] = symbolTable.referenceSimpleFunction(d) + result[key] = symbolTable.descriptorExtension.referenceSimpleFunction(d) } } return result diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrDescriptorBasedFunctionFactory.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrDescriptorBasedFunctionFactory.kt index 75ad1495915..631cc4f3ad1 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrDescriptorBasedFunctionFactory.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrDescriptorBasedFunctionFactory.kt @@ -48,7 +48,7 @@ abstract class IrAbstractDescriptorBasedFunctionFactory { fun functionN(n: Int) = functionN(n) { callback -> val descriptor = functionClassDescriptor(n) - declareClass(descriptor) { symbol -> + descriptorExtension.declareClass(descriptor) { symbol -> callback(symbol) } } @@ -56,7 +56,7 @@ abstract class IrAbstractDescriptorBasedFunctionFactory { fun kFunctionN(n: Int): IrClass { return kFunctionN(n) { callback -> val descriptor = kFunctionClassDescriptor(n) - declareClass(descriptor) { symbol -> + descriptorExtension.declareClass(descriptor) { symbol -> callback(symbol) } } @@ -64,14 +64,14 @@ abstract class IrAbstractDescriptorBasedFunctionFactory { fun suspendFunctionN(n: Int): IrClass = suspendFunctionN(n) { callback -> val descriptor = suspendFunctionClassDescriptor(n) - declareClass(descriptor) { symbol -> + descriptorExtension.declareClass(descriptor) { symbol -> callback(symbol) } } fun kSuspendFunctionN(n: Int): IrClass = kSuspendFunctionN(n) { callback -> val descriptor = kSuspendFunctionClassDescriptor(n) - declareClass(descriptor) { symbol -> + descriptorExtension.declareClass(descriptor) { symbol -> callback(symbol) } } @@ -96,7 +96,7 @@ class IrDescriptorBasedFunctionFactory( private val referenceFunctionsWhenKFunctionAreReferenced: Boolean = false, ) : IrAbstractDescriptorBasedFunctionFactory() { val getPackageFragment = - getPackageFragment ?: symbolTable::declareExternalPackageFragmentIfNotExists + getPackageFragment ?: symbolTable.descriptorExtension::declareExternalPackageFragmentIfNotExists // TODO: Lazieness @@ -107,8 +107,10 @@ class IrDescriptorBasedFunctionFactory( private val irFactory: IrFactory get() = symbolTable.irFactory - val functionClass = symbolTable.referenceClass(irBuiltIns.builtIns.getBuiltInClassByFqName(FqName("kotlin.Function"))) - val kFunctionClass = symbolTable.referenceClass(irBuiltIns.builtIns.getBuiltInClassByFqName(FqName("kotlin.reflect.KFunction"))) + val functionClass = + symbolTable.descriptorExtension.referenceClass(irBuiltIns.builtIns.getBuiltInClassByFqName(FqName("kotlin.Function"))) + val kFunctionClass = + symbolTable.descriptorExtension.referenceClass(irBuiltIns.builtIns.getBuiltInClassByFqName(FqName("kotlin.reflect.KFunction"))) override fun functionClassDescriptor(arity: Int): FunctionClassDescriptor = irBuiltIns.builtIns.getFunction(arity) as FunctionClassDescriptor @@ -190,7 +192,7 @@ class IrDescriptorBasedFunctionFactory( getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_BACKEND).first() } } - return symbolTable.declareSimpleFunction(descriptor, factory).symbol + return symbolTable.descriptorExtension.declareSimpleFunction(descriptor, factory).symbol } override fun FunctionDescriptor.valueParameterDescriptor(index: Int): ValueParameterDescriptor { @@ -406,7 +408,7 @@ class IrDescriptorBasedFunctionFactory( fun createFakeOverrideFunction(descriptor: FunctionDescriptor, property: IrPropertySymbol?): IrSimpleFunction { val returnType = descriptor.returnType?.let { toIrType(it) } ?: error("No return type for $descriptor") - val newFunction = symbolTable.declareSimpleFunction(descriptor) { + val newFunction = symbolTable.descriptorExtension.declareSimpleFunction(descriptor) { descriptor.run { irFactory.createSimpleFunction( startOffset = offset, @@ -430,7 +432,8 @@ class IrDescriptorBasedFunctionFactory( } newFunction.parent = this - newFunction.overriddenSymbols = descriptor.overriddenDescriptors.memoryOptimizedMap { symbolTable.referenceSimpleFunction(it.original) } + newFunction.overriddenSymbols = + descriptor.overriddenDescriptors.memoryOptimizedMap { symbolTable.descriptorExtension.referenceSimpleFunction(it.original) } newFunction.dispatchReceiverParameter = descriptor.dispatchReceiverParameter?.let { newFunction.createValueParameter(it) } newFunction.extensionReceiverParameter = descriptor.extensionReceiverParameter?.let { newFunction.createValueParameter(it) } newFunction.contextReceiverParametersCount = descriptor.contextReceiverParameters.size @@ -444,7 +447,7 @@ class IrDescriptorBasedFunctionFactory( } fun createFakeOverrideProperty(descriptor: PropertyDescriptor): IrProperty { - return symbolTable.declareProperty(descriptor) { + return symbolTable.descriptorExtension.declareProperty(descriptor) { irFactory.createProperty( startOffset = offset, endOffset = offset, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnonymousInitializerGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnonymousInitializerGenerator.kt index a50c9e87477..c09372076e5 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnonymousInitializerGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnonymousInitializerGenerator.kt @@ -32,7 +32,7 @@ internal class AnonymousInitializerGenerator( ktAnonymousInitializer: KtAnonymousInitializer, irClass: IrClass ): IrAnonymousInitializer = - context.symbolTable.declareAnonymousInitializer( + context.symbolTable.descriptorExtension.declareAnonymousInitializer( ktAnonymousInitializer.startOffsetSkippingComments, ktAnonymousInitializer.endOffset, IrDeclarationOrigin.DEFINED, irClass.descriptor ).buildWithScope { irAnonymousInitializer -> diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt index e3b9a7534f3..4dfa615c048 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt @@ -79,7 +79,7 @@ private fun StatementGenerator.generateContextReceiverForDelegatingConstructorCa return object : ExpressionValue(irReceiverType) { override fun load(): IrExpression = IrGetValueImpl( defaultStartOffset, defaultEndOffset, irReceiverType, - context.symbolTable.referenceValueParameter(receiverParameter) + context.symbolTable.descriptorExtension.referenceValueParameter(receiverParameter) ) } } @@ -114,7 +114,7 @@ private fun StatementGenerator.generateReceiver(defaultStartOffset: Int, default else IrGetValueImpl( defaultStartOffset, defaultEndOffset, irReceiverType, - context.symbolTable.referenceValueParameter(receiverClassDescriptor.thisAsReceiverParameter) + context.symbolTable.descriptorExtension.referenceValueParameter(receiverClassDescriptor.thisAsReceiverParameter) ) } is ContextClassReceiver -> loadContextReceiver(receiver, defaultStartOffset, defaultEndOffset) @@ -127,7 +127,7 @@ private fun StatementGenerator.generateReceiver(defaultStartOffset: Int, default is ExtensionReceiver -> { IrGetValueImpl( defaultStartOffset, defaultStartOffset, irReceiverType, - context.symbolTable.referenceValueParameter(receiver.declarationDescriptor.extensionReceiverParameter!!) + context.symbolTable.descriptorExtension.referenceValueParameter(receiver.declarationDescriptor.extensionReceiverParameter!!) ) } is ContextReceiver -> { @@ -135,7 +135,7 @@ private fun StatementGenerator.generateReceiver(defaultStartOffset: Int, default .single { it.value == receiver.original } IrGetValueImpl( defaultStartOffset, defaultStartOffset, irReceiverType, - context.symbolTable.referenceValueParameter(receiverParameter) + context.symbolTable.descriptorExtension.referenceValueParameter(receiverParameter) ) } else -> @@ -153,7 +153,7 @@ internal fun StatementGenerator.loadContextReceiver( val thisReceiver = IrGetValueImpl( defaultStartOffset, defaultEndOffset, thisAsReceiverParameter.type.toIrType(), - context.symbolTable.referenceValue(thisAsReceiverParameter) + context.symbolTable.descriptorExtension.referenceValue(thisAsReceiverParameter) ) return IrGetFieldImpl( @@ -176,19 +176,19 @@ internal fun StatementGenerator.generateSingletonReference( DescriptorUtils.isObject(descriptor) -> IrGetObjectValueImpl( startOffset, endOffset, irType, - context.symbolTable.referenceClass(descriptor) + context.symbolTable.descriptorExtension.referenceClass(descriptor) ) DescriptorUtils.isEnumEntry(descriptor) -> IrGetEnumValueImpl( startOffset, endOffset, irType, - context.symbolTable.referenceEnumEntry(descriptor) + context.symbolTable.descriptorExtension.referenceEnumEntry(descriptor) ) else -> { val companionObjectDescriptor = descriptor.companionObjectDescriptor ?: throw java.lang.AssertionError("Class value without companion object: $descriptor") IrGetObjectValueImpl( startOffset, endOffset, irType, - context.symbolTable.referenceClass(companionObjectDescriptor) + context.symbolTable.descriptorExtension.referenceClass(companionObjectDescriptor) ) } } @@ -287,7 +287,7 @@ private fun StatementGenerator.generateReceiverForCalleeImportedFromObject( return generateExpressionValue(objectType) { IrGetObjectValueImpl( startOffset, endOffset, objectType, - context.symbolTable.referenceClass(objectDescriptor) + context.symbolTable.descriptorExtension.referenceClass(objectDescriptor) ) } } @@ -473,7 +473,7 @@ private fun StatementGenerator.createFunctionForSuspendConversion( .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND) .find { it.valueParameters.size == valueArgumentsCount } ?: error("No matching operator fun 'invoke' for suspend conversion: funType=$funType, suspendFunType=$suspendFunType") - val invokeSymbol = context.symbolTable.referenceSimpleFunction(invokeDescriptor.original) + val invokeSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(invokeDescriptor.original) irAdapterFun.body = irBlockBody(startOffset, endOffset) { val irAdapteeCall = IrCallImpl( diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AssignmentGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AssignmentGenerator.kt index b9e6969e662..3b57b1065b7 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AssignmentGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AssignmentGenerator.kt @@ -201,8 +201,8 @@ internal class AssignmentGenerator(statementGenerator: StatementGenerator) : Sta context, startOffset, endOffset, descriptor.type.toIrType(), - descriptor.getter?.let { context.symbolTable.referenceDeclaredFunction(it) }, - descriptor.setter?.let { context.symbolTable.referenceDeclaredFunction(it) }, + descriptor.getter?.let { context.symbolTable.descriptorExtension.referenceDeclaredFunction(it) }, + descriptor.setter?.let { context.symbolTable.descriptorExtension.referenceDeclaredFunction(it) }, origin ) else @@ -251,7 +251,7 @@ internal class AssignmentGenerator(statementGenerator: StatementGenerator) : Sta VariableLValue( context, ktExpression.startOffsetSkippingComments, ktExpression.endOffset, - context.symbolTable.referenceValue(descriptor), + context.symbolTable.descriptorExtension.referenceValue(descriptor), descriptor.type.toIrType(), origin ) @@ -266,7 +266,7 @@ internal class AssignmentGenerator(statementGenerator: StatementGenerator) : Sta context, ktExpression.startOffsetSkippingComments, ktExpression.endOffset, descriptor.type.toIrType(), - context.symbolTable.referenceField(descriptor), + context.symbolTable.descriptorExtension.referenceField(descriptor), receiverValue, origin ) @@ -338,12 +338,12 @@ internal class AssignmentGenerator(statementGenerator: StatementGenerator) : Sta val setterDescriptor = unwrappedPropertyDescriptor.unwrappedSetMethod ?.takeUnless { it.visibility == DescriptorVisibilities.INVISIBLE_FAKE } - val getterSymbol = getterDescriptor?.let { context.symbolTable.referenceSimpleFunction(it.original) } - val setterSymbol = setterDescriptor?.let { context.symbolTable.referenceSimpleFunction(it.original) } + val getterSymbol = getterDescriptor?.let { context.symbolTable.descriptorExtension.referenceSimpleFunction(it.original) } + val setterSymbol = setterDescriptor?.let { context.symbolTable.descriptorExtension.referenceSimpleFunction(it.original) } val propertyIrType = resultingDescriptor.type.toIrType() return if (getterSymbol != null || setterSymbol != null) { - val superQualifierSymbol = superQualifier?.let { context.symbolTable.referenceClass(it) } + val superQualifierSymbol = superQualifier?.let { context.symbolTable.descriptorExtension.referenceClass(it) } val typeArgumentsList = typeArgumentsMap?.let { typeArguments -> candidateDescriptor.typeParameters.map { @@ -369,12 +369,16 @@ internal class AssignmentGenerator(statementGenerator: StatementGenerator) : Sta ) } else { val superQualifierSymbol = (superQualifier - ?: unwrappedPropertyDescriptor.containingDeclaration as? ClassDescriptor)?.let { context.symbolTable.referenceClass(it) } + ?: unwrappedPropertyDescriptor.containingDeclaration as? ClassDescriptor)?.let { + context.symbolTable.descriptorExtension.referenceClass( + it + ) + } FieldPropertyLValue( context, scope, ktExpression.startOffsetSkippingComments, ktExpression.endOffset, origin, - context.symbolTable.referenceField(unwrappedPropertyDescriptor.resolveFakeOverride().original), + context.symbolTable.descriptorExtension.referenceField(unwrappedPropertyDescriptor.resolveFakeOverride().original), unwrappedPropertyDescriptor, propertyIrType, propertyReceiver, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt index 7fd5ca9e11b..f5ae4730670 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt @@ -105,7 +105,7 @@ internal class BodyGenerator( val parameterValue = VariableLValue( context, ktDestructuringDeclaration.startOffsetSkippingComments, ktDestructuringDeclaration.endOffset, - context.symbolTable.referenceValue(valueParameter), + context.symbolTable.descriptorExtension.referenceValue(valueParameter), valueParameter.type.toIrType(), IrStatementOrigin.DESTRUCTURING_DECLARATION ) @@ -216,7 +216,7 @@ internal class BodyGenerator( irBlockBody.statements.add( IrInstanceInitializerCallImpl( ktClassOrObject.pureStartOffset, ktClassOrObject.pureEndOffset, - context.symbolTable.referenceClass(classDescriptor), + context.symbolTable.descriptorExtension.referenceClass(classDescriptor), context.irBuiltIns.unitType ) ) @@ -233,7 +233,7 @@ internal class BodyGenerator( irBlockBody.statements.add( IrInstanceInitializerCallImpl( ktConstructor.startOffsetSkippingComments, ktConstructor.endOffset, - context.symbolTable.referenceClass(classDescriptor), + context.symbolTable.descriptorExtension.referenceClass(classDescriptor), context.irBuiltIns.unitType ) ) @@ -300,7 +300,7 @@ internal class BodyGenerator( IrDelegatingConstructorCallImpl.fromSymbolDescriptor( ktElement.pureStartOffset, ktElement.pureEndOffset, context.irBuiltIns.unitType, - context.symbolTable.referenceConstructor(anyConstructor) + context.symbolTable.descriptorExtension.referenceConstructor(anyConstructor) ) ) } @@ -311,7 +311,7 @@ internal class BodyGenerator( IrEnumConstructorCallImpl.fromSymbolDescriptor( ktElement.startOffsetSkippingComments, ktElement.endOffset, context.irBuiltIns.unitType, - context.symbolTable.referenceConstructor(enumConstructor), + context.symbolTable.descriptorExtension.referenceConstructor(enumConstructor), 1 // kotlin.Enum has a single type parameter ).apply { putTypeArgument(0, classDescriptor.defaultType.toIrType()) @@ -329,7 +329,7 @@ internal class BodyGenerator( return IrEnumConstructorCallImpl.fromSymbolDescriptor( ktEnumEntry.startOffsetSkippingComments, ktEnumEntry.endOffset, context.irBuiltIns.unitType, - context.symbolTable.referenceConstructor(enumEntryConstructor), + context.symbolTable.descriptorExtension.referenceConstructor(enumEntryConstructor), 0 // enums can't be generic ) } @@ -379,7 +379,7 @@ internal class BodyGenerator( UNDEFINED_OFFSET, UNDEFINED_OFFSET, thisAsReceiverParameter.type.toIrType(), - context.symbolTable.referenceValue(thisAsReceiverParameter) + context.symbolTable.descriptorExtension.referenceValue(thisAsReceiverParameter) ), IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irValueParameter.type, irValueParameter.symbol), context.irBuiltIns.unitType diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt index 33e45b1f2b8..fabe95663dc 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt @@ -114,7 +114,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement } is SyntheticFieldDescriptor -> { val receiver = statementGenerator.generateBackingFieldReceiver(startOffset, endOffset, resolvedCall, descriptor) - val field = statementGenerator.context.symbolTable.referenceField(descriptor.propertyDescriptor) + val field = statementGenerator.context.symbolTable.descriptorExtension.referenceField(descriptor.propertyDescriptor) val fieldType = descriptor.propertyDescriptor.type.toIrType() IrGetFieldImpl(startOffset, endOffset, field, fieldType, receiver?.load()) } @@ -135,7 +135,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement ) = if (descriptor is LocalVariableDescriptor && descriptor.isDelegated) { val getterDescriptor = descriptor.getter!! - val getterSymbol = context.symbolTable.referenceSimpleFunction(getterDescriptor.original) + val getterSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(getterDescriptor.original) IrCallImpl.fromSymbolDescriptor( startOffset, endOffset, descriptor.type.toIrType(), getterSymbol, origin = origin ?: IrStatementOrigin.GET_LOCAL_PROPERTY ).apply { @@ -144,7 +144,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement } } else { val getValue = - IrGetValueImpl(startOffset, endOffset, descriptor.type.toIrType(), context.symbolTable.referenceValue(descriptor), origin) + IrGetValueImpl(startOffset, endOffset, descriptor.type.toIrType(), context.symbolTable.descriptorExtension.referenceValue(descriptor), origin) if (irType != null) { IrTypeOperatorCallImpl(startOffset, endOffset, irType, IrTypeOperator.IMPLICIT_CAST, irType, getValue) } else { @@ -156,7 +156,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement call.callReceiver.call { dispatchReceiver, extensionReceiver, contextReceivers -> val descriptor = call.descriptor as? ClassConstructorDescriptor ?: throw AssertionError("Class constructor expected: ${call.descriptor}") - val constructorSymbol = context.symbolTable.referenceConstructor(descriptor.original) + val constructorSymbol = context.symbolTable.descriptorExtension.referenceConstructor(descriptor.original) val irCall = IrDelegatingConstructorCallImpl.fromSymbolDescriptor( startOffset, endOffset, context.irBuiltIns.unitType, @@ -182,7 +182,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement if (extensionReceiver != null) throw AssertionError("Extension receiver should be null: $extensionReceiver") if (contextReceivers.isNotEmpty()) throw AssertionError("Context receivers should be empty: $contextReceivers") val descriptor = constructorDescriptor.original - val constructorSymbol = context.symbolTable.referenceConstructor(descriptor) + val constructorSymbol = context.symbolTable.descriptorExtension.referenceConstructor(descriptor) val returnType = constructorDescriptor.returnType.toIrType() val irCall = IrEnumConstructorCallImpl( startOffset, endOffset, returnType, constructorSymbol, descriptor.typeParametersCount, descriptor.valueParameters.size @@ -204,10 +204,10 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement return if (getMethodDescriptor == null) { val superQualifierSymbol = (call.superQualifier ?: descriptor.containingDeclaration as? ClassDescriptor)?.let { if (it is ScriptDescriptor) null // otherwise it creates a reference to script as class; TODO: check if correct - else context.symbolTable.referenceClass(it) + else context.symbolTable.descriptorExtension.referenceClass(it) } val fieldSymbol = - context.symbolTable.referenceField(context.extensions.remapDebuggerFieldPropertyDescriptor(descriptor.resolveFakeOverride().original)) + context.symbolTable.descriptorExtension.referenceField(context.extensions.remapDebuggerFieldPropertyDescriptor(descriptor.resolveFakeOverride().original)) call.callReceiver.call { dispatchReceiverValue, extensionReceiverValue, _ -> IrGetFieldImpl( startOffset, endOffset, @@ -219,7 +219,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement ).also { context.callToSubstitutedDescriptorMap[it] = descriptor } } } else { - val superQualifierSymbol = call.superQualifier?.let { context.symbolTable.referenceClass(it) } + val superQualifierSymbol = call.superQualifier?.let { context.symbolTable.descriptorExtension.referenceClass(it) } call.callReceiver.adjustForCallee(getMethodDescriptor) .call { dispatchReceiverValue, extensionReceiverValue, contextReceiverValues -> if (descriptor.isDynamic()) { @@ -232,7 +232,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement dispatchReceiver ) } else { - val getterSymbol = context.symbolTable.referenceSimpleFunction(getMethodDescriptor.original) + val getterSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(getMethodDescriptor.original) IrCallImpl( startOffset, endOffset, irType, @@ -287,7 +287,7 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement ): IrExpression = call.callReceiver.call { dispatchReceiverValue, extensionReceiverValue, contextReceiverValues -> val irType = constructorDescriptor.returnType.toIrType() - val originalSymbol = context.symbolTable.referenceConstructor(constructorDescriptor.original) + val originalSymbol = context.symbolTable.descriptorExtension.referenceConstructor(constructorDescriptor.original) IrConstructorCallImpl.fromSymbolDescriptor( startOffset, endOffset, @@ -315,13 +315,13 @@ internal class CallGenerator(statementGenerator: StatementGenerator) : Statement if (functionDescriptor.isDynamic()) { generateDynamicFunctionCall(startOffset, endOffset, functionDescriptor, call, dispatchReceiverValue, extensionReceiverValue) } else { - val originalSymbol = context.symbolTable.referenceSimpleFunction(functionDescriptor.original) + val originalSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(functionDescriptor.original) IrCallImpl.fromSymbolDescriptor( startOffset, endOffset, functionDescriptor.returnType!!.toIrType(), originalSymbol, origin = origin, - superQualifierSymbol = call.superQualifier?.let { context.symbolTable.referenceClass(it) } + superQualifierSymbol = call.superQualifier?.let { context.symbolTable.descriptorExtension.referenceClass(it) } ).run { context.callToSubstitutedDescriptorMap[this] = functionDescriptor putTypeArguments(call.typeArguments) { it.toIrType() } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt index 318876bd462..dc201d6d3df 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl import org.jetbrains.kotlin.ir.expressions.typeParametersCount +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.util.* @@ -68,7 +69,7 @@ internal class ClassGenerator( val visibility = visibility_ ?: classDescriptor.visibility val modality = getEffectiveModality(ktClassOrObject, classDescriptor) - return context.symbolTable.declareClass(classDescriptor) { + return context.symbolTable.descriptorExtension.declareClass(classDescriptor) { it: IrClassSymbol -> context.irFactory.createIrClassFromDescriptor( startOffset, endOffset, IrDeclarationOrigin.DEFINED, it, classDescriptor, context.symbolTable.nameProvider.nameForDeclaration(classDescriptor), visibility, modality @@ -123,7 +124,7 @@ internal class ClassGenerator( generateAdditionalMembersForEnumClass(irClass) } - irClass.sealedSubclasses = classDescriptor.sealedSubclasses.map { context.symbolTable.referenceClass(it) } + irClass.sealedSubclasses = classDescriptor.sealedSubclasses.map { context.symbolTable.descriptorExtension.referenceClass(it) } } } @@ -225,7 +226,7 @@ internal class ClassGenerator( } else { null } - context.symbolTable.declareField( + context.symbolTable.descriptorExtension.declareField( ktDelegateExpression.startOffsetSkippingComments, ktDelegateExpression.endOffset, IrDeclarationOrigin.DELEGATE, delegateDescriptor, delegateDescriptor.type.toIrType(), @@ -277,10 +278,12 @@ internal class ClassGenerator( val startOffset = irDelegate.startOffset val endOffset = irDelegate.endOffset - val irProperty = context.symbolTable.declareProperty( - startOffset, endOffset, IrDeclarationOrigin.DELEGATED_MEMBER, - delegatedDescriptor - ) + val irProperty = + context.symbolTable.descriptorExtension.declareProperty( + startOffset, endOffset, IrDeclarationOrigin.DELEGATED_MEMBER, + delegatedDescriptor, + delegatedDescriptor.isDelegated + ) irProperty.getter = generateDelegatedFunction(irDelegate, delegatedDescriptor.getter!!, delegateToDescriptor.getter!!) @@ -298,7 +301,7 @@ internal class ClassGenerator( private fun IrProperty.generateOverrides(propertyDescriptor: PropertyDescriptor) { overriddenSymbols = propertyDescriptor.overriddenDescriptors.map { overriddenPropertyDescriptor -> - context.symbolTable.referenceProperty(overriddenPropertyDescriptor.original) + context.symbolTable.descriptorExtension.referenceProperty(overriddenPropertyDescriptor.original) } } @@ -345,7 +348,7 @@ internal class ClassGenerator( val substitutedDelegateTo = substituteDelegateToDescriptor(delegatedDescriptor, delegateToDescriptor) val returnType = substitutedDelegateTo.returnType!! - val delegateToSymbol = context.symbolTable.referenceSimpleFunction(delegateToDescriptor.original) + val delegateToSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(delegateToDescriptor.original) val irCall = IrCallImpl.fromSymbolDescriptor( startOffset, endOffset, @@ -485,7 +488,7 @@ internal class ClassGenerator( ) { ktClassOrObject.primaryConstructor?.let { ktPrimaryConstructor -> irPrimaryConstructor.valueParameters.forEach { - context.symbolTable.introduceValueParameter(it) + context.symbolTable.descriptorExtension.introduceValueParameter(it) } ktPrimaryConstructor.valueParameters.forEachIndexed { i, ktParameter -> @@ -523,10 +526,10 @@ internal class ClassGenerator( // TODO this is a hack, pass declaration parent through generator chain instead val enumClassDescriptor = enumEntryDescriptor.containingDeclaration as ClassDescriptor - val enumClassSymbol = context.symbolTable.referenceClass(enumClassDescriptor) + val enumClassSymbol = context.symbolTable.descriptorExtension.referenceClass(enumClassDescriptor) val irEnumClass = enumClassSymbol.owner - return context.symbolTable.declareEnumEntry( + return context.symbolTable.descriptorExtension.declareEnumEntry( ktEnumEntry.startOffsetSkippingComments, ktEnumEntry.endOffset, IrDeclarationOrigin.DEFINED, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt index 87aeb2779e0..84600e629a3 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt @@ -161,7 +161,7 @@ internal class DataClassMembersGenerator( val dataClassConstructor = classDescriptor.unsubstitutedPrimaryConstructor ?: throw AssertionError("Data class should have a primary constructor: $classDescriptor") - val constructorSymbol = context.symbolTable.referenceConstructor(dataClassConstructor) + val constructorSymbol = context.symbolTable.descriptorExtension.referenceConstructor(dataClassConstructor) irDataClassMembersGenerator.generateCopyFunction(function, constructorSymbol) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt index b58c43a15d9..566bd2906df 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.endOffset @@ -109,7 +110,7 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { private fun generateTypeAliasDeclaration(ktTypeAlias: KtTypeAlias): IrTypeAlias = with(getOrFail(BindingContext.TYPE_ALIAS, ktTypeAlias)) { - context.symbolTable.declareTypeAlias(this) { symbol -> + context.symbolTable.descriptorExtension.declareTypeAlias(this) { symbol: IrTypeAliasSymbol -> context.irFactory.createTypeAlias( startOffset = ktTypeAlias.startOffsetSkippingComments, endOffset = ktTypeAlias.endOffset, @@ -130,7 +131,7 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { from: List ) { generateTypeParameterDeclarations(irTypeParametersOwner, from) { startOffset, endOffset, typeParameterDescriptor -> - context.symbolTable.declareGlobalTypeParameter( + context.symbolTable.descriptorExtension.declareGlobalTypeParameter( startOffset, endOffset, IrDeclarationOrigin.DEFINED, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt index 53c10a79948..83997fbc370 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt @@ -60,7 +60,7 @@ internal class DelegatedPropertyGenerator( val kPropertyType = getKPropertyTypeForDelegatedProperty(propertyDescriptor) - val irProperty = context.symbolTable.declareProperty( + val irProperty = context.symbolTable.descriptorExtension.declareProperty( ktProperty.startOffsetSkippingComments, ktProperty.endOffset, IrDeclarationOrigin.DEFINED, propertyDescriptor, isDelegated = true @@ -139,7 +139,7 @@ internal class DelegatedPropertyGenerator( val endOffset = ktDelegate.endOffset val origin = IrDeclarationOrigin.PROPERTY_DELEGATE val type = delegateDescriptor.type.toIrType() - context.symbolTable.declareField( + context.symbolTable.descriptorExtension.declareField( startOffset, endOffset, origin, delegateDescriptor, type ) { context.irFactory.createField( @@ -221,7 +221,7 @@ internal class DelegatedPropertyGenerator( IrGetValueImpl( ktDelegate.startOffsetSkippingComments, ktDelegate.endOffset, thisAsReceiverParameter.type.toIrType(), - context.symbolTable.referenceValueParameter(thisAsReceiverParameter) + context.symbolTable.descriptorExtension.referenceValueParameter(thisAsReceiverParameter) ) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/EnumClassMembersGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/EnumClassMembersGenerator.kt index c56c1c24bab..c7b2add8f10 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/EnumClassMembersGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/EnumClassMembersGenerator.kt @@ -87,10 +87,11 @@ class EnumClassMembersGenerator(declarationGenerator: DeclarationGenerator) : De } ?: return irClass.addMember( - context.symbolTable.declareProperty( + context.symbolTable.descriptorExtension.declareProperty( SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.ENUM_CLASS_SPECIAL_MEMBER, - entriesProperty + entriesProperty, + entriesProperty.isDelegated ).also { irProperty -> irProperty.getter = context.symbolTable.declareSimpleFunctionWithOverrides( SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ExpectDependencyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ExpectDependencyGenerator.kt index 336b73df6a3..a7247658e5f 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ExpectDependencyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ExpectDependencyGenerator.kt @@ -42,10 +42,10 @@ private class ExpectDependencyGenerator( override fun visitClass(declaration: IrClass) { declaration.forEachExpect { expectDescriptor -> - val symbol = symbolTable.referenceClass(expectDescriptor as ClassDescriptor) + val symbol = symbolTable.descriptorExtension.referenceClass(expectDescriptor as ClassDescriptor) expectDescriptorToSymbol[expectDescriptor] = symbol expectDescriptor.constructors.forEach { - expectDescriptorToSymbol[it] = symbolTable.referenceConstructor(it as ClassConstructorDescriptor) + expectDescriptorToSymbol[it] = symbolTable.descriptorExtension.referenceConstructor(it as ClassConstructorDescriptor) } } super.visitDeclaration(declaration) @@ -53,7 +53,7 @@ private class ExpectDependencyGenerator( override fun visitSimpleFunction(declaration: IrSimpleFunction) { declaration.forEachExpect { - val symbol = symbolTable.referenceSimpleFunction(it as FunctionDescriptor) + val symbol = symbolTable.descriptorExtension.referenceSimpleFunction(it as FunctionDescriptor) expectDescriptorToSymbol[it] = symbol } super.visitDeclaration(declaration) @@ -61,7 +61,7 @@ private class ExpectDependencyGenerator( override fun visitConstructor(declaration: IrConstructor) { declaration.forEachExpect { - val symbol = symbolTable.referenceConstructor(it as ClassConstructorDescriptor) + val symbol = symbolTable.descriptorExtension.referenceConstructor(it as ClassConstructorDescriptor) expectDescriptorToSymbol[it] = symbol } @@ -70,7 +70,7 @@ private class ExpectDependencyGenerator( override fun visitProperty(declaration: IrProperty) { declaration.forEachExpect { - val symbol = symbolTable.referenceProperty(it as PropertyDescriptor) + val symbol = symbolTable.descriptorExtension.referenceProperty(it as PropertyDescriptor) expectDescriptorToSymbol[it] = symbol } super.visitDeclaration(declaration) @@ -78,7 +78,7 @@ private class ExpectDependencyGenerator( override fun visitEnumEntry(declaration: IrEnumEntry) { declaration.forEachExpect { - val symbol = symbolTable.referenceEnumEntry(it as ClassDescriptor) + val symbol = symbolTable.descriptorExtension.referenceEnumEntry(it as ClassDescriptor) expectDescriptorToSymbol[it] = symbol } @@ -88,7 +88,7 @@ private class ExpectDependencyGenerator( override fun visitTypeAlias(declaration: IrTypeAlias) { declaration.forEachExpect { val symbol = when (it) { - is ClassDescriptor -> symbolTable.referenceClass(it) + is ClassDescriptor -> symbolTable.descriptorExtension.referenceClass(it) else -> error("Unexpected expect for actual type alias: $it") } expectDescriptorToSymbol[it] = symbol diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt index f983307bb4b..0bbec1f5a90 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.ir.expressions.IrBody import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.expressions.impl.* +import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol import org.jetbrains.kotlin.ir.types.impl.IrUninitializedType import org.jetbrains.kotlin.ir.util.declareSimpleFunctionWithOverrides import org.jetbrains.kotlin.name.Name @@ -179,7 +180,7 @@ internal class FunctionGenerator(declarationGenerator: DeclarationGenerator) : D irAccessor.symbol, IrGetFieldImpl( startOffset, endOffset, - context.symbolTable.referenceField(property), + context.symbolTable.descriptorExtension.referenceField(property), property.type.toIrType(), receiver ) @@ -204,7 +205,7 @@ internal class FunctionGenerator(declarationGenerator: DeclarationGenerator) : D irBody.statements.add( IrSetFieldImpl( startOffset, endOffset, - context.symbolTable.referenceField(property), + context.symbolTable.descriptorExtension.referenceField(property), receiver, IrGetValueImpl(startOffset, endOffset, irValueParameter.type, irValueParameter.symbol), context.irBuiltIns.unitType @@ -223,7 +224,7 @@ internal class FunctionGenerator(declarationGenerator: DeclarationGenerator) : D IrGetValueImpl( irAccessor.startOffset, irAccessor.endOffset, thisAsReceiverParameter.type.toIrType(), - context.symbolTable.referenceValue(thisAsReceiverParameter) + context.symbolTable.descriptorExtension.referenceValue(thisAsReceiverParameter) ) } else -> null @@ -281,7 +282,7 @@ internal class FunctionGenerator(declarationGenerator: DeclarationGenerator) : D val startOffset = ktConstructorElement.getStartOffsetOfConstructorDeclarationKeywordOrNull() ?: ktConstructorElement.pureStartOffset val endOffset = ktConstructorElement.pureEndOffset val origin = IrDeclarationOrigin.DEFINED - return context.symbolTable.declareConstructor(constructorDescriptor) { + return context.symbolTable.descriptorExtension.declareConstructor(constructorDescriptor) { with(constructorDescriptor) { context.irFactory.createConstructor( startOffset = startOffset, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt index 14133ddff17..f6965c233ba 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt @@ -50,7 +50,7 @@ internal class LocalClassGenerator(statementGenerator: StatementGenerator) : Sta irBlock.statements.add( IrConstructorCallImpl.fromSymbolDescriptor( startOffset, endOffset, objectLiteralType, - context.symbolTable.referenceConstructor(objectConstructor), + context.symbolTable.descriptorExtension.referenceConstructor(objectConstructor), IrStatementOrigin.OBJECT_LITERAL ) ) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt index fb1f386cec0..87924f64b01 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt @@ -192,7 +192,7 @@ internal class LoopExpressionGenerator(statementGenerator: StatementGenerator) : val irLoopParameter = if (ktLoopParameter != null && ktLoopDestructuringDeclaration == null) { val loopParameter = getOrFail(BindingContext.VALUE_PARAMETER, ktLoopParameter) - context.symbolTable.declareVariable( + context.symbolTable.descriptorExtension.declareVariable( ktLoopParameter.startOffsetSkippingComments, ktLoopParameter.endOffset, IrDeclarationOrigin.FOR_LOOP_VARIABLE, loopParameter, loopParameter.type.toIrType(), irNextCall diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt index 9ab45ca2b82..17903d0563b 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt @@ -123,7 +123,7 @@ open class ModuleGenerator( gen.visitClassDescriptor(ErrorUtils.errorClass, fakeFile) gen.visitConstructorDescriptor( ErrorUtils.errorClass.unsubstitutedPrimaryConstructor!!, - context.symbolTable.referenceClass(ErrorUtils.errorClass).owner, + context.symbolTable.descriptorExtension.referenceClass(ErrorUtils.errorClass).owner, ) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt index 72f1d005d65..a3f7026528f 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt @@ -416,7 +416,7 @@ internal class OperatorExpressionGenerator(statementGenerator: StatementGenerato functionDescriptor: FunctionDescriptor, receiver: IrExpression ): IrExpression { - val originalSymbol = context.symbolTable.referenceSimpleFunction(functionDescriptor.original) + val originalSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(functionDescriptor.original) return IrCallImpl.fromSymbolDescriptor( startOffset, endOffset, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt index e22f35011f2..11c0e383455 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt @@ -48,7 +48,7 @@ internal class PropertyGenerator(declarationGenerator: DeclarationGenerator) : D fun generateDestructuringDeclarationEntryAsPropertyDeclaration(ktEntry: KtDestructuringDeclarationEntry): IrProperty { val propertyDescriptor = getPropertyDescriptor(ktEntry) - return context.symbolTable.declareProperty( + return context.symbolTable.descriptorExtension.declareProperty( ktEntry.startOffsetSkippingComments, ktEntry.endOffset, IrDeclarationOrigin.DEFINED, propertyDescriptor, @@ -99,7 +99,7 @@ internal class PropertyGenerator(declarationGenerator: DeclarationGenerator) : D generateSyntheticAccessors: Boolean, generateInitializer: (IrField) -> IrExpressionBody? ): IrProperty { - return context.symbolTable.declareProperty( + return context.symbolTable.descriptorExtension.declareProperty( ktDeclarationContainer.startOffsetSkippingComments, ktDeclarationContainer.endOffset, IrDeclarationOrigin.DEFINED, propertyDescriptor, @@ -181,7 +181,7 @@ internal class PropertyGenerator(declarationGenerator: DeclarationGenerator) : D hasBackingField(bindingContext) || context.extensions.isPropertyWithPlatformField(this) private fun generateSimpleProperty(ktProperty: KtVariableDeclaration, propertyDescriptor: PropertyDescriptor): IrProperty = - context.symbolTable.declareProperty( + context.symbolTable.descriptorExtension.declareProperty( ktProperty.startOffsetSkippingComments, ktProperty.endOffset, IrDeclarationOrigin.DEFINED, propertyDescriptor, @@ -228,7 +228,7 @@ internal class PropertyGenerator(declarationGenerator: DeclarationGenerator) : D val startOffset = ktElement.pureStartOffsetOrUndefined val endOffset = ktElement.pureEndOffsetOrUndefined - return context.symbolTable.declareProperty(startOffset, endOffset, IrDeclarationOrigin.FAKE_OVERRIDE, propertyDescriptor).apply { + return context.symbolTable.descriptorExtension.declareProperty(startOffset, endOffset, IrDeclarationOrigin.FAKE_OVERRIDE, propertyDescriptor, propertyDescriptor.isDelegated).apply { this.getter = propertyDescriptor.getter?.let { FunctionGenerator(declarationGenerator).generateFakeOverrideFunction(it, ktElement) } @@ -243,7 +243,7 @@ internal class PropertyGenerator(declarationGenerator: DeclarationGenerator) : D private fun IrProperty.generateOverrides(propertyDescriptor: PropertyDescriptor) { overriddenSymbols = propertyDescriptor.overriddenDescriptors.map { overriddenPropertyDescriptor -> - context.symbolTable.referenceProperty(overriddenPropertyDescriptor.original) + context.symbolTable.descriptorExtension.referenceProperty(overriddenPropertyDescriptor.original) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt index 0bc1417059c..bfed31eaef4 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt @@ -546,12 +546,12 @@ internal class ReflectionReferencesGenerator(statementGenerator: StatementGenera variableDescriptor.getter ?: throw AssertionError("Local delegated property should have a getter: $variableDescriptor") val setterDescriptor = variableDescriptor.setter - val getterSymbol = context.symbolTable.referenceSimpleFunction(getterDescriptor) - val setterSymbol = setterDescriptor?.let { context.symbolTable.referenceSimpleFunction(it) } + val getterSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(getterDescriptor) + val setterSymbol = setterDescriptor?.let { context.symbolTable.descriptorExtension.referenceSimpleFunction(it) } return IrLocalDelegatedPropertyReferenceImpl( startOffset, endOffset, type.toIrType(), - context.symbolTable.referenceLocalDelegatedProperty(variableDescriptor), + context.symbolTable.descriptorExtension.referenceLocalDelegatedProperty(variableDescriptor), irDelegateSymbol, getterSymbol, setterSymbol, origin ).apply { @@ -566,16 +566,16 @@ internal class ReflectionReferencesGenerator(statementGenerator: StatementGenera ) private fun resolvePropertySymbol(descriptor: PropertyDescriptor, mutable: Boolean): DelegatedPropertySymbols { - val symbol = context.symbolTable.referenceProperty(descriptor) + val symbol = context.symbolTable.descriptorExtension.referenceProperty(descriptor) val syntheticJavaProperty = context.extensions.unwrapSyntheticJavaProperty(descriptor) if (syntheticJavaProperty != null) { val (getMethod, setMethod) = syntheticJavaProperty // This is the special case of synthetic java properties when requested property doesn't even exist but IR design // requires its symbol to be bound so let do that // see `irText/declarations/provideDelegate/javaDelegate.kt` and KT-45297 - val getterSymbol = context.symbolTable.referenceSimpleFunction(getMethod) + val getterSymbol = context.symbolTable.descriptorExtension.referenceSimpleFunction(getMethod) val setterSymbol = if (mutable) setMethod?.let { - context.symbolTable.referenceSimpleFunction(it) + context.symbolTable.descriptorExtension.referenceSimpleFunction(it) } else null if (!symbol.isBound) { val offset = UNDEFINED_OFFSET @@ -601,8 +601,8 @@ internal class ReflectionReferencesGenerator(statementGenerator: StatementGenera } return DelegatedPropertySymbols(symbol, getterSymbol, setterSymbol) } else { - val getterSymbol = descriptor.getter?.let { context.symbolTable.referenceSimpleFunction(it) } - val setterSymbol = if (mutable) descriptor.setter?.let { context.symbolTable.referenceSimpleFunction(it) } else null + val getterSymbol = descriptor.getter?.let { context.symbolTable.descriptorExtension.referenceSimpleFunction(it) } + val setterSymbol = if (mutable) descriptor.setter?.let { context.symbolTable.descriptorExtension.referenceSimpleFunction(it) } else null return DelegatedPropertySymbols(symbol, getterSymbol, setterSymbol) } } @@ -638,7 +638,7 @@ internal class ReflectionReferencesGenerator(statementGenerator: StatementGenera when { originalProperty.isDelegated -> null originalProperty.getter != null -> null - else -> context.symbolTable.referenceField(originalProperty) + else -> context.symbolTable.descriptorExtension.referenceField(originalProperty) } private fun generateFunctionReference( diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ScriptGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ScriptGenerator.kt index 0ff8f97c89d..29bda7fd37a 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ScriptGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ScriptGenerator.kt @@ -47,7 +47,7 @@ internal class ScriptGenerator(declarationGenerator: DeclarationGenerator) : Dec fun generateScriptDeclaration(ktScript: KtScript): IrDeclaration? { val descriptor = getOrFail(BindingContext.DECLARATION_TO_DESCRIPTOR, ktScript) as ScriptDescriptor - return context.symbolTable.declareScript(ktScript.startOffsetSkippingComments, ktScript.endOffset, descriptor).buildWithScope { irScript -> + return context.symbolTable.descriptorExtension.declareScript(ktScript.startOffsetSkippingComments, ktScript.endOffset, descriptor).buildWithScope { irScript -> irScript.metadata = DescriptorMetadataSource.Script(descriptor) @@ -56,7 +56,7 @@ internal class ScriptGenerator(declarationGenerator: DeclarationGenerator) : Dec fun makeParameter(descriptor: ParameterDescriptor, origin: IrDeclarationOrigin, index: Int = -1): IrValueParameter { val type = descriptor.type.toIrType() val varargElementType = descriptor.varargElementType?.toIrType() - return context.symbolTable.declareValueParameter( + return context.symbolTable.descriptorExtension.declareValueParameter( UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor, @@ -94,7 +94,7 @@ internal class ScriptGenerator(declarationGenerator: DeclarationGenerator) : Dec it.owner != irScript && it.descriptor !in importedScripts } irScript.earlierScripts?.forEach { - context.symbolTable.introduceValueParameter(it.owner.thisReceiver!!) + context.symbolTable.descriptorExtension.introduceValueParameter(it.owner.thisReceiver!!) } fun createValueParameter(valueParameterDescriptor: ValueParameterDescriptor): IrValueParameter { @@ -138,7 +138,7 @@ internal class ScriptGenerator(declarationGenerator: DeclarationGenerator) : Dec // TODO: initializer // TODO: do not keep direct links val type = providedProperty.type.toIrType() - val valueParameter = context.symbolTable.declareValueParameter( + val valueParameter = context.symbolTable.descriptorExtension.declareValueParameter( UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.SCRIPT_PROVIDED_PROPERTY, parameter, type ) { symbol -> @@ -186,7 +186,7 @@ internal class ScriptGenerator(declarationGenerator: DeclarationGenerator) : Dec isInline = isInline, isExpect = isExpect, returnType = returnType, - symbol = context.symbolTable.referenceConstructor(descriptor.unsubstitutedPrimaryConstructor), + symbol = context.symbolTable.descriptorExtension.referenceConstructor(descriptor.unsubstitutedPrimaryConstructor), isPrimary = isPrimary, isExternal = isExternal, containerSource = containerSource diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt index 42574c2377d..785335687fe 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt @@ -39,7 +39,7 @@ internal class StandaloneDeclarationGenerator(private val context: GeneratorCont from: List ) { generateTypeParameterDeclarations(irTypeParametersOwner, from) { startOffset, endOffset, typeParameterDescriptor -> - symbolTable.declareGlobalTypeParameter(startOffset, endOffset, IrDeclarationOrigin.DEFINED, typeParameterDescriptor) + symbolTable.descriptorExtension.declareGlobalTypeParameter(startOffset, endOffset, IrDeclarationOrigin.DEFINED, typeParameterDescriptor) } } @@ -200,7 +200,7 @@ internal class StandaloneDeclarationGenerator(private val context: GeneratorCont } protected fun generateOverridenSymbols(irFunction: IrSimpleFunction, overridens: Collection) { - irFunction.overriddenSymbols = overridens.map { symbolTable.referenceSimpleFunction(it.original) } + irFunction.overriddenSymbols = overridens.map { symbolTable.descriptorExtension.referenceSimpleFunction(it.original) } } fun generateSimpleFunction( diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt index fa217d0cb03..6c632a18798 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt @@ -119,7 +119,7 @@ internal class StatementGenerator( } else { property } - return context.symbolTable.declareVariable( + return context.symbolTable.descriptorExtension.declareVariable( sourceElement.startOffsetSkippingComments, sourceElement.endOffset, IrDeclarationOrigin.DEFINED, variableDescriptor, variableDescriptor.type.toIrType(), @@ -207,7 +207,7 @@ internal class StatementGenerator( } else { ktEntry } - val irComponentVar = context.symbolTable.declareVariable( + val irComponentVar = context.symbolTable.descriptorExtension.declareVariable( componentVarOffsetSource.startOffsetSkippingComments, componentVarOffsetSource.endOffset, IrDeclarationOrigin.DEFINED, componentVariable, componentVariable.type.toIrType(), irComponentCall @@ -447,13 +447,13 @@ internal class StatementGenerator( IrGetObjectValueImpl( startOffset, endOffset, thisType, - context.symbolTable.referenceClass(classDescriptor) + context.symbolTable.descriptorExtension.referenceClass(classDescriptor) ) } else { IrGetValueImpl( startOffset, endOffset, thisType, - context.symbolTable.referenceValueParameter(thisAsReceiverParameter) + context.symbolTable.descriptorExtension.referenceValueParameter(thisAsReceiverParameter) ) } } @@ -479,7 +479,7 @@ internal class StatementGenerator( IrGetValueImpl( startOffset, endOffset, receiverType, - context.symbolTable.referenceValueParameter(receiverParameter) + context.symbolTable.descriptorExtension.referenceValueParameter(receiverParameter) ) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDeclarationsGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDeclarationsGenerator.kt index 859701bd3d8..7b6817c8e47 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDeclarationsGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDeclarationsGenerator.kt @@ -59,7 +59,7 @@ internal class SyntheticDeclarationsGenerator(context: GeneratorContext) : Decla if (descriptor.visibility != DescriptorVisibilities.INVISIBLE_FAKE && descriptor.kind != CallableMemberDescriptor.Kind.DELEGATION // Skip mismatching delegates, see KT-46120 ) { - symbolTable.declareSimpleFunctionIfNotExists(descriptor) { + symbolTable.descriptorExtension.declareSimpleFunctionIfNotExists(descriptor) { createFunctionStub(descriptor, it).insertDeclaration(data) } } @@ -84,11 +84,11 @@ internal class SyntheticDeclarationsGenerator(context: GeneratorContext) : Decla require(data != null) if (DescriptorUtils.isEnumEntry(descriptor)) { - symbolTable.declareEnumEntryIfNotExists(descriptor) { + symbolTable.descriptorExtension.declareEnumEntryIfNotExists(descriptor) { createEnumEntruStub(descriptor, it).insertDeclaration(data) } } else { - symbolTable.declareClassIfNotExists(descriptor) { + symbolTable.descriptorExtension.declareClassIfNotExists(descriptor) { createClassStub(descriptor, it).insertDeclaration(data) } } @@ -101,7 +101,7 @@ internal class SyntheticDeclarationsGenerator(context: GeneratorContext) : Decla override fun visitTypeAliasDescriptor(descriptor: TypeAliasDescriptor, data: IrDeclarationContainer?) { require(data != null) - symbolTable.declareTypeAliasIfNotExists(descriptor) { + symbolTable.descriptorExtension.declareTypeAliasIfNotExists(descriptor) { declareTypeAliasStub(descriptor, it).insertDeclaration(data) } } @@ -117,13 +117,13 @@ internal class SyntheticDeclarationsGenerator(context: GeneratorContext) : Decla override fun visitConstructorDescriptor(constructorDescriptor: ConstructorDescriptor, data: IrDeclarationContainer?) { require(data != null) assert(constructorDescriptor is ClassConstructorDescriptor) - symbolTable.declareConstructorIfNotExists(constructorDescriptor as ClassConstructorDescriptor) { + symbolTable.descriptorExtension.declareConstructorIfNotExists(constructorDescriptor as ClassConstructorDescriptor) { createConstructorStub(constructorDescriptor, it).insertDeclaration(data) } } override fun visitScriptDescriptor(scriptDescriptor: ScriptDescriptor, data: IrDeclarationContainer?) { - assert(symbolTable.referenceScript(scriptDescriptor).isBound) { "Script $scriptDescriptor isn't declared" } + assert(symbolTable.descriptorExtension.referenceScript(scriptDescriptor).isBound) { "Script $scriptDescriptor isn't declared" } } private fun createPropertyStub(descriptor: PropertyDescriptor, symbol: IrPropertySymbol): IrProperty { @@ -132,7 +132,7 @@ internal class SyntheticDeclarationsGenerator(context: GeneratorContext) : Decla private fun declareAccessor(accessorDescriptor: PropertyAccessorDescriptor, property: IrProperty): IrSimpleFunction { // TODO: type parameters - return symbolTable.declareSimpleFunctionIfNotExists(accessorDescriptor) { + return symbolTable.descriptorExtension.declareSimpleFunctionIfNotExists(accessorDescriptor) { createFunctionStub(accessorDescriptor, it).also { acc -> acc.parent = property.parent acc.correspondingPropertySymbol = property.symbol @@ -143,7 +143,7 @@ internal class SyntheticDeclarationsGenerator(context: GeneratorContext) : Decla override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, data: IrDeclarationContainer?) { require(data != null) if (descriptor.visibility != DescriptorVisibilities.INVISIBLE_FAKE) { - symbolTable.declarePropertyIfNotExists(descriptor) { + symbolTable.descriptorExtension.declarePropertyIfNotExists(descriptor) { createPropertyStub(descriptor, it).insertDeclaration(data).also { p -> descriptor.getter?.let { g -> p.getter = declareAccessor(g, p) } descriptor.setter?.let { s -> p.setter = declareAccessor(s, p) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt index c5e4e920008..98ba5600651 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentCompilerSymbolTableDecorator.kt @@ -29,9 +29,9 @@ class FragmentCompilerSymbolTableDecorator( ) : SymbolTable(signatureComposer, irFactory, nameProvider) { override fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol { - val fi = fragmentInfo ?: return super.referenceValueParameter(descriptor) + val fi = fragmentInfo ?: return super.descriptorExtension.referenceValueParameter(descriptor) - if (descriptor !is ReceiverParameterDescriptor) return super.referenceValueParameter(descriptor) + if (descriptor !is ReceiverParameterDescriptor) return super.descriptorExtension.referenceValueParameter(descriptor) val finderPredicate = when (val receiverValue = descriptor.value) { is ExtensionReceiver, is ContextReceiver -> { (targetDescriptor, _): EvaluatorFragmentParameterInfo -> @@ -46,14 +46,14 @@ class FragmentCompilerSymbolTableDecorator( val parameterPosition = fi.parameters.indexOfFirst(finderPredicate) if (parameterPosition > -1) { - return super.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition]) + return super.descriptorExtension.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition]) } - return super.referenceValueParameter(descriptor) + return super.descriptorExtension.referenceValueParameter(descriptor) } - override fun referenceValue(value: ValueDescriptor): IrValueSymbol { - val fi = fragmentInfo ?: return super.referenceValue(value) + fun referenceValue(value: ValueDescriptor): IrValueSymbol { + val fi = fragmentInfo ?: return super.descriptorExtension.referenceValue(value) val finderPredicate = when (value) { is AbstractReceiverParameterDescriptor -> { (targetDescriptor, _): EvaluatorFragmentParameterInfo -> @@ -67,9 +67,9 @@ class FragmentCompilerSymbolTableDecorator( val parameterPosition = fi.parameters.indexOfFirst(finderPredicate) if (parameterPosition > -1) { - return super.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition]) + return super.descriptorExtension.referenceValueParameter(fi.methodDescriptor.valueParameters[parameterPosition]) } - return super.referenceValue(value) + return super.descriptorExtension.referenceValue(value) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentDeclarationGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentDeclarationGenerator.kt index 6fb565d2903..8130b8ad57e 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentDeclarationGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/fragments/FragmentDeclarationGenerator.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorPublicSymbolImpl import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.name.Name @@ -31,7 +32,7 @@ open class FragmentDeclarationGenerator( val startOffset = UNDEFINED_OFFSET val endOffset = UNDEFINED_OFFSET - return context.symbolTable.declareClass(classDescriptor) { + return context.symbolTable.descriptorExtension.declareClass(classDescriptor) { context.irFactory.createIrClassFromDescriptor( startOffset, endOffset, IrDeclarationOrigin.DEFINED, @@ -84,7 +85,7 @@ open class FragmentDeclarationGenerator( return IrDelegatingConstructorCallImpl.fromSymbolDescriptor( UNDEFINED_OFFSET, UNDEFINED_OFFSET, context.irBuiltIns.unitType, - context.symbolTable.referenceConstructor(anyConstructor) + context.symbolTable.descriptorExtension.referenceConstructor(anyConstructor) ) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/preprocessing/SourceDeclarationsPreprocessor.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/preprocessing/SourceDeclarationsPreprocessor.kt index 64a8e59dbb9..1513575be5b 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/preprocessing/SourceDeclarationsPreprocessor.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/preprocessing/SourceDeclarationsPreprocessor.kt @@ -32,7 +32,7 @@ class SourceDeclarationsPreprocessor(private val context: GeneratorContext) { private fun processClassOrObject(ktClassOrObject: KtClassOrObject) { val classDescriptor = ktClassOrObject.findClassDescriptor(context.bindingContext) if (DescriptorUtils.isEnumEntry(classDescriptor)) return - context.symbolTable.referenceClass(classDescriptor) + context.symbolTable.descriptorExtension.referenceClass(classDescriptor) ktClassOrObject.body?.let { ktClassBody -> ktClassBody.declarations.forEach { processDeclaration(it) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt index 5e1e49b5800..af0803d0db3 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt @@ -472,7 +472,7 @@ internal class InsertImplicitCasts( return IrCallImpl( startOffset, endOffset, targetType.toIrType(), - symbolTable.referenceSimpleFunction(coercionFunction), + symbolTable.descriptorExtension.referenceSimpleFunction(coercionFunction), typeArgumentsCount = 0, valueArgumentsCount = 0 ).also { irCall -> irCall.dispatchReceiver = this @@ -494,7 +494,7 @@ internal class InsertImplicitCasts( return IrCallImpl( startOffset, endOffset, targetType.toIrType(), - symbolTable.referenceSimpleFunction(coercionFunction), + symbolTable.descriptorExtension.referenceSimpleFunction(coercionFunction), typeArgumentsCount = 0, valueArgumentsCount = 0 ).also { irCall -> irCall.extensionReceiver = this diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt index be9ddb31e67..e10e011f6d4 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazySymbolTable.kt @@ -23,7 +23,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol { synchronized(lock) { - return originalTable.referenceClass(descriptor).also { + return originalTable.descriptorExtension.referenceClass(descriptor).also { if (!it.isBound) { stubGenerator?.generateClassStub(descriptor) } @@ -33,7 +33,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol { synchronized(lock) { - return originalTable.referenceTypeAlias(descriptor).also { + return originalTable.descriptorExtension.referenceTypeAlias(descriptor).also { if (!it.isBound) { stubGenerator?.generateTypeAliasStub(descriptor) } @@ -43,7 +43,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol { synchronized(lock) { - return originalTable.referenceConstructor(descriptor).also { + return originalTable.descriptorExtension.referenceConstructor(descriptor).also { if (!it.isBound) { stubGenerator?.generateConstructorStub(descriptor) } @@ -53,7 +53,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol { synchronized(lock) { - return originalTable.referenceEnumEntry(descriptor).also { + return originalTable.descriptorExtension.referenceEnumEntry(descriptor).also { if (!it.isBound) { stubGenerator?.generateEnumEntryStub(descriptor) } @@ -63,7 +63,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { synchronized(lock) { - return originalTable.referenceSimpleFunction(descriptor).also { + return originalTable.descriptorExtension.referenceSimpleFunction(descriptor).also { if (!it.isBound) { stubGenerator?.generateFunctionStub(descriptor) } @@ -73,7 +73,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol { synchronized(lock) { - return originalTable.referenceProperty(descriptor).also { + return originalTable.descriptorExtension.referenceProperty(descriptor).also { if (!it.isBound) { stubGenerator?.generatePropertyStub(descriptor) } @@ -83,7 +83,7 @@ class IrLazySymbolTable(private val originalTable: SymbolTable) : ReferenceSymbo fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol { synchronized(lock) { - return originalTable.referenceTypeParameter(classifier).also { + return originalTable.descriptorExtension.referenceTypeParameter(classifier).also { if (!it.isBound) { stubGenerator?.generateOrGetTypeParameterStub(classifier) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt index b159bb863ed..06e9e0c039c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt @@ -24,9 +24,7 @@ import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.lazy.* import org.jetbrains.kotlin.ir.linkage.IrProvider -import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol -import org.jetbrains.kotlin.ir.symbols.IrSymbol -import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol +import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal @@ -80,11 +78,11 @@ abstract class DeclarationStubGenerator( } fun generateOrGetEmptyExternalPackageFragmentStub(descriptor: PackageFragmentDescriptor): IrExternalPackageFragment { - val referenced = symbolTable.referenceExternalPackageFragment(descriptor) + val referenced = symbolTable.descriptorExtension.referenceExternalPackageFragment(descriptor) if (referenced.isBound) { return referenced.owner } - return symbolTable.declareExternalPackageFragment(descriptor) + return symbolTable.descriptorExtension.declareExternalPackageFragment(descriptor) } fun generateOrGetFacadeClass(descriptor: DeclarationDescriptor): IrClass? { @@ -135,7 +133,7 @@ abstract class DeclarationStubGenerator( extensions.computeExternalDeclarationOrigin(descriptor) ?: IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB fun generatePropertyStub(descriptor: PropertyDescriptor): IrProperty { - val referenced = symbolTable.referenceProperty(descriptor) + val referenced = symbolTable.descriptorExtension.referenceProperty(descriptor) if (referenced.isBound) { return referenced.owner } @@ -156,12 +154,12 @@ abstract class DeclarationStubGenerator( } fun generateFieldStub(descriptor: PropertyDescriptor): IrField { - val referenced = symbolTable.referenceField(descriptor) + val referenced = symbolTable.descriptorExtension.referenceField(descriptor) if (referenced.isBound) { return referenced.owner } - return symbolTable.declareField( + return symbolTable.descriptorExtension.declareField( UNDEFINED_OFFSET, UNDEFINED_OFFSET, computeOrigin(descriptor), descriptor.original, descriptor.type.toIrType() ) { IrLazyField( @@ -177,7 +175,7 @@ abstract class DeclarationStubGenerator( } fun generateFunctionStub(descriptor: FunctionDescriptor, createPropertyIfNeeded: Boolean = true): IrSimpleFunction { - val referenced = symbolTable.referenceSimpleFunction(descriptor) + val referenced = symbolTable.descriptorExtension.referenceSimpleFunction(descriptor) if (referenced.isBound) { return referenced.owner } @@ -195,7 +193,7 @@ abstract class DeclarationStubGenerator( if (descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) IrDeclarationOrigin.FAKE_OVERRIDE else computeOrigin(descriptor) - return symbolTable.declareSimpleFunction(descriptor.original) { + return symbolTable.descriptorExtension.declareSimpleFunction(descriptor.original) { IrLazyFunction( UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, descriptor, @@ -209,13 +207,13 @@ abstract class DeclarationStubGenerator( } fun generateConstructorStub(descriptor: ClassConstructorDescriptor): IrConstructor { - val referenced = symbolTable.referenceConstructor(descriptor) + val referenced = symbolTable.descriptorExtension.referenceConstructor(descriptor) if (referenced.isBound) { return referenced.owner } val origin = computeOrigin(descriptor) - return symbolTable.declareConstructor( + return symbolTable.descriptorExtension.declareConstructor( descriptor.original ) { IrLazyConstructor( @@ -252,7 +250,7 @@ abstract class DeclarationStubGenerator( classDescriptor.modality fun generateClassStub(descriptor: ClassDescriptor): IrClass { - val irClassSymbol = symbolTable.referenceClass(descriptor) + val irClassSymbol = symbolTable.descriptorExtension.referenceClass(descriptor) if (irClassSymbol.isBound) { return irClassSymbol.owner } @@ -267,7 +265,7 @@ abstract class DeclarationStubGenerator( val targetDescriptor = if (irClassSymbol.hasDescriptor) irClassSymbol.descriptor else descriptor with(targetDescriptor) { val origin = computeOrigin(this) - return symbolTable.declareClass(this) { + return symbolTable.descriptorExtension.declareClass(this) { IrLazyClass( UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, this, @@ -287,12 +285,12 @@ abstract class DeclarationStubGenerator( } fun generateEnumEntryStub(descriptor: ClassDescriptor): IrEnumEntry { - val referenced = symbolTable.referenceEnumEntry(descriptor) + val referenced = symbolTable.descriptorExtension.referenceEnumEntry(descriptor) if (referenced.isBound) { return referenced.owner } val origin = computeOrigin(descriptor) - return symbolTable.declareEnumEntry(descriptor) { + return symbolTable.descriptorExtension.declareEnumEntry(descriptor) { IrLazyEnumEntryImpl( UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, descriptor, @@ -302,7 +300,7 @@ abstract class DeclarationStubGenerator( } internal fun generateOrGetTypeParameterStub(descriptor: TypeParameterDescriptor): IrTypeParameter { - val referenced = symbolTable.referenceTypeParameter(descriptor) + val referenced = symbolTable.descriptorExtension.referenceTypeParameter(descriptor) if (referenced.isBound) { return referenced.owner } @@ -321,12 +319,12 @@ abstract class DeclarationStubGenerator( } internal fun generateOrGetScopedTypeParameterStub(descriptor: TypeParameterDescriptor): IrTypeParameter { - val referenced = symbolTable.referenceScopedTypeParameter(descriptor) + val referenced = symbolTable.descriptorExtension.referenceScopedTypeParameter(descriptor) if (referenced.isBound) { return referenced.owner } val origin = computeOrigin(descriptor) - return symbolTable.declareScopedTypeParameter(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor) { + return symbolTable.descriptorExtension.declareScopedTypeParameter(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor) { IrLazyTypeParameter( UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, descriptor, @@ -340,12 +338,12 @@ abstract class DeclarationStubGenerator( } fun generateTypeAliasStub(descriptor: TypeAliasDescriptor): IrTypeAlias { - val referenced = symbolTable.referenceTypeAlias(descriptor) + val referenced = symbolTable.descriptorExtension.referenceTypeAlias(descriptor) if (referenced.isBound) { return referenced.owner } val origin = computeOrigin(descriptor) - return symbolTable.declareTypeAlias(descriptor) { + return symbolTable.descriptorExtension.declareTypeAlias(descriptor) { IrLazyTypeAlias( UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, descriptor, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt index ed13219fb47..115468a8249 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt @@ -10,12 +10,8 @@ import org.jetbrains.kotlin.ir.IrLock import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.lazy.IrLazySymbolTable -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.* -import org.jetbrains.kotlin.ir.types.IrType -import org.jetbrains.kotlin.name.Name open class SymbolTable( val signaturer: IdSignatureComposer, @@ -485,366 +481,6 @@ open class SymbolTable( addUnbound(typeAliasSlice) addUnbound(fieldSlice) } - - // ------------------------------------ descriptors ------------------------------------ - - @ObsoleteDescriptorBasedAPI - fun referenceScript(descriptor: ScriptDescriptor): IrScriptSymbol { - return descriptorExtension.referenceScript(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareScript( - startOffset: Int, - endOffset: Int, - descriptor: ScriptDescriptor, - ): IrScript { - return descriptorExtension.declareScript(startOffset, endOffset, descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun referenceExternalPackageFragment(descriptor: PackageFragmentDescriptor): IrExternalPackageFragmentSymbol { - return descriptorExtension.referenceExternalPackageFragment(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareExternalPackageFragment(descriptor: PackageFragmentDescriptor): IrExternalPackageFragment { - return descriptorExtension.declareExternalPackageFragment(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareExternalPackageFragmentIfNotExists(descriptor: PackageFragmentDescriptor): IrExternalPackageFragment { - return descriptorExtension.declareExternalPackageFragmentIfNotExists(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareAnonymousInitializer( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: ClassDescriptor, - ): IrAnonymousInitializer { - return descriptorExtension.declareAnonymousInitializer(startOffset, endOffset, origin, descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareClass( - descriptor: ClassDescriptor, - classFactory: (IrClassSymbol) -> IrClass, - ): IrClass { - return descriptorExtension.declareClass(descriptor, classFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareClassIfNotExists(descriptor: ClassDescriptor, classFactory: (IrClassSymbol) -> IrClass): IrClass { - return descriptorExtension.declareClassIfNotExists(descriptor, classFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareClassFromLinker(descriptor: ClassDescriptor, signature: IdSignature, factory: (IrClassSymbol) -> IrClass): IrClass { - return descriptorExtension.declareClassFromLinker(descriptor, signature, factory) - } - - @ObsoleteDescriptorBasedAPI - fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol { - return descriptorExtension.referenceClass(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareConstructor( - descriptor: ClassConstructorDescriptor, - constructorFactory: (IrConstructorSymbol) -> IrConstructor, - ): IrConstructor { - return descriptorExtension.declareConstructor(descriptor, constructorFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareConstructorIfNotExists( - descriptor: ClassConstructorDescriptor, - constructorFactory: (IrConstructorSymbol) -> IrConstructor, - ): IrConstructor { - return descriptorExtension.declareConstructorIfNotExists(descriptor, constructorFactory) - } - - @ObsoleteDescriptorBasedAPI - fun referenceConstructor(descriptor: ClassConstructorDescriptor): IrConstructorSymbol { - return descriptorExtension.referenceConstructor(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareConstructorFromLinker( - descriptor: ClassConstructorDescriptor, - signature: IdSignature, - constructorFactory: (IrConstructorSymbol) -> IrConstructor, - ): IrConstructor { - return descriptorExtension.declareConstructorFromLinker(descriptor, signature, constructorFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareEnumEntry( - startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: ClassDescriptor, - ): IrEnumEntry { - return descriptorExtension.declareEnumEntry(startOffset, endOffset, origin, descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareEnumEntry( - descriptor: ClassDescriptor, - factory: (IrEnumEntrySymbol) -> IrEnumEntry, - ): IrEnumEntry { - return descriptorExtension.declareEnumEntry(descriptor, factory) - } - - @ObsoleteDescriptorBasedAPI - fun declareEnumEntryIfNotExists(descriptor: ClassDescriptor, factory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry { - return descriptorExtension.declareEnumEntryIfNotExists(descriptor, factory) - } - - @ObsoleteDescriptorBasedAPI - fun declareEnumEntryFromLinker( - descriptor: ClassDescriptor, - signature: IdSignature, - factory: (IrEnumEntrySymbol) -> IrEnumEntry, - ): IrEnumEntry { - return descriptorExtension.declareEnumEntryFromLinker(descriptor, signature, factory) - } - - @ObsoleteDescriptorBasedAPI - fun referenceEnumEntry(descriptor: ClassDescriptor): IrEnumEntrySymbol { - return descriptorExtension.referenceEnumEntry(descriptor) - } - - @OptIn(ObsoleteDescriptorBasedAPI::class) - fun declareField( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: PropertyDescriptor, - type: IrType, - visibility: DescriptorVisibility? = null, - fieldFactory: (IrFieldSymbol) -> IrField, - ): IrField { - return descriptorExtension.declareField(startOffset, endOffset, origin, descriptor, type, visibility, fieldFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareField( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: PropertyDescriptor, - type: IrType, - irInitializer: IrExpressionBody?, - ): IrField { - return descriptorExtension.declareField(startOffset, endOffset, origin, descriptor, type, irInitializer) - } - - @ObsoleteDescriptorBasedAPI - fun referenceField(descriptor: PropertyDescriptor): IrFieldSymbol { - return descriptorExtension.referenceField(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareProperty( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: PropertyDescriptor, - isDelegated: Boolean = descriptor.isDelegated, - ): IrProperty { - return descriptorExtension.declareProperty(startOffset, endOffset, origin, descriptor, isDelegated) - } - - @ObsoleteDescriptorBasedAPI - fun declareProperty( - descriptor: PropertyDescriptor, - propertyFactory: (IrPropertySymbol) -> IrProperty, - ): IrProperty { - return descriptorExtension.declareProperty(descriptor, propertyFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declarePropertyIfNotExists(descriptor: PropertyDescriptor, propertyFactory: (IrPropertySymbol) -> IrProperty): IrProperty { - return descriptorExtension.declarePropertyIfNotExists(descriptor, propertyFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declarePropertyFromLinker( - descriptor: PropertyDescriptor, - signature: IdSignature, - factory: (IrPropertySymbol) -> IrProperty, - ): IrProperty { - return descriptorExtension.declarePropertyFromLinker(descriptor, signature, factory) - } - - @ObsoleteDescriptorBasedAPI - fun referenceProperty(descriptor: PropertyDescriptor): IrPropertySymbol { - return descriptorExtension.referenceProperty(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol { - return descriptorExtension.referenceTypeAlias(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareTypeAlias(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias { - return descriptorExtension.declareTypeAlias(descriptor, factory) - } - - @ObsoleteDescriptorBasedAPI - fun declareTypeAliasIfNotExists(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias { - return descriptorExtension.declareTypeAliasIfNotExists(descriptor, factory) - } - - @ObsoleteDescriptorBasedAPI - fun declareSimpleFunction( - descriptor: FunctionDescriptor, - functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction, - ): IrSimpleFunction { - return descriptorExtension.declareSimpleFunction(descriptor, functionFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareSimpleFunctionIfNotExists( - descriptor: FunctionDescriptor, - functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction, - ): IrSimpleFunction { - return descriptorExtension.declareSimpleFunctionIfNotExists(descriptor, functionFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareSimpleFunctionFromLinker( - descriptor: FunctionDescriptor, - signature: IdSignature, - functionFactory: (IrSimpleFunctionSymbol) -> IrSimpleFunction, - ): IrSimpleFunction { - return descriptorExtension.declareSimpleFunctionFromLinker(descriptor, signature, functionFactory) - } - - @ObsoleteDescriptorBasedAPI - fun referenceSimpleFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { - return descriptorExtension.referenceSimpleFunction(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun referenceDeclaredFunction(descriptor: FunctionDescriptor): IrSimpleFunctionSymbol { - return descriptorExtension.referenceDeclaredFunction(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareGlobalTypeParameter( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: TypeParameterDescriptor, - ): IrTypeParameter { - return descriptorExtension.declareGlobalTypeParameter(startOffset, endOffset, origin, descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun declareScopedTypeParameter( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: TypeParameterDescriptor, - typeParameterFactory: (IrTypeParameterSymbol) -> IrTypeParameter, - ): IrTypeParameter { - return descriptorExtension.declareScopedTypeParameter(startOffset, endOffset, origin, descriptor, typeParameterFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareValueParameter( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: ParameterDescriptor, - type: IrType, - varargElementType: IrType? = null, - name: Name? = null, - index: Int? = null, - isAssignable: Boolean = false, - valueParameterFactory: (IrValueParameterSymbol) -> IrValueParameter, - ): IrValueParameter { - return descriptorExtension.declareValueParameter( - startOffset, - endOffset, - origin, - descriptor, - type, - varargElementType, - name, - index, - isAssignable, - valueParameterFactory - ) - } - - @OptIn(ObsoleteDescriptorBasedAPI::class) - fun introduceValueParameter(irValueParameter: IrValueParameter) { - descriptorExtension.introduceValueParameter(irValueParameter) - } - - @ObsoleteDescriptorBasedAPI - open fun referenceValue(value: ValueDescriptor): IrValueSymbol { - return descriptorExtension.referenceValue(value) - } - - @ObsoleteDescriptorBasedAPI - fun referenceValueParameter(descriptor: ParameterDescriptor): IrValueParameterSymbol { - return descriptorExtension.referenceValueParameter(descriptor) - } - - @ObsoleteDescriptorBasedAPI - fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol { - return descriptorExtension.referenceTypeParameter(classifier) - } - - @ObsoleteDescriptorBasedAPI - fun referenceScopedTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol { - return descriptorExtension.referenceScopedTypeParameter(classifier) - } - - @ObsoleteDescriptorBasedAPI - fun declareVariable( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: VariableDescriptor, - type: IrType, - variableFactory: (IrVariableSymbol) -> IrVariable, - ): IrVariable { - return descriptorExtension.declareVariable(startOffset, endOffset, origin, descriptor, type, variableFactory) - } - - @ObsoleteDescriptorBasedAPI - fun declareVariable( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: VariableDescriptor, - type: IrType, - irInitializerExpression: IrExpression?, - ): IrVariable { - return descriptorExtension.declareVariable(startOffset, endOffset, origin, descriptor, type, irInitializerExpression) - } - - @ObsoleteDescriptorBasedAPI - fun declareLocalDelegatedProperty( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - descriptor: VariableDescriptorWithAccessors, - type: IrType, - factory: (IrLocalDelegatedPropertySymbol) -> IrLocalDelegatedProperty, - ): IrLocalDelegatedProperty { - return descriptorExtension.declareLocalDelegatedProperty(startOffset, endOffset, origin, descriptor, type, factory) - } - - @ObsoleteDescriptorBasedAPI - fun referenceLocalDelegatedProperty(descriptor: VariableDescriptorWithAccessors): IrLocalDelegatedPropertySymbol { - return descriptorExtension.referenceLocalDelegatedProperty(descriptor) - } } inline fun SymbolTable.withScope(owner: IrSymbol, block: SymbolTable.() -> T): T { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt index 6d2fb3dc70b..3e2c228d331 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTableExtension.kt @@ -340,7 +340,7 @@ abstract class SymbolTableExtension< endOffset: Int, origin: IrDeclarationOrigin, descriptor: Property, - isDelegated: Boolean,/* = descriptor.isDelegated*/ + isDelegated: Boolean ): IrProperty { return declareProperty(descriptor) { propertySymbol -> defaultPropertyFactory(startOffset, endOffset, origin, descriptor, isDelegated, propertySymbol) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt index 2a5dceec76f..aed8de521bb 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.DescriptorMetadataSource import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.types.impl.IrUninitializedType import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal import org.jetbrains.kotlin.utils.memoryOptimizedMap @@ -22,7 +23,7 @@ fun SymbolTable.declareSimpleFunctionWithOverrides( origin: IrDeclarationOrigin, descriptor: FunctionDescriptor ) = - declareSimpleFunction(descriptor) { + descriptorExtension.declareSimpleFunction(descriptor) { with(descriptor) { irFactory.createSimpleFunction( startOffset = startOffset, diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt index 07d22d15512..d6aea64067c 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt @@ -51,7 +51,7 @@ internal class LazyIrFunctionFactory( override fun getDeclaration(symbol: IrSymbol) = (symbol.descriptor as? FunctionClassDescriptor)?.let { descriptor -> buildClass(descriptor) { - declareClass(descriptor) { + descriptorExtension.declareClass(descriptor) { createIrClass(descriptor) } } @@ -103,7 +103,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( override fun getDeclaration(symbol: IrSymbol) = (symbol.descriptor as? FunctionClassDescriptor)?.let { descriptor -> buildClass(descriptor) { - declareClass(descriptor) { + descriptorExtension.declareClass(descriptor) { createIrClass(it, descriptor) } } @@ -124,7 +124,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( fun buildAllClasses() { val maxArity = 255 // See [BuiltInFictitiousFunctionClassFactory]. - (0 .. maxArity).forEach { arity -> + (0..maxArity).forEach { arity -> functionN(arity) kFunctionN(arity) suspendFunctionN(arity) @@ -156,13 +156,11 @@ internal class BuiltInFictitiousFunctionIrClassFactory( override fun kSuspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass = buildClass(reflectionTypes.getKSuspendFunction(arity) as FunctionClassDescriptor, declarator) - private val functionSymbol = symbolTable.referenceClass( - irBuiltIns.builtIns.builtInsModule.findClassAcrossModuleDependencies( - ClassId.topLevel(KonanFqNames.function))!!) + private val functionSymbol = symbolTable.descriptorExtension.referenceClass(irBuiltIns.builtIns.builtInsModule.findClassAcrossModuleDependencies( + ClassId.topLevel(KonanFqNames.function))!!) - private val kFunctionSymbol = symbolTable.referenceClass( - irBuiltIns.builtIns.builtInsModule.findClassAcrossModuleDependencies( - ClassId.topLevel(KonanFqNames.kFunction))!!) + private val kFunctionSymbol = symbolTable.descriptorExtension.referenceClass(irBuiltIns.builtIns.builtInsModule.findClassAcrossModuleDependencies( + ClassId.topLevel(KonanFqNames.kFunction))!!) private val filesMap = mutableMapOf() @@ -179,8 +177,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( } private fun createTypeParameter(descriptor: TypeParameterDescriptor): IrTypeParameter = - symbolTable.declareGlobalTypeParameter( - SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, DECLARATION_ORIGIN_FUNCTION_CLASS, + symbolTable.descriptorExtension.declareGlobalTypeParameter(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, DECLARATION_ORIGIN_FUNCTION_CLASS, descriptor ) @@ -198,7 +195,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( ) } } - return symbolTable.declareSimpleFunction(descriptor, functionFactory) + return symbolTable.descriptorExtension.declareSimpleFunction(descriptor, functionFactory) } private fun createIrClass(symbol: IrClassSymbol, descriptor: ClassDescriptor): IrClass = @@ -228,7 +225,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( } val superTypeSymbol = when (val superTypeDescriptor = superType.constructor.declarationDescriptor) { is FunctionClassDescriptor -> buildClass(superTypeDescriptor) { - declareClass(superTypeDescriptor) { + descriptorExtension.declareClass(superTypeDescriptor) { createIrClass(it, superTypeDescriptor) } }.symbol @@ -341,10 +338,10 @@ internal class BuiltInFictitiousFunctionIrClassFactory( } } - val newFunction = symbolTable.declareSimpleFunction(descriptor, functionDeclare) + val newFunction = symbolTable.descriptorExtension.declareSimpleFunction(descriptor, functionDeclare) newFunction.parent = this - newFunction.overriddenSymbols = descriptor.overriddenDescriptors.mapNotNull { symbolTable.referenceSimpleFunction(it.original) } + newFunction.overriddenSymbols = descriptor.overriddenDescriptors.mapNotNull { symbolTable.descriptorExtension.referenceSimpleFunction(it.original) } newFunction.dispatchReceiverParameter = descriptor.dispatchReceiverParameter?.let { newFunction.createValueParameter(it) } newFunction.extensionReceiverParameter = descriptor.extensionReceiverParameter?.let { newFunction.createValueParameter(it) } newFunction.valueParameters = descriptor.valueParameters.map { newFunction.createValueParameter(it) } @@ -371,7 +368,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( isExpect = descriptor.isExpect, isFakeOverride = true) } - val property = symbolTable.declareProperty(descriptor, propertyFactory = propertyDeclare) + val property = symbolTable.descriptorExtension.declareProperty(descriptor, propertyFactory = propertyDeclare) property.parent = this property.getter = descriptor.getter?.let { g -> createFakeOverrideFunction(g, property.symbol) } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cexport/CAdapterGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cexport/CAdapterGenerator.kt index baf7544a906..046f1c5d7d2 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cexport/CAdapterGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cexport/CAdapterGenerator.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.backend.common.pop import org.jetbrains.kotlin.backend.common.push import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.backend.konan.driver.phases.PsiToIrContext -import org.jetbrains.kotlin.config.CommonConfigurationKeys.USE_FIR import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor @@ -160,8 +159,8 @@ internal class ExportedElement( val irSymbol = when { isFunction -> owner.symbolTable.referenceFunction(declaration as FunctionDescriptor) - isClass -> owner.symbolTable.referenceClass(declaration as ClassDescriptor) - isEnumEntry -> owner.symbolTable.referenceEnumEntry(declaration as ClassDescriptor) + isClass -> owner.symbolTable.descriptorExtension.referenceClass(declaration as ClassDescriptor) + isEnumEntry -> owner.symbolTable.descriptorExtension.referenceEnumEntry(declaration as ClassDescriptor) else -> error("unexpected $kind element: $declaration") } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt index 67a00993db7..9c1e8e3e09f 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt @@ -507,18 +507,18 @@ internal class SymbolOverDescriptorsLookupUtils(val symbolTable: SymbolTable) : // inspired by: irBuiltIns.findBuiltInClassMemberFunctions(this, name).singleOrNull() clazz.descriptor.unsubstitutedMemberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND) .singleOrNull() - ?.let { symbolTable.referenceSimpleFunction(it) } + ?.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) } override fun findMemberProperty(clazz: IrClassSymbol, name: Name): IrPropertySymbol? = clazz.descriptor.unsubstitutedMemberScope.getContributedVariables(name, NoLookupLocation.FROM_BACKEND) .singleOrNull() - ?.let { symbolTable.referenceProperty(it) } + ?.let { symbolTable.descriptorExtension.referenceProperty(it) } override fun findMemberPropertyGetter(clazz: IrClassSymbol, name: Name): IrSimpleFunctionSymbol? = clazz.descriptor.unsubstitutedMemberScope.getContributedVariables(name, NoLookupLocation.FROM_BACKEND) .singleOrNull() ?.getter - ?.let { symbolTable.referenceSimpleFunction(it) } + ?.let { symbolTable.descriptorExtension.referenceSimpleFunction(it) } override fun getName(clazz: IrClassSymbol) = clazz.descriptor.name override fun isExtensionReceiverClass(property: IrPropertySymbol, expected: IrClassSymbol?): Boolean { @@ -529,7 +529,7 @@ internal class SymbolOverDescriptorsLookupUtils(val symbolTable: SymbolTable) : return function.descriptor.extensionReceiverParameter?.type?.let { TypeUtils.getClassDescriptor(it) } == expected?.descriptor } - override fun findGetter(property: IrPropertySymbol): IrSimpleFunctionSymbol = symbolTable.referenceSimpleFunction(property.descriptor.getter!!) + override fun findGetter(property: IrPropertySymbol): IrSimpleFunctionSymbol = symbolTable.descriptorExtension.referenceSimpleFunction(property.descriptor.getter!!) override fun isExtensionReceiverNullable(function: IrFunctionSymbol): Boolean? { return function.descriptor.extensionReceiverParameter?.type?.isMarkedNullable @@ -570,13 +570,13 @@ internal class SymbolOverDescriptorsLookupUtils(val symbolTable: SymbolTable) : override fun isSuspend(functionSymbol: IrFunctionSymbol): Boolean = functionSymbol.descriptor.isSuspend override fun getVisibility(function: IrFunctionSymbol): DescriptorVisibility = function.descriptor.visibility - override fun findPrimaryConstructor(clazz: IrClassSymbol) = clazz.descriptor.unsubstitutedPrimaryConstructor?.let { symbolTable.referenceConstructor(it) } - override fun findNoParametersConstructor(clazz: IrClassSymbol) = clazz.descriptor.constructors.singleOrNull { it.valueParameters.size == 0 }?.let { symbolTable.referenceConstructor(it) } + override fun findPrimaryConstructor(clazz: IrClassSymbol) = clazz.descriptor.unsubstitutedPrimaryConstructor?.let { symbolTable.descriptorExtension.referenceConstructor(it) } + override fun findNoParametersConstructor(clazz: IrClassSymbol) = clazz.descriptor.constructors.singleOrNull { it.valueParameters.size == 0 }?.let { symbolTable.descriptorExtension.referenceConstructor(it) } override fun findNestedClass(clazz: IrClassSymbol, name: Name): IrClassSymbol? { val classDescriptor = clazz.descriptor.defaultType.memberScope.getContributedClassifier(name, NoLookupLocation.FROM_BUILTINS) as? ClassDescriptor return classDescriptor?.let { - symbolTable.referenceClass(it) + symbolTable.descriptorExtension.referenceClass(it) } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/DescriptorToIrTranslationUtils.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/DescriptorToIrTranslationUtils.kt index b984b99d0b1..b3dbc1293c2 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/DescriptorToIrTranslationUtils.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/DescriptorToIrTranslationUtils.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.impl.IrUninitializedType import org.jetbrains.kotlin.ir.util.* @@ -54,7 +55,7 @@ internal interface DescriptorToIrTranslationMixin { * Additional elements are passed via [builder] callback. */ fun createClass(descriptor: ClassDescriptor, builder: (IrClass) -> Unit): IrClass = - symbolTable.declareClass(descriptor) { + symbolTable.descriptorExtension.declareClass(descriptor) { symbolTable.irFactory.createIrClassFromDescriptor( SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, it, descriptor ) @@ -85,7 +86,7 @@ internal interface DescriptorToIrTranslationMixin { } fun createConstructor(constructorDescriptor: ClassConstructorDescriptor): IrConstructor { - val irConstructor = symbolTable.declareConstructor(constructorDescriptor) { + val irConstructor = symbolTable.descriptorExtension.declareConstructor(constructorDescriptor) { with(constructorDescriptor) { IrConstructorImpl( SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, it, name, visibility, @@ -107,7 +108,7 @@ internal interface DescriptorToIrTranslationMixin { } fun createProperty(propertyDescriptor: PropertyDescriptor): IrProperty { - val irProperty = symbolTable.declareProperty(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, propertyDescriptor) + val irProperty = symbolTable.descriptorExtension.declareProperty(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, propertyDescriptor, propertyDescriptor.isDelegated) irProperty.getter = propertyDescriptor.getter?.let { val irGetter = createFunction(it) irGetter.correspondingPropertySymbol = irProperty.symbol diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/IrProviderForCEnumAndCStructStubs.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/IrProviderForCEnumAndCStructStubs.kt index 37b5b42a328..ef184dc4654 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/IrProviderForCEnumAndCStructStubs.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/IrProviderForCEnumAndCStructStubs.kt @@ -63,7 +63,7 @@ internal class IrProviderForCEnumAndCStructStubs( .flatMap { it.getMemberScope().getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) } .filterIsInstance() .filter { it.implementsCEnum() || it.inheritsFromCStructVar() } - .forEach { symbolTable.referenceClass(it) } + .forEach { symbolTable.descriptorExtension.referenceClass(it) } private fun generateIrIfNeeded(symbol: IrSymbol, file: IrFile) { // TODO: These `findOrGenerate` calls generate a whole subtree. @@ -92,23 +92,23 @@ internal class IrProviderForCEnumAndCStructStubs( fun getDeclaration(descriptor: DeclarationDescriptor, idSignature: IdSignature, file: IrFile, symbolKind: BinarySymbolData.SymbolKind): IrSymbolOwner { return symbolTable.run { when (symbolKind) { - BinarySymbolData.SymbolKind.CONSTRUCTOR_SYMBOL -> declareConstructorFromLinker(descriptor as ClassConstructorDescriptor, idSignature) { s -> + BinarySymbolData.SymbolKind.CONSTRUCTOR_SYMBOL -> descriptorExtension.declareConstructorFromLinker(descriptor as ClassConstructorDescriptor, idSignature) { s: IrConstructorSymbol -> generateIrIfNeeded(s, file) s.owner } - BinarySymbolData.SymbolKind.CLASS_SYMBOL -> declareClassFromLinker(descriptor as ClassDescriptor, idSignature) { s -> + BinarySymbolData.SymbolKind.CLASS_SYMBOL -> descriptorExtension.declareClassFromLinker(descriptor as ClassDescriptor, idSignature) { s -> generateIrIfNeeded(s, file) s.owner } - BinarySymbolData.SymbolKind.ENUM_ENTRY_SYMBOL -> declareEnumEntryFromLinker(descriptor as ClassDescriptor, idSignature) { s -> + BinarySymbolData.SymbolKind.ENUM_ENTRY_SYMBOL -> descriptorExtension.declareEnumEntryFromLinker(descriptor as ClassDescriptor, idSignature) { s: IrEnumEntrySymbol -> generateIrIfNeeded(s, file) s.owner } - BinarySymbolData.SymbolKind.FUNCTION_SYMBOL -> declareSimpleFunctionFromLinker(descriptor as FunctionDescriptor, idSignature) { s -> + BinarySymbolData.SymbolKind.FUNCTION_SYMBOL -> descriptorExtension.declareSimpleFunctionFromLinker(descriptor as FunctionDescriptor, idSignature) { s: IrSimpleFunctionSymbol -> generateIrIfNeeded(s, file) s.owner } - BinarySymbolData.SymbolKind.PROPERTY_SYMBOL -> declarePropertyFromLinker(descriptor as PropertyDescriptor, idSignature) { s -> + BinarySymbolData.SymbolKind.PROPERTY_SYMBOL -> descriptorExtension.declarePropertyFromLinker(descriptor as PropertyDescriptor, idSignature) { s: IrPropertySymbol -> generateIrIfNeeded(s, file) s.owner } @@ -121,4 +121,4 @@ internal class IrProviderForCEnumAndCStructStubs( companion object { const val cTypeDefinitionsFileName = "CTypeDefinitions" } -} \ No newline at end of file +} diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumClassGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumClassGenerator.kt index 998bec3eb4b..efac5ef0d6f 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumClassGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumClassGenerator.kt @@ -60,7 +60,7 @@ internal class CEnumClassGenerator( * Generates one if absent. */ fun findOrGenerateCEnum(classDescriptor: ClassDescriptor, parent: IrDeclarationContainer): IrClass { - val irClassSymbol = symbolTable.referenceClass(classDescriptor) + val irClassSymbol = symbolTable.descriptorExtension.referenceClass(classDescriptor) return if (!irClassSymbol.isBound) { provideIrClassForCEnum(classDescriptor).also { it.patchDeclarationParents(parent) @@ -123,11 +123,10 @@ internal class CEnumClassGenerator( } private fun createEnumEntry(enumDescriptor: ClassDescriptor, entryDescriptor: ClassDescriptor): IrEnumEntry { - val enumEntry = symbolTable.declareEnumEntry( - SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, + val enumEntry = symbolTable.descriptorExtension.declareEnumEntry(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, entryDescriptor ) - val constructorSymbol = symbolTable.referenceConstructor(enumDescriptor.unsubstitutedPrimaryConstructor!!) + val constructorSymbol = symbolTable.descriptorExtension.referenceConstructor(enumDescriptor.unsubstitutedPrimaryConstructor!!) postLinkageSteps.add { enumEntry.initializerExpression = IrExpressionBodyImpl(IrEnumConstructorCallImpl( SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, @@ -158,8 +157,8 @@ internal class CEnumClassGenerator( val irConstructor = createConstructor(descriptor.unsubstitutedPrimaryConstructor!!) val builtIns = (irBuiltIns as IrBuiltInsOverDescriptors).builtIns val enumConstructor = builtIns.enum.constructors.single() - val constructorSymbol = symbolTable.referenceConstructor(enumConstructor) - val classSymbol = symbolTable.referenceClass(descriptor) + val constructorSymbol = symbolTable.descriptorExtension.referenceConstructor(enumConstructor) + val classSymbol = symbolTable.descriptorExtension.referenceClass(descriptor) val type = descriptor.defaultType.toIrType() postLinkageSteps.add { irConstructor.body = irBuilder(irBuiltIns, irConstructor.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumCompanionGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumCompanionGenerator.kt index ccc358612bb..3f41d119c74 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumCompanionGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumCompanionGenerator.kt @@ -52,8 +52,8 @@ internal class CEnumCompanionGenerator( private fun createCompanionConstructor(companionObjectDescriptor: ClassDescriptor): IrConstructor { val anyPrimaryConstructor = companionObjectDescriptor.builtIns.any.unsubstitutedPrimaryConstructor!! - val superConstructorSymbol = symbolTable.referenceConstructor(anyPrimaryConstructor) - val classSymbol = symbolTable.referenceClass(companionObjectDescriptor) + val superConstructorSymbol = symbolTable.descriptorExtension.referenceConstructor(anyPrimaryConstructor) + val classSymbol = symbolTable.descriptorExtension.referenceClass(companionObjectDescriptor) return createConstructor(companionObjectDescriptor.unsubstitutedPrimaryConstructor!!).also { postLinkageSteps.add { it.body = irBuilder(irBuiltIns, it.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody { @@ -99,4 +99,4 @@ internal class CEnumCompanionGenerator( } } } -} \ No newline at end of file +} diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumVarClassGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumVarClassGenerator.kt index 689b54f5b60..05b592bcdf1 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumVarClassGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumVarClassGenerator.kt @@ -59,11 +59,11 @@ internal class CEnumVarClassGenerator( private fun createPrimaryConstructor(enumVarClass: IrClass): IrConstructor { val irConstructor = createConstructor(enumVarClass.descriptor.unsubstitutedPrimaryConstructor!!) - val classSymbol = symbolTable.referenceClass(enumVarClass.descriptor) + val classSymbol = symbolTable.descriptorExtension.referenceClass(enumVarClass.descriptor) postLinkageSteps.add { irConstructor.body = irBuilder(irBuiltIns, irConstructor.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody { +IrDelegatingConstructorCallImpl.fromSymbolOwner( - startOffset, endOffset, context.irBuiltIns.unitType, symbols.enumVarConstructorSymbol + startOffset, endOffset, context.irBuiltIns.unitType, symbols.enumVarConstructorSymbol ).also { it.putValueArgument(0, irGet(irConstructor.valueParameters[0])) } @@ -82,13 +82,13 @@ internal class CEnumVarClassGenerator( } private fun createCompanionConstructor(companionObjectDescriptor: ClassDescriptor, typeSize: Int): IrConstructor { - val classSymbol = symbolTable.referenceClass(companionObjectDescriptor) + val classSymbol = symbolTable.descriptorExtension.referenceClass(companionObjectDescriptor) return createConstructor(companionObjectDescriptor.unsubstitutedPrimaryConstructor!!).also { postLinkageSteps.add { it.body = irBuilder(irBuiltIns, it.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody { +IrDelegatingConstructorCallImpl.fromSymbolOwner( - startOffset, endOffset, context.irBuiltIns.unitType, - symbols.primitiveVarPrimaryConstructor + startOffset, endOffset, context.irBuiltIns.unitType, + symbols.primitiveVarPrimaryConstructor ).also { it.putValueArgument(0, irInt(typeSize)) } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarClassGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarClassGenerator.kt index 849fd79d917..5ae984dec5f 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarClassGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarClassGenerator.kt @@ -41,7 +41,7 @@ internal class CStructVarClassGenerator( override val postLinkageSteps: MutableList<() -> Unit> = mutableListOf() fun findOrGenerateCStruct(classDescriptor: ClassDescriptor, parent: IrDeclarationContainer): IrClass { - val irClassSymbol = symbolTable.referenceClass(classDescriptor) + val irClassSymbol = symbolTable.descriptorExtension.referenceClass(classDescriptor) return if (!irClassSymbol.isBound) { provideIrClassForCStruct(classDescriptor).also { it.patchDeclarationParents(parent) @@ -275,7 +275,7 @@ internal class CStructVarClassGenerator( ).also { it.putValueArgument(0, irGet(irConstructor.valueParameters[0])) } - +irInstanceInitializer(symbolTable.referenceClass(irClass.descriptor)) + +irInstanceInitializer(symbolTable.descriptorExtension.referenceClass(irClass.descriptor)) } } } @@ -290,7 +290,7 @@ internal class CStructVarClassGenerator( it.putTypeArgument(0, irConstructor.valueParameters[0].type) it.putValueArgument(0, irGet(irConstructor.valueParameters[0])) } - +irInstanceInitializer(symbolTable.referenceClass(irClass.descriptor)) + +irInstanceInitializer(symbolTable.descriptorExtension.referenceClass(irClass.descriptor)) } } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarCompanionGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarCompanionGenerator.kt index 67b4bfc1b06..bb9176e8fd4 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarCompanionGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarCompanionGenerator.kt @@ -73,7 +73,7 @@ internal class CStructVarCompanionGenerator( startOffset, endOffset, context.irBuiltIns.unitType, irBuiltIns.anyClass.owner.primaryConstructor!!.symbol ) - +irInstanceInitializer(symbolTable.referenceClass(companionObjectDescriptor)) + +irInstanceInitializer(symbolTable.descriptorExtension.referenceClass(companionObjectDescriptor)) } } } @@ -88,10 +88,10 @@ internal class CStructVarCompanionGenerator( it.putValueArgument(0, irLong(size)) it.putValueArgument(1, irInt(align)) } - +irInstanceInitializer(symbolTable.referenceClass(companionObjectDescriptor)) + +irInstanceInitializer(symbolTable.descriptorExtension.referenceClass(companionObjectDescriptor)) } } } } } -} \ No newline at end of file +} diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportCodeSpec.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportCodeSpec.kt index 635b30bb711..88aa73565a5 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportCodeSpec.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportCodeSpec.kt @@ -24,7 +24,7 @@ internal fun ObjCExportedInterface.createCodeSpec(symbolTable: SymbolTable): Obj createObjCMethodSpecBaseMethod( mapper, namer, - symbolTable.referenceSimpleFunction(it), + symbolTable.descriptorExtension.referenceSimpleFunction(it), it ) ) @@ -58,13 +58,13 @@ internal fun ObjCExportedInterface.createCodeSpec(symbolTable: SymbolTable): Obj methods += createObjCMethods(allBaseMethods) val binaryName = namer.getClassOrProtocolName(descriptor).binaryName - val irClassSymbol = symbolTable.referenceClass(descriptor) + val irClassSymbol = symbolTable.descriptorExtension.referenceClass(descriptor) if (descriptor.isInterface) { ObjCProtocolForKotlinInterface(binaryName, irClassSymbol, methods) } else { descriptor.constructors.filter { mapper.shouldBeExposed(it) }.mapTo(methods) { - val irConstructorSymbol = symbolTable.referenceConstructor(it) + val irConstructorSymbol = symbolTable.descriptorExtension.referenceConstructor(it) val baseMethod = createObjCMethodSpecBaseMethod(mapper, namer, irConstructorSymbol, it) if (descriptor.isArray) { @@ -80,24 +80,26 @@ internal fun ObjCExportedInterface.createCodeSpec(symbolTable: SymbolTable): Obj } if (descriptor.needCompanionObjectProperty(namer, mapper)) { - methods += ObjCGetterForObjectInstance(namer.getCompanionObjectPropertySelector(descriptor), - symbolTable.referenceClass(descriptor.companionObjectDescriptor!!)) + methods += ObjCGetterForObjectInstance( + namer.getCompanionObjectPropertySelector(descriptor), + symbolTable.descriptorExtension.referenceClass(descriptor.companionObjectDescriptor!!) + ) } if (descriptor.kind == ClassKind.ENUM_CLASS) { descriptor.enumEntries.mapTo(methods) { - ObjCGetterForKotlinEnumEntry(symbolTable.referenceEnumEntry(it), namer.getEnumEntrySelector(it)) + ObjCGetterForKotlinEnumEntry(symbolTable.descriptorExtension.referenceEnumEntry(it), namer.getEnumEntrySelector(it)) } descriptor.getEnumValuesFunctionDescriptor()?.let { methods += ObjCClassMethodForKotlinEnumValuesOrEntries( - symbolTable.referenceSimpleFunction(it), + symbolTable.descriptorExtension.referenceSimpleFunction(it), namer.getEnumStaticMemberSelector(it) ) } descriptor.getEnumEntriesPropertyDescriptor()?.let { methods += ObjCClassMethodForKotlinEnumValuesOrEntries( - symbolTable.referenceSimpleFunction(it.getter!!), + symbolTable.descriptorExtension.referenceSimpleFunction(it.getter!!), namer.getEnumStaticMemberSelector(it) ) } @@ -227,4 +229,4 @@ internal class ObjCClassForKotlinFile( ) : ObjCTypeSpec(binaryName) { override fun toString(): String = "ObjC spec of class `$binaryName` for `${sourceFile.name}`" -} \ No newline at end of file +} diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/KJvmReplCompilerBase.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/KJvmReplCompilerBase.kt index 920ee52f1f0..25f55d762da 100644 --- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/KJvmReplCompilerBase.kt +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/KJvmReplCompilerBase.kt @@ -204,7 +204,7 @@ open class KJvmReplCompilerBase( prebuiltState: GenerationState.Builder, ): GenerationState { val generatorExtensions = object : JvmGeneratorExtensionsImpl(compilationState.environment.configuration) { - override fun getPreviousScripts() = state.history.map { compilationState.symbolTable.referenceScript(it.item) } + override fun getPreviousScripts() = state.history.map { compilationState.symbolTable.descriptorExtension.referenceScript(it.item) } } val codegenFactory = JvmIrCodegenFactory( compilationState.environment.configuration,