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

[IR] Remove descriptor-related methods from SymbolTable

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