IR: symbol -> target in IrDeclarationReference, working only in JVM for now
diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
index 1eadd8f..c675ed2 100644
--- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
@@ -27,7 +27,6 @@
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.builders.*
@@ -355,7 +354,7 @@
if (firOverriddenSymbol != null && this is IrSimpleFunction && firFunctionSymbol != null) {
val overriddenSymbol = declarationStorage.getIrFunctionSymbol(firOverriddenSymbol)
if (overriddenSymbol is IrSimpleFunctionSymbol) {
- overriddenSymbols += overriddenSymbol
+ overridden += overriddenSymbol
}
}
body = firFunction?.body?.convertToIrBlockBody()
@@ -547,7 +546,7 @@
if (firOverriddenSymbol != null && backingField != null) {
val overriddenSymbol = declarationStorage.getIrPropertyOrFieldSymbol(firOverriddenSymbol.fir.backingFieldSymbol)
if (overriddenSymbol is IrFieldSymbol) {
- backingField.overriddenSymbols += overriddenSymbol
+ backingField.overridden += overriddenSymbol
}
}
}
@@ -556,14 +555,14 @@
property.getter, this, propertyType, property.getter is FirDefaultPropertyGetter, property.getter == null
)
getter?.apply {
- overriddenProperty?.owner?.getter?.symbol?.let { overriddenSymbols += it }
+ overriddenProperty?.owner?.getter?.symbol?.let { overridden += it }
}
if (property.isVar) {
setter?.setPropertyAccessorContent(
property.setter, this, propertyType, property.setter is FirDefaultPropertySetter, property.setter == null
)
setter?.apply {
- overriddenProperty?.owner?.setter?.symbol?.let { overriddenSymbols += it }
+ overriddenProperty?.owner?.setter?.symbol?.let { overridden += it }
}
}
property.annotations.forEach {
@@ -739,7 +738,7 @@
}
}
} else {
- val name = if (this is IrCallImpl) symbol.owner.name else "???"
+ val name = if (this is IrCallImpl) target.name else "???"
IrErrorCallExpressionImpl(
startOffset, endOffset, type,
"Cannot bind $argumentsCount arguments to $name call with $valueArgumentsCount parameters"
@@ -762,14 +761,13 @@
private fun IrExpression.applyReceivers(qualifiedAccess: FirQualifiedAccess): IrExpression {
return when (this) {
is IrCallImpl -> {
- val ownerFunction = symbol.owner
- if (ownerFunction.dispatchReceiverParameter != null) {
+ if (target.dispatchReceiverParameter != null) {
dispatchReceiver = qualifiedAccess.dispatchReceiver.takeIf { it !is FirNoReceiverExpression }?.toIrExpression()
?: qualifiedAccess.explicitReceiver?.toIrExpression() // NB: this applies to the situation when call is unresolved
if (dispatchReceiver == null) {
throw AssertionError()
}
- } else if (ownerFunction.extensionReceiverParameter != null) {
+ } else if (target.extensionReceiverParameter != null) {
extensionReceiver = qualifiedAccess.extensionReceiver.takeIf { it !is FirNoReceiverExpression }?.toIrExpression()
?: qualifiedAccess.explicitReceiver?.toIrExpression()
if (extensionReceiver == null) {
@@ -779,8 +777,7 @@
this
}
is IrFieldExpressionBase -> {
- val ownerField = symbol.owner
- if (!ownerField.isStatic) {
+ if (!target.isStatic) {
receiver = qualifiedAccess.dispatchReceiver.takeIf { it !is FirNoReceiverExpression }?.toIrExpression()
?: qualifiedAccess.explicitReceiver?.toIrExpression()
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt
index 0611257..0ec103e 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt
@@ -25,7 +25,6 @@
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.types.defaultType
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
@@ -63,7 +62,8 @@
ensureTypesEqual(type, expectedType)
}
- private fun IrSymbol.ensureBound(expression: IrExpression) {
+ private fun IrSymbolOwner.ensureBound(expression: IrExpression) {
+ if (this !is IrSymbol) return
if (!this.isBound && expression.type !is IrDynamicType) {
reportError(expression, "Unbound symbol ${this}")
}
@@ -102,7 +102,7 @@
override fun visitGetObjectValue(expression: IrGetObjectValue) {
super.visitGetObjectValue(expression)
- expression.ensureTypeIs(expression.symbol.createType(false, emptyList()))
+ expression.ensureTypeIs(expression.target.createType(false, emptyList()))
}
// TODO: visitGetEnumValue
@@ -110,7 +110,7 @@
override fun visitGetValue(expression: IrGetValue) {
super.visitGetValue(expression)
- expression.ensureTypeIs(expression.symbol.owner.type)
+ expression.ensureTypeIs(expression.target.type)
}
override fun visitSetVariable(expression: IrSetVariable) {
@@ -122,7 +122,7 @@
override fun visitGetField(expression: IrGetField) {
super.visitGetField(expression)
- val fieldType = expression.symbol.owner.type
+ val fieldType = expression.target.type
// TODO: We don't have the proper type substitution yet, so skip generics for now.
if (fieldType is IrSimpleType &&
fieldType.classifier is IrClassSymbol &&
@@ -141,14 +141,14 @@
override fun visitCall(expression: IrCall) {
super.visitCall(expression)
- val function = expression.symbol.owner
+ val function = expression.target
if (function.dispatchReceiverParameter?.type is IrDynamicType) {
reportError(expression, "Dispatch receivers with 'dynamic' type are not allowed")
}
// TODO: Why don't we check parameters as well?
- val returnType = expression.symbol.owner.returnType
+ val returnType = expression.target.returnType
// TODO: We don't have the proper type substitution yet, so skip generics for now.
if (returnType is IrSimpleType &&
returnType.classifier is IrClassSymbol &&
@@ -158,7 +158,7 @@
expression.ensureTypeIs(returnType)
}
- expression.superQualifierSymbol?.ensureBound(expression)
+ expression.irSuperQualifier?.ensureBound(expression)
}
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) {
@@ -177,7 +177,7 @@
super.visitInstanceInitializerCall(expression)
expression.ensureTypeIs(irBuiltIns.unitType)
- expression.classSymbol.ensureBound(expression)
+ expression.irClass.ensureBound(expression)
}
override fun visitTypeOperator(expression: IrTypeOperatorCall) {
@@ -228,7 +228,7 @@
super.visitReturn(expression)
expression.ensureTypeIs(irBuiltIns.nothingType)
- expression.returnTargetSymbol.ensureBound(expression)
+ expression.irReturnTarget.ensureBound(expression)
}
override fun visitThrow(expression: IrThrow) {
@@ -294,15 +294,15 @@
return
}
- expression.symbol.ensureBound(expression)
+ expression.target.ensureBound(expression)
}
override fun visitDeclaration(declaration: IrDeclaration) {
super.visitDeclaration(declaration)
if (declaration is IrOverridableDeclaration<*>) {
- for (overriddenSymbol in declaration.overriddenSymbols) {
- val overriddenDeclaration = overriddenSymbol.owner as? IrDeclarationWithVisibility ?: continue
+ for (overridden in declaration.overridden) {
+ val overriddenDeclaration = overridden as? IrDeclarationWithVisibility ?: continue
if (overriddenDeclaration.visibility == Visibilities.PRIVATE) {
reportError(declaration, "Overrides private declaration $overriddenDeclaration")
}
@@ -313,13 +313,13 @@
override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
super.visitFunctionAccess(expression)
- expression.symbol.ensureBound(expression)
+ expression.target.ensureBound(expression)
}
override fun visitFunctionReference(expression: IrFunctionReference) {
super.visitFunctionReference(expression)
- expression.symbol.ensureBound(expression)
+ expression.target.ensureBound(expression)
}
override fun visitPropertyReference(expression: IrPropertyReference) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DeepCopyIrTreeWithDeclarations.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DeepCopyIrTreeWithDeclarations.kt
index aa5e680..a56a935 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DeepCopyIrTreeWithDeclarations.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DeepCopyIrTreeWithDeclarations.kt
@@ -22,10 +22,7 @@
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrLoop
-import org.jetbrains.kotlin.ir.util.DeepCopyIrTreeWithSymbols
-import org.jetbrains.kotlin.ir.util.DeepCopySymbolRemapper
-import org.jetbrains.kotlin.ir.util.DeepCopyTypeRemapper
-import org.jetbrains.kotlin.ir.util.DescriptorsRemapper
+import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.visitors.acceptVoid
@Suppress("UNCHECKED_CAST")
@@ -52,5 +49,5 @@
}
},
null
- ) as T
+ ).desymbolize() as T
}
\ No newline at end of file
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/IrElementTransformerVoidWithContext.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/IrElementTransformerVoidWithContext.kt
index ad511d1..7021e5e 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/IrElementTransformerVoidWithContext.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/IrElementTransformerVoidWithContext.kt
@@ -20,10 +20,6 @@
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.builders.Scope
import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
@@ -34,7 +30,7 @@
private val scopeStack = mutableListOf<ScopeWithIr>()
protected open fun createScope(declaration: IrSymbolOwner): ScopeWithIr =
- ScopeWithIr(Scope(declaration.symbol), declaration)
+ ScopeWithIr(Scope(declaration), declaration)
final override fun visitFile(declaration: IrFile): IrFile {
scopeStack.push(createScope(declaration))
@@ -72,9 +68,9 @@
}
protected val currentFile get() = scopeStack.lastOrNull { it.irElement is IrFile }!!.irElement as IrFile
- protected val currentClass get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrClassSymbol }
- protected val currentFunction get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrFunctionSymbol }
- protected val currentProperty get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrPropertySymbol }
+ protected val currentClass get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrClass }
+ protected val currentFunction get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrFunction }
+ protected val currentProperty get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrProperty }
protected val currentScope get() = scopeStack.peek()
protected val parentScope get() = if (scopeStack.size < 2) null else scopeStack[scopeStack.size - 2]
protected val allScopes get() = scopeStack
@@ -109,7 +105,7 @@
private val scopeStack = mutableListOf<ScopeWithIr>()
protected open fun createScope(declaration: IrSymbolOwner): ScopeWithIr =
- ScopeWithIr(Scope(declaration.symbol), declaration)
+ ScopeWithIr(Scope(declaration), declaration)
final override fun visitFile(declaration: IrFile) {
scopeStack.push(createScope(declaration))
@@ -142,10 +138,10 @@
scopeStack.pop()
}
- protected val currentFile get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrFileSymbol }
- protected val currentClass get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrClassSymbol }
- protected val currentFunction get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrFunctionSymbol }
- protected val currentProperty get() = scopeStack.lastOrNull { it.scope.scopeOwnerSymbol is IrPropertySymbol }
+ protected val currentFile get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrFile }
+ protected val currentClass get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrClass }
+ protected val currentFunction get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrFunction }
+ protected val currentProperty get() = scopeStack.lastOrNull { it.scope.irScopeOwner is IrProperty }
protected val currentScope get() = scopeStack.peek()
protected val parentScope get() = if (scopeStack.size < 2) null else scopeStack[scopeStack.size - 2]
protected val allScopes get() = scopeStack
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/TailRecursionCallsCollector.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/TailRecursionCallsCollector.kt
index fa19575..a5fb6cc 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/TailRecursionCallsCollector.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/TailRecursionCallsCollector.kt
@@ -62,7 +62,7 @@
}
override fun visitReturn(expression: IrReturn, data: ElementKind) {
- val valueKind = if (expression.returnTargetSymbol == irFunction.symbol) {
+ val valueKind = if (expression.irReturnTarget == irFunction) {
ElementKind.TAIL_STATEMENT
} else {
ElementKind.NOT_SURE
@@ -98,18 +98,18 @@
}
// Is it a recursive call?
- if (expression.symbol != irFunction.symbol) {
+ if (expression.target != irFunction) {
return
}
// TODO: check type arguments
- if (irFunction.overriddenSymbols.isNotEmpty() && expression.usesDefaultArguments()) {
+ if (irFunction.overridden.isNotEmpty() && expression.usesDefaultArguments()) {
// Overridden functions using default arguments at tail call are not included: KT-4285
return
}
expression.dispatchReceiver?.let {
- if (it !is IrGetValue || it.symbol.owner != irFunction.dispatchReceiverParameter) {
+ if (it !is IrGetValue || it.target != irFunction.dispatchReceiverParameter) {
// A tail call is not allowed to change dispatch receiver
// class C {
// fun foo(other: C) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt
index 7e9dd1e..b6f6e4e 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt
@@ -46,12 +46,12 @@
}
private fun IrConstructorCall.toAnnotationDescriptor(): AnnotationDescriptor {
- assert(symbol.owner.parentAsClass.isAnnotationClass) {
+ assert(target.parentAsClass.isAnnotationClass) {
"Expected call to constructor of annotation class but was: ${this.dump()}"
}
return AnnotationDescriptorImpl(
- symbol.owner.parentAsClass.defaultType.toKotlinType(),
- symbol.owner.valueParameters.map { it.name to getValueArgument(it.index) }
+ target.parentAsClass.defaultType.toKotlinType(),
+ target.valueParameters.map { it.name to getValueArgument(it.index) }
.filter { it.second != null }
.associate { it.first to it.second!!.toConstantValue() },
/*TODO*/ SourceElement.NO_SOURCE
@@ -81,7 +81,7 @@
}
}
- this is IrGetEnumValue -> EnumValue(symbol.owner.parentAsClass.descriptor.classId!!, symbol.owner.name)
+ this is IrGetEnumValue -> EnumValue(target.parentAsClass.descriptor.classId!!, target.name)
this is IrClassReference -> KClassValue(classType.classifierOrFail.descriptor.classId!!, /*TODO*/0)
@@ -381,7 +381,7 @@
var originalDescriptor: FunctionDescriptor? = null
- override fun getOverriddenDescriptors() = owner.overriddenSymbols.map { it.descriptor }
+ override fun getOverriddenDescriptors() = owner.overridden.map { it.descriptor }
override fun getContainingDeclaration(): DeclarationDescriptor = getContainingDeclaration(owner)
@@ -965,7 +965,7 @@
override fun hasSynthesizedParameterNames() = false
override fun getOverriddenDescriptors(): MutableCollection<out PropertyDescriptor> =
- owner.overriddenSymbols.map { it.descriptor }.toMutableList()
+ owner.overridden.map { it.descriptor }.toMutableList()
override fun copy(
newOwner: DeclarationDescriptor?,
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt
index 159855a..38cef50 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt
@@ -14,12 +14,7 @@
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.classOrNull
import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
@@ -60,16 +55,16 @@
name: Name,
vararg packageNameSegments: String = arrayOf("kotlin"),
condition: (SimpleFunctionDescriptor) -> Boolean
- ): IrSimpleFunctionSymbol =
+ ): IrSimpleFunction =
symbolTable.referenceSimpleFunction(
builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
.first(condition)
- )
+ ).owner
- private fun getClass(name: Name, vararg packageNameSegments: String = arrayOf("kotlin")): IrClassSymbol =
+ private fun getClass(name: Name, vararg packageNameSegments: String = arrayOf("kotlin")): IrClass =
symbolTable.referenceClass(
builtInsPackage(*packageNameSegments).getContributedClassifier(name, NoLookupLocation.FROM_BACKEND) as ClassDescriptor
- )
+ ).owner
/**
* Use this table to reference external dependencies.
@@ -77,15 +72,15 @@
open val externalSymbolTable: ReferenceSymbolTable
get() = symbolTable
- abstract val ThrowNullPointerException: IrFunctionSymbol
- abstract val ThrowNoWhenBranchMatchedException: IrFunctionSymbol
- abstract val ThrowTypeCastException: IrFunctionSymbol
+ abstract val ThrowNullPointerException: IrFunction
+ abstract val ThrowNoWhenBranchMatchedException: IrFunction
+ abstract val ThrowTypeCastException: IrFunction
- abstract val ThrowUninitializedPropertyAccessException: IrSimpleFunctionSymbol
+ abstract val ThrowUninitializedPropertyAccessException: IrSimpleFunction
- abstract val stringBuilder: IrClassSymbol
+ abstract val stringBuilder: IrClass
- abstract val defaultConstructorMarker: IrClassSymbol
+ abstract val defaultConstructorMarker: IrClass
val iterator = getClass(Name.identifier("Iterator"), "kotlin", "collections")
@@ -142,11 +137,11 @@
val array = symbolTable.referenceClass(builtIns.array)
private fun primitiveArrayClass(type: PrimitiveType) =
- symbolTable.referenceClass(builtIns.getPrimitiveArrayClassDescriptor(type))
+ symbolTable.referenceClass(builtIns.getPrimitiveArrayClassDescriptor(type)).owner
private fun unsignedArrayClass(unsignedType: UnsignedType) =
builtIns.builtInsModule.findClassAcrossModuleDependencies(unsignedType.arrayClassId)
- ?.let { symbolTable.referenceClass(it) }
+ ?.let { symbolTable.referenceClass(it).owner }
val byteArray = primitiveArrayClass(PrimitiveType.BYTE)
val charArray = primitiveArrayClass(PrimitiveType.CHAR)
@@ -182,51 +177,51 @@
val mutableIterator = symbolTable.referenceClass(builtIns.mutableIterator)
val mutableListIterator = symbolTable.referenceClass(builtIns.mutableListIterator)
- abstract val copyRangeTo: Map<ClassDescriptor, IrSimpleFunctionSymbol>
+ abstract val copyRangeTo: Map<ClassDescriptor, IrSimpleFunction>
- abstract val coroutineImpl: IrClassSymbol
+ abstract val coroutineImpl: IrClass
- abstract val coroutineSuspendedGetter: IrSimpleFunctionSymbol
+ abstract val coroutineSuspendedGetter: IrSimpleFunction
- abstract val getContinuation: IrSimpleFunctionSymbol
+ abstract val getContinuation: IrSimpleFunction
- abstract val coroutineContextGetter: IrSimpleFunctionSymbol
+ abstract val coroutineContextGetter: IrSimpleFunction
- abstract val suspendCoroutineUninterceptedOrReturn: IrSimpleFunctionSymbol
+ abstract val suspendCoroutineUninterceptedOrReturn: IrSimpleFunction
- abstract val coroutineGetContext: IrSimpleFunctionSymbol
+ abstract val coroutineGetContext: IrSimpleFunction
- abstract val returnIfSuspended: IrSimpleFunctionSymbol
+ abstract val returnIfSuspended: IrSimpleFunction
- private val binaryOperatorCache = mutableMapOf<Triple<Name, KotlinType, KotlinType>, IrSimpleFunctionSymbol>()
+ private val binaryOperatorCache = mutableMapOf<Triple<Name, KotlinType, KotlinType>, IrSimpleFunction>()
- fun getBinaryOperator(name: Name, lhsType: KotlinType, rhsType: KotlinType): IrSimpleFunctionSymbol {
+ fun getBinaryOperator(name: Name, lhsType: KotlinType, rhsType: KotlinType): IrSimpleFunction {
val key = Triple(name, lhsType, rhsType)
return binaryOperatorCache.getOrPut(key) {
symbolTable.referenceSimpleFunction(
lhsType.memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
.first { it.valueParameters.size == 1 && it.valueParameters[0].type == rhsType }
- )
+ ).owner
}
}
- private val unaryOperatorCache = mutableMapOf<Pair<Name, KotlinType>, IrSimpleFunctionSymbol>()
+ private val unaryOperatorCache = mutableMapOf<Pair<Name, KotlinType>, IrSimpleFunction>()
- fun getUnaryOperator(name: Name, receiverType: KotlinType): IrSimpleFunctionSymbol {
+ fun getUnaryOperator(name: Name, receiverType: KotlinType): IrSimpleFunction {
val key = name to receiverType
return unaryOperatorCache.getOrPut(key) {
symbolTable.referenceSimpleFunction(
receiverType.memberScope.getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
.first { it.valueParameters.isEmpty() }
- )
+ ).owner
}
}
val intAnd = getBinaryOperator(OperatorNameConventions.AND, builtIns.intType, builtIns.intType)
val intPlusInt = getBinaryOperator(OperatorNameConventions.PLUS, builtIns.intType, builtIns.intType)
- open fun functionN(n: Int): IrClassSymbol = symbolTable.referenceClass(builtIns.getFunction(n))
- open fun suspendFunctionN(n: Int): IrClassSymbol = symbolTable.referenceClass(builtIns.getSuspendFunction(n))
+ open fun functionN(n: Int): IrClass = symbolTable.referenceClass(builtIns.getFunction(n))
+ open fun suspendFunctionN(n: Int): IrClass = symbolTable.referenceClass(builtIns.getSuspendFunction(n))
val extensionToString = getSimpleFunction(Name.identifier("toString")) {
it.dispatchReceiverParameter == null && it.extensionReceiverParameter != null &&
@@ -240,22 +235,20 @@
}
companion object {
- fun isLateinitIsInitializedPropertyGetter(symbol: IrFunctionSymbol): Boolean =
- symbol is IrSimpleFunctionSymbol && symbol.owner.let { function ->
- function.name.asString() == "<get-isInitialized>" &&
- function.isTopLevel &&
- function.getPackageFragment()!!.fqName.asString() == "kotlin" &&
- function.valueParameters.isEmpty() &&
- symbol.owner.extensionReceiverParameter?.type?.classOrNull?.owner.let { receiverClass ->
- receiverClass?.fqNameWhenAvailable?.toUnsafe() == KotlinBuiltIns.FQ_NAMES.kProperty0
- }
- }
+ fun isLateinitIsInitializedPropertyGetter(function: IrFunction): Boolean =
+ function is IrSimpleFunction &&
+ function.name.asString() == "<get-isInitialized>" &&
+ function.isTopLevel &&
+ function.getPackageFragment()!!.fqName.asString() == "kotlin" &&
+ function.valueParameters.isEmpty() &&
+ function.extensionReceiverParameter?.type?.classOrNull?.owner.let { receiverClass ->
+ receiverClass?.fqNameWhenAvailable?.toUnsafe() == KotlinBuiltIns.FQ_NAMES.kProperty0
+ }
- fun isTypeOfIntrinsic(symbol: IrFunctionSymbol): Boolean =
- symbol is IrSimpleFunctionSymbol && symbol.owner.let { function ->
- function.name.asString() == "typeOf" &&
- function.valueParameters.isEmpty() &&
- (function.parent as? IrPackageFragment)?.fqName == KOTLIN_REFLECT_FQ_NAME
- }
+ fun isTypeOfIntrinsic(function: IrFunction): Boolean =
+ function is IrSimpleFunction &&
+ function.name.asString() == "typeOf" &&
+ function.valueParameters.isEmpty() &&
+ (function.parent as? IrPackageFragment)?.fqName == KOTLIN_REFLECT_FQ_NAME
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt
index cb23885..de8cbc4 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrInlineUtils.kt
@@ -27,7 +27,7 @@
if (this !is IrBlock || statements.size != 2)
return null
val (function, reference) = statements
- if (function !is IrSimpleFunction || reference !is IrFunctionReference || function.symbol != reference.symbol)
+ if (function !is IrSimpleFunction || reference !is IrFunctionReference || function != reference.target)
return null
if ((0 until reference.valueArgumentsCount).any { reference.getValueArgument(it) != null })
return null
@@ -42,11 +42,11 @@
require(body != null)
val argumentMap = valueParameters.zip(arguments).toMap()
val blockSymbol = IrReturnableBlockSymbolImpl(descriptor)
- val block = IrReturnableBlockImpl(startOffset, endOffset, returnType, blockSymbol, null, symbol)
+ val block = IrReturnableBlockImpl(startOffset, endOffset, returnType, blockSymbol, null, this)
val remapper = object : VariableRemapper(argumentMap) {
override fun visitReturn(expression: IrReturn): IrExpression = super.visitReturn(
- if (expression.returnTargetSymbol == symbol)
- IrReturnImpl(expression.startOffset, expression.endOffset, expression.type, blockSymbol, expression.value)
+ if (expression.irReturnTarget == this@inline)
+ IrReturnImpl(expression.startOffset, expression.endOffset, expression.type, block, expression.value)
else
expression
)
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt
index 7887bee..2fe2e62 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt
@@ -83,26 +83,26 @@
listOf(
IrDelegatingConstructorCallImpl(
startOffset, endOffset, irBuiltIns.unitType,
- superConstructor.symbol, superConstructor.descriptor,
+ superConstructor, superConstructor.descriptor,
0, superConstructor.valueParameters.size
).apply {
constructor.valueParameters.forEachIndexed { idx, parameter ->
- putValueArgument(idx, IrGetValueImpl(startOffset, endOffset, parameter.type, parameter.symbol))
+ putValueArgument(idx, IrGetValueImpl(startOffset, endOffset, parameter.type, parameter))
}
},
- IrInstanceInitializerCallImpl(startOffset, endOffset, this.symbol, irBuiltIns.unitType)
+ IrInstanceInitializerCallImpl(startOffset, endOffset, this, irBuiltIns.unitType)
)
)
}
}
-val IrCall.isSuspend get() = (symbol.owner as? IrSimpleFunction)?.isSuspend == true
-val IrFunctionReference.isSuspend get() = (symbol.owner as? IrSimpleFunction)?.isSuspend == true
+val IrCall.isSuspend get() = (target as? IrSimpleFunction)?.isSuspend == true
+val IrFunctionReference.isSuspend get() = (target as? IrSimpleFunction)?.isSuspend == true
val IrSimpleFunction.isOverridable: Boolean
get() = visibility != Visibilities.PRIVATE && modality != Modality.FINAL && (parent as? IrClass)?.isFinalClass != true
-val IrSimpleFunction.isOverridableOrOverrides: Boolean get() = isOverridable || overriddenSymbols.isNotEmpty()
+val IrSimpleFunction.isOverridableOrOverrides: Boolean get() = isOverridable || overridden.isNotEmpty()
fun IrReturnTarget.returnType(context: CommonBackendContext) =
when (this) {
@@ -117,9 +117,8 @@
// For an annotation, get the annotation class.
fun IrCall.getAnnotationClass(): IrClass {
- val callable = symbol.owner
- assert(callable is IrConstructor) { "Constructor call expected, got ${ir2string(this)}" }
- val annotationClass = callable.parentAsClass
+ assert(target is IrConstructor) { "Constructor call expected, got ${ir2string(this)}" }
+ val annotationClass = target.parentAsClass
assert(annotationClass.isAnnotationClass) { "Annotation class expected, got ${ir2string(annotationClass)}" }
return annotationClass
}
@@ -365,7 +364,7 @@
IrValueParameterSymbolImpl(thisReceiverDescriptor),
Name.identifier("<this>"),
index = -1,
- type = this.symbol.typeWith(this.typeParameters.map { it.defaultType }),
+ type = this.typeWith(this.typeParameters.map { it.defaultType }),
varargElementType = null,
isCrossinline = false,
isNoinline = false
@@ -450,7 +449,7 @@
val overriddenFunctions = declarations
.flatMap { it.toList() }
- .flatMap { it.overriddenSymbols.map { it.owner } }
+ .flatMap { it.overridden }
.toSet()
val unoverriddenSuperFunctions = superTypes
@@ -485,7 +484,7 @@
).apply {
descriptor.bind(this)
parent = this@addFakeOverrides
- overriddenSymbols += overriddenFunctions.map { it.symbol }
+ overridden += overriddenFunctions
copyParameterDeclarationsFrom(irFunction)
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/SharedVariablesManager.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/SharedVariablesManager.kt
index 6eb4043..8368cf2 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/SharedVariablesManager.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/SharedVariablesManager.kt
@@ -10,14 +10,13 @@
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.IrSetVariable
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
interface SharedVariablesManager {
fun declareSharedVariable(originalDeclaration: IrVariable): IrVariable
fun defineSharedValue(originalDeclaration: IrVariable, sharedVariableDeclaration: IrVariable): IrStatement
- fun getSharedValue(sharedVariableSymbol: IrVariableSymbol, originalGet: IrGetValue): IrExpression
+ fun getSharedValue(sharedVariable: IrVariable, originalGet: IrGetValue): IrExpression
- fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetVariable): IrExpression
+ fun setSharedValue(sharedVariable: IrVariable, originalSet: IrSetVariable): IrExpression
}
\ No newline at end of file
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt
index b68e3ca..15da1fa 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt
@@ -23,16 +23,12 @@
import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
-import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.types.classifierOrFail
+import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
-import org.jetbrains.kotlin.ir.types.typeWith
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.visitors.*
import org.jetbrains.kotlin.name.Name
@@ -43,7 +39,7 @@
protected object DECLARATION_ORIGIN_COROUTINE_IMPL : IrDeclarationOriginImpl("COROUTINE_IMPL")
protected abstract val stateMachineMethodName: Name
- protected abstract fun getCoroutineBaseClass(function: IrFunction): IrClassSymbol
+ protected abstract fun getCoroutineBaseClass(function: IrFunction): IrClass
protected abstract fun nameForCoroutineClass(function: IrFunction): Name
protected abstract fun buildStateMachine(
@@ -84,7 +80,7 @@
// Suppress since it is used in native
@Suppress("MemberVisibilityCanBePrivate")
protected fun IrCall.isReturnIfSuspendedCall() =
- symbol.owner.run { fqNameWhenAvailable == context.internalPackageFqn.child(Name.identifier("returnIfSuspended")) }
+ target.run { fqNameWhenAvailable == context.internalPackageFqn.child(Name.identifier("returnIfSuspended")) }
private fun tryTransformSuspendFunction(element: IrElement) =
if (element is IrSimpleFunction && element.isSuspend && element.modality != Modality.ABSTRACT)
@@ -101,7 +97,7 @@
expression.acceptChildrenVoid(this)
if (expression.isSuspend) {
- suspendLambdas[expression.symbol.owner] = expression
+ suspendLambdas[expression.target] = expression
}
}
})
@@ -115,16 +111,16 @@
if (!expression.isSuspend)
return expression
- val coroutine = builtCoroutines[expression.symbol.owner]
+ val coroutine = builtCoroutines[expression.target]
?: throw Error("Non-local callable reference to suspend lambda: $expression")
val constructorParameters = coroutine.coroutineConstructor.valueParameters
val expressionArguments = expression.getArguments().map { it.second }
assert(constructorParameters.size == expressionArguments.size) {
"Inconsistency between callable reference to suspend lambda and the corresponding coroutine"
}
- val irBuilder = context.createIrBuilder(expression.symbol, expression.startOffset, expression.endOffset)
+ val irBuilder = context.createIrBuilder(expression.target, expression.startOffset, expression.endOffset)
irBuilder.run {
- return irCall(coroutine.coroutineConstructor.symbol).apply {
+ return irCall(coroutine.coroutineConstructor).apply {
expressionArguments.forEachIndexed { index, argument ->
putValueArgument(index, argument)
}
@@ -215,15 +211,15 @@
}
private val symbols = context.ir.symbols
- private val getContinuationSymbol = symbols.getContinuation
- private val continuationClassSymbol = getContinuationSymbol.owner.returnType.classifierOrFail as IrClassSymbol
+ private val getContinuation = symbols.getContinuation
+ private val continuationClass = getContinuation.returnType.getClass()!!
private fun removeReturnIfSuspendedCallAndSimplifyDelegatingCall(irFunction: IrFunction, delegatingCall: IrCall) {
val returnValue =
if (delegatingCall.isReturnIfSuspendedCall())
delegatingCall.getValueArgument(0)!!
else delegatingCall
- context.createIrBuilder(irFunction.symbol).run {
+ context.createIrBuilder(irFunction).run {
val statements = (irFunction.body as IrBlockBody).statements
val lastStatement = statements.last()
assert(lastStatement == delegatingCall || lastStatement is IrReturn) { "Unexpected statement $lastStatement" }
@@ -237,11 +233,11 @@
if (functionReference == null) {
// It is not a lambda - replace original function with a call to constructor of the built coroutine.
- val irBuilder = context.createIrBuilder(irFunction.symbol, irFunction.startOffset, irFunction.endOffset)
+ val irBuilder = context.createIrBuilder(irFunction, irFunction.startOffset, irFunction.endOffset)
irFunction.body = irBuilder.irBlockBody(irFunction) {
val constructor = coroutine.coroutineConstructor
generateCoroutineStart(coroutine.stateMachineFunction,
- irCallConstructor(constructor.symbol, irFunction.typeParameters.map {
+ irCallConstructor(constructor, irFunction.typeParameters.map {
IrSimpleTypeImpl(it.symbol, true, emptyList(), emptyList())
}).apply {
val functionParameters = irFunction.explicitParameters
@@ -251,8 +247,8 @@
putValueArgument(
functionParameters.size,
irCall(
- getContinuationSymbol,
- getContinuationSymbol.owner.returnType,
+ getContinuation,
+ getContinuation.returnType,
listOf(irFunction.returnType)
)
)
@@ -302,7 +298,7 @@
}
private val coroutineClassThis = coroutineClass.thisReceiver!!
- private val continuationType = continuationClassSymbol.typeWith(irFunction.returnType)
+ private val continuationType = continuationClass.typeWith(irFunction.returnType)
// Save all arguments to fields.
private val argumentToPropertiesMap = functionParameters.associate {
@@ -310,15 +306,15 @@
}
private val coroutineBaseClass = getCoroutineBaseClass(irFunction)
- private val coroutineBaseClassConstructor = coroutineBaseClass.owner.constructors.single { it.valueParameters.size == 1 }
- private val create1Function = coroutineBaseClass.owner.simpleFunctions()
+ private val coroutineBaseClassConstructor = coroutineBaseClass.constructors.single { it.valueParameters.size == 1 }
+ private val create1Function = coroutineBaseClass.simpleFunctions()
.single { it.name.asString() == "create" && it.valueParameters.size == 1 }
private val create1CompletionParameter = create1Function.valueParameters[0]
private val coroutineConstructors = mutableListOf<IrConstructor>()
fun build(): BuiltCoroutine {
- val superTypes = mutableListOf(coroutineBaseClass.owner.defaultType)
+ val superTypes = mutableListOf(coroutineBaseClass.defaultType)
var suspendFunctionClass: IrClass? = null
var functionClass: IrClass? = null
val suspendFunctionClassTypeArguments: List<IrType>?
@@ -326,19 +322,19 @@
if (unboundFunctionParameters != null) {
// Suspend lambda inherits SuspendFunction.
val numberOfParameters = unboundFunctionParameters.size
- suspendFunctionClass = symbols.suspendFunctionN(numberOfParameters).owner
+ suspendFunctionClass = symbols.suspendFunctionN(numberOfParameters)
val unboundParameterTypes = unboundFunctionParameters.map { it.type }
suspendFunctionClassTypeArguments = unboundParameterTypes + irFunction.returnType
superTypes += suspendFunctionClass.typeWith(suspendFunctionClassTypeArguments)
- functionClass = symbols.functionN(numberOfParameters + 1).owner
+ functionClass = symbols.functionN(numberOfParameters + 1)
functionClassTypeArguments = unboundParameterTypes + continuationType + context.irBuiltIns.anyNType
superTypes += functionClass.typeWith(functionClassTypeArguments)
}
val coroutineConstructor = buildConstructor()
- val superInvokeSuspendFunction = coroutineBaseClass.owner.simpleFunctions().single { it.name == stateMachineMethodName }
+ val superInvokeSuspendFunction = coroutineBaseClass.simpleFunctions().single { it.name == stateMachineMethodName }
val invokeSuspendMethod = buildInvokeSuspendMethod(superInvokeSuspendFunction, coroutineClass)
var coroutineFactoryConstructor: IrConstructor? = null
@@ -347,24 +343,23 @@
// Suspend lambda - create factory methods.
coroutineFactoryConstructor = buildFactoryConstructor(boundFunctionParameters!!)
- val createFunctionSymbol = coroutineBaseClass.owner.simpleFunctions()
+ val createFunction = coroutineBaseClass.simpleFunctions()
.atMostOne { it.name.asString() == "create" && it.valueParameters.size == unboundFunctionParameters!!.size + 1 }
- ?.symbol
createMethod = buildCreateMethod(
unboundArgs = unboundFunctionParameters!!,
- superFunctionSymbol = createFunctionSymbol,
+ superFunction = createFunction,
coroutineConstructor = coroutineConstructor
)
- val invokeFunctionSymbol =
- functionClass!!.simpleFunctions().single { it.name.asString() == "invoke" }.symbol
- val suspendInvokeFunctionSymbol =
- suspendFunctionClass!!.simpleFunctions().single { it.name.asString() == "invoke" }.symbol
+ val invokeFunction =
+ functionClass!!.simpleFunctions().single { it.name.asString() == "invoke" }
+ val suspendInvokeFunction =
+ suspendFunctionClass!!.simpleFunctions().single { it.name.asString() == "invoke" }
buildInvokeMethod(
- suspendFunctionInvokeFunctionSymbol = suspendInvokeFunctionSymbol,
- functionInvokeFunctionSymbol = invokeFunctionSymbol,
+ suspendFunctionInvokeFunction = suspendInvokeFunction,
+ functionInvokeFunction = invokeFunction,
createFunction = createMethod,
stateMachineFunction = invokeSuspendMethod
)
@@ -414,7 +409,7 @@
+irDelegatingConstructorCall(coroutineBaseClassConstructor).apply {
putValueArgument(0, irGet(completionParameter))
}
- +IrInstanceInitializerCallImpl(startOffset, endOffset, coroutineClass.symbol, context.irBuiltIns.unitType)
+ +IrInstanceInitializerCallImpl(startOffset, endOffset, coroutineClass, context.irBuiltIns.unitType)
functionParameters.forEachIndexed { index, parameter ->
+irSetField(
@@ -454,7 +449,7 @@
putValueArgument(0, irNull()) // Completion.
}
+IrInstanceInitializerCallImpl(
- startOffset, endOffset, coroutineClass.symbol,
+ startOffset, endOffset, coroutineClass,
context.irBuiltIns.unitType
)
// Save all arguments to fields.
@@ -470,7 +465,7 @@
private fun buildCreateMethod(
unboundArgs: List<IrValueParameter>,
- superFunctionSymbol: IrSimpleFunctionSymbol?,
+ superFunction: IrSimpleFunction?,
coroutineConstructor: IrConstructor
) = WrappedSimpleFunctionDescriptor().let { d ->
IrFunctionImpl(
@@ -502,9 +497,9 @@
this.createDispatchReceiverParameter()
- superFunctionSymbol?.let {
- overriddenSymbols += it.owner.overriddenSymbols
- overriddenSymbols += it
+ superFunction?.let {
+ overridden += it.overridden
+ overridden += it
}
val thisReceiver = this.dispatchReceiverParameter!!
@@ -533,8 +528,8 @@
}
private fun buildInvokeMethod(
- suspendFunctionInvokeFunctionSymbol: IrSimpleFunctionSymbol,
- functionInvokeFunctionSymbol: IrSimpleFunctionSymbol,
+ suspendFunctionInvokeFunction: IrSimpleFunction,
+ functionInvokeFunction: IrSimpleFunction,
createFunction: IrFunction,
stateMachineFunction: IrFunction
) = WrappedSimpleFunctionDescriptor().let { d ->
@@ -569,8 +564,8 @@
this.createDispatchReceiverParameter()
- overriddenSymbols += functionInvokeFunctionSymbol
- overriddenSymbols += suspendFunctionInvokeFunctionSymbol
+ overridden += functionInvokeFunction
+ overridden += suspendFunctionInvokeFunction
val thisReceiver = dispatchReceiverParameter!!
@@ -583,7 +578,7 @@
}
putValueArgument(
valueParameters.size,
- irCall(getContinuationSymbol, getContinuationSymbol.owner.returnType, listOf(returnType))
+ irCall(getContinuation, getContinuation.returnType, listOf(returnType))
)
})
}
@@ -623,7 +618,7 @@
this.createDispatchReceiverParameter()
- overriddenSymbols += stateMachineFunction.symbol
+ overridden += stateMachineFunction
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt
index 994c2a5..52630af 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt
@@ -10,10 +10,6 @@
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrStringConcatenationImpl
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
-import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
-import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -49,10 +45,10 @@
this.useAsValue(parameter)
protected open fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression): IrExpression =
- this.useAsArgument(expression.symbol.owner.dispatchReceiverParameter!!)
+ this.useAsArgument(expression.target.dispatchReceiverParameter!!)
protected open fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression): IrExpression =
- this.useAsArgument(expression.symbol.owner.extensionReceiverParameter!!)
+ this.useAsArgument(expression.target.extensionReceiverParameter!!)
protected open fun IrExpression.useAsValueArgument(
expression: IrFunctionAccessExpression,
@@ -66,11 +62,11 @@
private fun IrExpression.useForField(field: IrField): IrExpression =
this.useAs(field.type)
- protected open fun IrExpression.useAsReturnValue(returnTarget: IrReturnTargetSymbol): IrExpression =
+ protected open fun IrExpression.useAsReturnValue(returnTarget: IrReturnTarget): IrExpression =
when (returnTarget) {
- is IrSimpleFunctionSymbol -> this.useAs(returnTarget.owner.returnType)
- is IrConstructorSymbol -> this.useAs(irBuiltIns.unitType)
- is IrReturnableBlockSymbol -> this.useAs(returnTarget.owner.type)
+ is IrSimpleFunction -> this.useAs(returnTarget.returnType)
+ is IrConstructor -> this.useAs(irBuiltIns.unitType)
+ is IrReturnableBlock -> this.useAs(returnTarget.type)
else -> error(returnTarget)
}
@@ -99,7 +95,7 @@
extensionReceiver = extensionReceiver?.useAsExtensionReceiver(expression)
for (index in descriptor.valueParameters.indices) {
val argument = getValueArgument(index) ?: continue
- val parameter = symbol.owner.valueParameters[index]
+ val parameter = target.valueParameters[index]
putValueArgument(index, argument.useAsValueArgument(expression, parameter))
}
}
@@ -143,7 +139,7 @@
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid(this)
- expression.value = expression.value.useAsReturnValue(expression.returnTargetSymbol)
+ expression.value = expression.value.useAsReturnValue(expression.irReturnTarget)
return expression
}
@@ -151,7 +147,7 @@
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
expression.transformChildrenVoid(this)
- expression.value = expression.value.useForVariable(expression.symbol.owner)
+ expression.value = expression.value.useForVariable(expression.target)
return expression
}
@@ -159,7 +155,7 @@
override fun visitSetField(expression: IrSetField): IrExpression {
expression.transformChildrenVoid(this)
- expression.value = expression.value.useForField(expression.symbol.owner)
+ expression.value = expression.value.useForField(expression.target)
return expression
}
@@ -261,7 +257,7 @@
declaration.body?.let {
if (it is IrExpressionBody) {
- it.expression = it.expression.useAsReturnValue(declaration.symbol)
+ it.expression = it.expression.useAsReturnValue(declaration)
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ArrayConstructorLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ArrayConstructorLowering.kt
index 2ec7f11..5d0cb71 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ArrayConstructorLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ArrayConstructorLowering.kt
@@ -13,11 +13,11 @@
import org.jetbrains.kotlin.ir.builders.*
import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.types.getClass
import org.jetbrains.kotlin.ir.types.toKotlinType
import org.jetbrains.kotlin.ir.util.constructedClass
@@ -33,12 +33,12 @@
}
// Array(size, init) -> Array(size)
- private fun arrayInlineToSizeConstructor(irConstructor: IrConstructor): IrFunctionSymbol? {
- val clazz = irConstructor.constructedClass.symbol
+ private fun arrayInlineToSizeConstructor(irConstructor: IrConstructor): IrFunction? {
+ val clazz = irConstructor.constructedClass
return when {
irConstructor.valueParameters.size != 2 -> null
- clazz == context.irBuiltIns.arrayClass -> context.ir.symbols.arrayOfNulls // Array<T> has no unary constructor: it can only exist for Array<T?>
- context.irBuiltIns.primitiveArrays.contains(clazz) -> clazz.constructors.single { it.owner.valueParameters.size == 1 }
+ clazz == context.irBuiltIns.arrayClass.owner -> context.ir.symbols.arrayOfNulls // Array<T> has no unary constructor: it can only exist for Array<T?>
+ context.irBuiltIns.primitiveArrays.contains(clazz.symbol) -> clazz.constructors.single { it.valueParameters.size == 1 }
else -> null
}
}
@@ -53,7 +53,7 @@
}
override fun visitConstructorCall(expression: IrConstructorCall): IrExpression {
- val sizeConstructor = arrayInlineToSizeConstructor(expression.symbol.owner)
+ val sizeConstructor = arrayInlineToSizeConstructor(expression.target)
?: return super.visitConstructorCall(expression)
// inline fun <reified T> Array(size: Int, invokable: (Int) -> T): Array<T> {
// val result = arrayOfNulls<T>(size)
@@ -66,7 +66,7 @@
val size = expression.getValueArgument(0)!!.transform(this, null)
val invokable = expression.getValueArgument(1)!!.transform(this, null)
val scope = currentScope!!.scope
- return context.createIrBuilder(scope.scopeOwnerSymbol).irBlock(expression.startOffset, expression.endOffset) {
+ return context.createIrBuilder(scope.irScopeOwner).irBlock(expression.startOffset, expression.endOffset) {
val index = irTemporaryVar(irInt(0))
val sizeVar = irTemporary(size)
val result = irTemporary(irCall(sizeConstructor, expression.type).apply {
@@ -85,7 +85,7 @@
body = irBlock {
val tempIndex = irTemporary(irGet(index))
val value = lambda?.inline(listOf(tempIndex)) ?: irCallOp(
- invoke.symbol,
+ invoke,
invoke.returnType,
irGet(invokableVar!!),
irGet(tempIndex)
@@ -96,7 +96,7 @@
putValueArgument(1, value)
}
val inc = index.type.getClass()!!.functions.single { it.name == OperatorNameConventions.INC }
- +irSetVar(index.symbol, irCallOp(inc.symbol, index.type, irGet(index)))
+ +irSetVar(index, irCallOp(inc, index.type, irGet(index)))
}
}
+irGet(result)
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt
index 80f5f28..a5c8614 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ClosureAnnotator.kt
@@ -26,13 +26,12 @@
import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.util.isLocal
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
import kotlin.collections.set
-class Closure(val capturedValues: List<IrValueSymbol> = emptyList())
+class Closure(val capturedValues: List<IrValueDeclaration> = emptyList())
class ClosureAnnotator(irFile: IrFile) {
private val closureBuilders = mutableMapOf<IrDeclaration, ClosureBuilder>()
@@ -53,7 +52,7 @@
}
private class ClosureBuilder(val owner: IrDeclaration) {
- val capturedValues = mutableSetOf<IrValueSymbol>()
+ val capturedValues = mutableSetOf<IrValueDeclaration>()
private val declaredValues = mutableSetOf<IrValueDeclaration>()
private val includes = mutableSetOf<ClosureBuilder>()
@@ -65,11 +64,11 @@
* variables declared in the node.
*/
fun buildClosure(): Closure {
- val result = mutableSetOf<IrValueSymbol>().apply { addAll(capturedValues) }
+ val result = mutableSetOf<IrValueDeclaration>().apply { addAll(capturedValues) }
includes.forEach { builder ->
if (!builder.processed) {
builder.processed = true
- builder.buildClosure().capturedValues.filterTo(result) { isExternal(it.owner) }
+ builder.buildClosure().capturedValues.filterTo(result) { isExternal(it) }
}
}
// TODO: We can save the closure and reuse it.
@@ -86,8 +85,8 @@
declaredValues.add(valueDeclaration)
}
- fun seeVariable(value: IrValueSymbol) {
- if (isExternal(value.owner))
+ fun seeVariable(value: IrValueDeclaration) {
+ if (isExternal(value))
capturedValues.add(value)
}
@@ -162,7 +161,7 @@
}
override fun visitVariableAccess(expression: IrValueAccessExpression) {
- closuresStack.peek()?.seeVariable(expression.symbol)
+ closuresStack.peek()?.seeVariable(expression.target)
super.visitVariableAccess(expression)
}
@@ -173,18 +172,18 @@
override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
super.visitFunctionAccess(expression)
- processMemberAccess(expression.symbol.owner)
+ processMemberAccess(expression.target)
}
override fun visitFunctionReference(expression: IrFunctionReference) {
super.visitFunctionReference(expression)
- processMemberAccess(expression.symbol.owner)
+ processMemberAccess(expression.target)
}
override fun visitPropertyReference(expression: IrPropertyReference) {
super.visitPropertyReference(expression)
- expression.getter?.let { processMemberAccess(it.owner) }
- expression.setter?.let { processMemberAccess(it.owner) }
+ expression.getter?.let { processMemberAccess(it) }
+ expression.setter?.let { processMemberAccess(it) }
}
private fun processMemberAccess(declaration: IrDeclaration) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt
index a0aa64e..5fd462ed 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt
@@ -17,8 +17,6 @@
import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
@@ -69,7 +67,7 @@
irFunction.generateDefaultsFunction(context, IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER, skipInlineMethods, skipExternalMethods)
log { "$irFunction -> $newIrFunction" }
- val builder = context.createIrBuilder(newIrFunction.symbol)
+ val builder = context.createIrBuilder(newIrFunction)
newIrFunction.body = builder.irBlockBody(newIrFunction) {
val params = mutableListOf<IrVariable>()
@@ -87,7 +85,7 @@
val parameter = newIrFunction.valueParameters[valueParameter.index]
val argument = if (valueParameter.defaultValue != null) {
- val kIntAnd = symbols.intAnd.owner
+ val kIntAnd = symbols.intAnd
val condition = irNotEquals(irCall(kIntAnd).apply {
dispatchReceiver = irGet(maskParameter(newIrFunction, valueParameter.index / 32))
putValueArgument(0, irInt(1 shl (valueParameter.index % 32)))
@@ -98,9 +96,9 @@
expressionBody.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrExpression {
- log { "GetValue: ${expression.symbol.owner}" }
- val valueSymbol = variables[expression.symbol.owner] ?: return expression
- return irGet(valueSymbol)
+ log { "GetValue: ${expression.target}" }
+ val value = variables[expression.target] ?: return expression
+ return irGet(value)
}
})
@@ -126,7 +124,7 @@
startOffset = irFunction.startOffset,
endOffset = irFunction.endOffset,
type = context.irBuiltIns.unitType,
- symbol = irFunction.symbol, descriptor = irFunction.symbol.descriptor,
+ target = irFunction, descriptor = irFunction.descriptor,
typeArgumentsCount = newIrFunction.parentAsClass.typeParameters.size + newIrFunction.typeParameters.size
).apply {
passTypeArgumentsFrom(newIrFunction.parentAsClass)
@@ -153,7 +151,7 @@
newIrFunction: IrFunction,
params: MutableList<IrVariable>
): IrExpression {
- val dispatchCall = irCall(irFunction.symbol).apply {
+ val dispatchCall = irCall(irFunction).apply {
passTypeArgumentsFrom(newIrFunction)
dispatchReceiver = newIrFunction.dispatchReceiverParameter?.let { irGet(it) }
extensionReceiver = newIrFunction.extensionReceiverParameter?.let { irGet(it) }
@@ -213,9 +211,9 @@
private fun visitFunctionAccessExpression(
expression: IrFunctionAccessExpression,
- builder: (IrFunctionSymbol) -> IrFunctionAccessExpression
+ builder: (IrFunction) -> IrFunctionAccessExpression
): IrExpression {
- val functionDeclaration = expression.symbol.owner
+ val functionDeclaration = expression.target
if (!functionDeclaration.needsDefaultArgumentsLowering(skipInline, skipExternalMethods))
return expression
@@ -224,16 +222,15 @@
if (argumentsCount == functionDeclaration.valueParameters.size)
return expression
- val (symbol, params) = parametersForCall(expression)
- val descriptor = symbol.descriptor
- val declaration = symbol.owner
+ val (declaration, params) = parametersForCall(expression)
+ val descriptor = declaration.descriptor
for (i in 0 until expression.typeArgumentsCount) {
log { "$descriptor [$i]: $expression.getTypeArgument(i)" }
}
declaration.typeParameters.forEach { log { "$declaration[${it.index}] : $it" } }
- return builder(symbol).apply {
+ return builder(declaration).apply {
this.copyTypeArgumentsFrom(expression)
params.forEach {
@@ -257,7 +254,7 @@
startOffset = expression.startOffset,
endOffset = expression.endOffset,
type = context.irBuiltIns.unitType,
- symbol = it as IrConstructorSymbol,
+ target = it as IrConstructor,
descriptor = it.descriptor,
typeArgumentsCount = expression.typeArgumentsCount
)
@@ -272,7 +269,7 @@
expression.startOffset,
expression.endOffset,
expression.type,
- it as IrConstructorSymbol,
+ it as IrConstructor,
DEFAULT_DISPATCH_CALL
)
}
@@ -286,7 +283,7 @@
expression.startOffset,
expression.endOffset,
expression.type,
- it as IrConstructorSymbol
+ it as IrConstructor
)
}
}
@@ -299,11 +296,11 @@
startOffset = expression.startOffset,
endOffset = expression.endOffset,
type = expression.type,
- symbol = it,
+ target = it,
descriptor = it.descriptor,
typeArgumentsCount = expression.typeArgumentsCount,
origin = DEFAULT_DISPATCH_CALL,
- superQualifierSymbol = expression.superQualifierSymbol
+ irSuperQualifier = expression.irSuperQualifier
)
}
}
@@ -313,8 +310,8 @@
if (this !is IrSimpleFunction) return this
- for (s in overriddenSymbols) {
- s.owner.findSuperMethodWithDefaultArguments()?.let { return it }
+ for (s in overridden) {
+ s.findSuperMethodWithDefaultArguments()?.let { return it }
}
return this
@@ -322,8 +319,8 @@
private fun parametersForCall(
expression: IrFunctionAccessExpression
- ): Pair<IrFunctionSymbol, List<Pair<IrValueParameter, IrExpression?>>> {
- val declaration = expression.symbol.owner
+ ): Pair<IrFunction, List<Pair<IrValueParameter, IrExpression?>>> {
+ val declaration = expression.target
val keyFunction = declaration.findSuperMethodWithDefaultArguments()!!
val realFunction =
@@ -358,7 +355,7 @@
value = maskValue
)
}
- if (expression.symbol is IrConstructorSymbol) {
+ if (expression.target is IrConstructor) {
params += markerParameterDeclaration(realFunction) to
IrConstImpl.constNull(startOffset, endOffset, context.irBuiltIns.nothingNType)
} else if (context.ir.shouldGenerateHandlerParameterForDefaultBodyFun()) {
@@ -368,7 +365,7 @@
params.forEach {
log { "descriptor::${realFunction.name.asString()}#${it.first.index}: ${it.first.name.asString()}" }
}
- return Pair(realFunction.symbol, params)
+ return Pair(realFunction, params)
}
private fun argumentCount(expression: IrMemberAccessExpression): Int {
@@ -416,7 +413,7 @@
if (this !is IrSimpleFunction) return false
fun IrSimpleFunction.inheritsDefaultValues(): Boolean =
- valueParameters.any { it.defaultValue != null } || overriddenSymbols.any { it.owner.inheritsDefaultValues() }
+ valueParameters.any { it.defaultValue != null } || overridden.any { it.inheritsDefaultValues() }
return inheritsDefaultValues()
}
@@ -437,7 +434,7 @@
syntheticParameters += newFunction.valueParameter(
syntheticParameters.last().index + 1,
kConstructorMarkerName,
- context.ir.symbols.defaultConstructorMarker.owner.defaultType
+ context.ir.symbols.defaultConstructorMarker.defaultType
)
} else if (context.ir.shouldGenerateHandlerParameterForDefaultBodyFun()) {
syntheticParameters += newFunction.valueParameter(
@@ -461,8 +458,7 @@
annotations.mapTo(newFunction.annotations) { it.deepCopyWithSymbols() }
if (origin == IrDeclarationOrigin.FAKE_OVERRIDE) {
- for (baseFunSymbol in (this as IrSimpleFunction).overriddenSymbols) {
- val baseFun = baseFunSymbol.owner
+ for (baseFun in (this as IrSimpleFunction).overridden) {
if (baseFun.needsDefaultArgumentsLowering(skipInlineMethods, skipExternalMethods)) {
val baseOrigin = if (baseFun.valueParameters.any { it.defaultValue != null }) {
IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER
@@ -470,7 +466,7 @@
IrDeclarationOrigin.FAKE_OVERRIDE
}
val defaultsBaseFun = baseFun.generateDefaultsFunction(context, baseOrigin, skipInlineMethods, skipExternalMethods)
- (newFunction as IrSimpleFunction).overriddenSymbols.add((defaultsBaseFun as IrSimpleFunction).symbol)
+ (newFunction as IrSimpleFunction).overridden.add(defaultsBaseFun as IrSimpleFunction)
}
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/Desymbolize.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/Desymbolize.kt
index 0fb38e9..44959aa 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/Desymbolize.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/Desymbolize.kt
@@ -5,5 +5,22 @@
package org.jetbrains.kotlin.backend.common.lower
-class Desymbolize {
+import org.jetbrains.kotlin.backend.common.CommonBackendContext
+import org.jetbrains.kotlin.backend.common.FileLoweringPass
+import org.jetbrains.kotlin.backend.common.phaser.makeIrModulePhase
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.util.desymbolize
+
+val desymbolizePhase = makeIrModulePhase(
+ ::Desymbolize,
+ name = "Desymbolize",
+ description = "Replace symbols by their owners in IR structures"
+)
+
+class Desymbolize() : FileLoweringPass {
+ constructor (context: CommonBackendContext) : this()
+
+ override fun lower(irFile: IrFile) {
+ irFile.desymbolize()
+ }
}
\ No newline at end of file
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/EnumWhenLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/EnumWhenLowering.kt
index e623db4..ad4c622 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/EnumWhenLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/EnumWhenLowering.kt
@@ -37,7 +37,7 @@
}
protected open fun mapRuntimeEnumEntry(builder: IrBuilderWithScope, subject: IrExpression): IrExpression =
- builder.irCall(subject.type.getClass()!!.symbol.getPropertyGetter("ordinal")!!).apply { dispatchReceiver = subject }
+ builder.irCall(subject.type.getClass()!!.getPropertyGetter("ordinal")!!).apply { dispatchReceiver = subject }
override fun lower(irFile: IrFile) {
visitFile(irFile)
@@ -59,7 +59,7 @@
// Will be initialized only when we found a branch that compares
// subject with compile-time known enum entry.
val subjectOrdinalProvider = lazy {
- context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, subject.startOffset, subject.endOffset).run {
+ context.createIrBuilder(currentScope!!.scope.irScopeOwner, subject.startOffset, subject.endOffset).run {
val integer = if (subject.type.isNullable())
irIfNull(context.irBuiltIns.intType, irGet(subject), irInt(-1), mapRuntimeEnumEntry(this, irGet(subject)))
else
@@ -81,7 +81,7 @@
override fun visitCall(expression: IrCall): IrExpression {
// We are looking for branch that is a comparison of the subject and another enum entry.
- if (expression.symbol != context.irBuiltIns.eqeqSymbol) {
+ if (expression.target != context.irBuiltIns.eqeqSymbol.owner) {
return super.visitCall(expression)
}
val lhs = expression.getValueArgument(0)!!
@@ -90,20 +90,20 @@
val (topmostSubject, topmostOrdinalProvider) = subjectWithOrdinalStack.peek()
?: return super.visitCall(expression)
val other = when {
- lhs is IrGetValue && lhs.symbol.owner == topmostSubject -> rhs
- rhs is IrGetValue && rhs.symbol.owner == topmostSubject -> lhs
+ lhs is IrGetValue && lhs.target == topmostSubject -> rhs
+ rhs is IrGetValue && rhs.target == topmostSubject -> lhs
else -> return super.visitCall(expression)
}
val entryOrdinal = when {
- other is IrGetEnumValue && topmostSubject.type.classifierOrNull?.owner == other.symbol.owner.parent ->
- mapConstEnumEntry(other.symbol.owner)
+ other is IrGetEnumValue && topmostSubject.type.classifierOrNull?.owner == other.target.parent ->
+ mapConstEnumEntry(other.target)
other.isNullConst() ->
-1
else -> return super.visitCall(expression)
}
val subjectOrdinal = topmostOrdinalProvider.value
- return IrCallImpl(expression.startOffset, expression.endOffset, expression.type, expression.symbol).apply {
- putValueArgument(0, IrGetValueImpl(lhs.startOffset, lhs.endOffset, subjectOrdinal.type, subjectOrdinal.symbol))
+ return IrCallImpl(expression.startOffset, expression.endOffset, expression.type, expression.target).apply {
+ putValueArgument(0, IrGetValueImpl(lhs.startOffset, lhs.endOffset, subjectOrdinal.type, subjectOrdinal))
putValueArgument(1, IrConstImpl.int(rhs.startOffset, rhs.endOffset, context.irBuiltIns.intType, entryOrdinal))
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FinallyBlocksLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FinallyBlocksLowering.kt
index e87789f..92b41e9 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FinallyBlocksLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FinallyBlocksLowering.kt
@@ -31,7 +31,7 @@
fun toIr(context: CommonBackendContext, startOffset: Int, endOffset: Int, value: IrExpression): IrExpression
}
- private data class Return(val target: IrReturnTargetSymbol): HighLevelJump {
+ private data class Return(val target: IrReturnTarget): HighLevelJump {
override fun toIr(context: CommonBackendContext, startOffset: Int, endOffset: Int, value: IrExpression)
=
IrReturnImpl(startOffset, endOffset, context.irBuiltIns.nothingType, target, value)
@@ -111,7 +111,7 @@
override fun visitBreak(jump: IrBreak): IrExpression {
val startOffset = jump.startOffset
val endOffset = jump.endOffset
- val irBuilder = context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, startOffset, endOffset)
+ val irBuilder = context.createIrBuilder(currentScope!!.scope.irScopeOwner, startOffset, endOffset)
return performHighLevelJump(
targetScopePredicate = { it is LoopScope && it.loop == jump.loop },
jump = Break(jump.loop),
@@ -124,7 +124,7 @@
override fun visitContinue(jump: IrContinue): IrExpression {
val startOffset = jump.startOffset
val endOffset = jump.endOffset
- val irBuilder = context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, startOffset, endOffset)
+ val irBuilder = context.createIrBuilder(currentScope!!.scope.irScopeOwner, startOffset, endOffset)
return performHighLevelJump(
targetScopePredicate = { it is LoopScope && it.loop == jump.loop },
jump = Continue(jump.loop),
@@ -138,8 +138,8 @@
expression.transformChildrenVoid(this)
return performHighLevelJump(
- targetScopePredicate = { it is ReturnableScope && it.symbol == expression.returnTargetSymbol },
- jump = Return(expression.returnTargetSymbol),
+ targetScopePredicate = { it is ReturnableScope && it.symbol == expression.irReturnTarget },
+ jump = Return(expression.irReturnTarget),
startOffset = expression.startOffset,
endOffset = expression.endOffset,
value = expression.value
@@ -173,7 +173,7 @@
val currentTryScope = tryScopes[index]
currentTryScope.jumps.getOrPut(jump) {
- val type = (jump as? Return)?.target?.owner?.returnType(context) ?: value.type
+ val type = (jump as? Return)?.target?.returnType(context) ?: value.type
jump.toString()
val symbol = IrReturnableBlockSymbolImpl(WrappedSimpleFunctionDescriptor())
with(currentTryScope) {
@@ -194,7 +194,7 @@
startOffset = startOffset,
endOffset = endOffset,
type = context.irBuiltIns.nothingType,
- returnTargetSymbol = it,
+ irReturnTarget = it,
value = value
)
}
@@ -206,7 +206,7 @@
val startOffset = aTry.startOffset
val endOffset = aTry.endOffset
- val irBuilder = context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, startOffset, endOffset)
+ val irBuilder = context.createIrBuilder(currentScope!!.scope.irScopeOwner, startOffset, endOffset)
val transformer = this
irBuilder.run {
val transformedFinallyExpression = finallyExpression.transform(transformer, null)
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FlattenStringConcatenationLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FlattenStringConcatenationLowering.kt
index b49bb15..4afa274 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FlattenStringConcatenationLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/FlattenStringConcatenationLowering.kt
@@ -16,7 +16,6 @@
import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
import org.jetbrains.kotlin.ir.expressions.impl.IrStringConcatenationImpl
import org.jetbrains.kotlin.ir.types.isStringClassType
-import org.jetbrains.kotlin.ir.util.fqNameSafe
import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
@@ -83,7 +82,7 @@
return when (expression) {
is IrStringConcatenation -> true
is IrCall -> {
- val function = expression.symbol.owner
+ val function = expression.target
val receiver = expression.dispatchReceiver ?: expression.extensionReceiver
receiver != null &&
receiver.type.isStringClassType() &&
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt
index 87f3d60..299df50 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt
@@ -7,7 +7,6 @@
import org.jetbrains.kotlin.backend.common.ClassLoweringPass
import org.jetbrains.kotlin.backend.common.CommonBackendContext
-import org.jetbrains.kotlin.backend.common.deepCopyWithWrappedDescriptors
import org.jetbrains.kotlin.backend.common.descriptors.WrappedSimpleFunctionDescriptor
import org.jetbrains.kotlin.backend.common.ir.SetDeclarationsParentVisitor
import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
@@ -100,12 +99,12 @@
if (!declaration.isStatic) // TODO isStaticField
IrGetValueImpl(
irFieldInitializer.startOffset, irFieldInitializer.endOffset,
- irClass.thisReceiver!!.type, irClass.thisReceiver!!.symbol
+ irClass.thisReceiver!!.type, irClass.thisReceiver!!
)
else null
return IrSetFieldImpl(
irFieldInitializer.startOffset, irFieldInitializer.endOffset,
- declaration.symbol,
+ declaration,
receiver,
irFieldInitializer,
context.irBuiltIns.unitType,
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt
index abb4a4f..a5b1029 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InlineClassDeclarationLowering.kt
@@ -13,8 +13,6 @@
import org.jetbrains.kotlin.ir.builders.*
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -24,7 +22,7 @@
// TODO: Support incremental compilation
class InlineClassLowering(val context: BackendContext) {
- private val transformedFunction = mutableMapOf<IrFunctionSymbol, IrSimpleFunctionSymbol>()
+ private val transformedFunction = mutableMapOf<IrFunction, IrSimpleFunction>()
val inlineClassDeclarationLowering = object : ClassLoweringPass {
override fun lower(irClass: IrClass) {
@@ -46,17 +44,17 @@
if (irConstructor.isPrimary) return irConstructor
// Secondary constructors are lowered into static function
- val result = transformedFunction.getOrPut(irConstructor.symbol) { createStaticBodilessMethod(irConstructor).symbol }.owner
+ val result = transformedFunction.getOrPut(irConstructor) { createStaticBodilessMethod(irConstructor) }
val irClass = irConstructor.parentAsClass
// Copied and adapted from Kotlin/Native InlineClassTransformer
- result.body = context.createIrBuilder(result.symbol).irBlockBody(result) {
+ result.body = context.createIrBuilder(result).irBlockBody(result) {
// Secondary ctors of inline class must delegate to some other constructors.
// Use these delegating call later to initialize this variable.
lateinit var thisVar: IrVariable
val parameterMapping = result.valueParameters.associateBy {
- irConstructor.valueParameters[it.index].symbol
+ irConstructor.valueParameters[it.index]
}
(irConstructor.body as IrBlockBody).statements.forEach { statement ->
@@ -74,11 +72,11 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
expression.transformChildrenVoid()
- if (expression.symbol == irClass.thisReceiver?.symbol) {
+ if (expression.target == irClass.thisReceiver) {
return irGet(thisVar)
}
- parameterMapping[expression.symbol]?.let { return irGet(it) }
+ parameterMapping[expression.target]?.let { return irGet(it) }
return expression
}
@@ -91,7 +89,7 @@
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid()
- if (expression.returnTargetSymbol == irConstructor.symbol) {
+ if (expression.irReturnTarget == irConstructor) {
return irReturn(irBlock(expression.startOffset, expression.endOffset) {
+expression.value
+irGet(thisVar)
@@ -116,7 +114,7 @@
return listOf(function)
val staticMethod = createStaticBodilessMethod(function)
- transformedFunction[function.symbol] = staticMethod.symbol
+ transformedFunction[function] = staticMethod
// Move function body to static method, transforming value parameters and nested declarations
function.body!!.transformChildrenVoid(object : IrElementTransformerVoid() {
@@ -129,9 +127,9 @@
}
override fun visitGetValue(expression: IrGetValue): IrExpression {
- val valueDeclaration = expression.symbol.owner as? IrValueParameter ?: return super.visitGetValue(expression)
+ val valueDeclaration = expression.target as? IrValueParameter ?: return super.visitGetValue(expression)
- return context.createIrBuilder(staticMethod.symbol).irGet(
+ return context.createIrBuilder(staticMethod).irGet(
when (valueDeclaration) {
function.dispatchReceiverParameter, function.parentAsClass.thisReceiver ->
staticMethod.valueParameters[0]
@@ -152,11 +150,11 @@
staticMethod.body = function.body
- if (function.overriddenSymbols.isEmpty()) // Function is used only in unboxed context
+ if (function.overridden.isEmpty()) // Function is used only in unboxed context
return listOf(staticMethod)
// Delegate original function to static implementation
- function.body = context.createIrBuilder(function.symbol).irBlockBody {
+ function.body = context.createIrBuilder(function).irBlockBody {
+irReturn(
irCall(staticMethod).apply {
val parameters =
@@ -183,7 +181,7 @@
override fun visitConstructorCall(expression: IrConstructorCall): IrExpression {
expression.transformChildrenVoid(this)
- val function = expression.symbol.owner
+ val function = expression.target
if (!function.parentAsClass.isInline || function.isPrimary) {
return expression
}
@@ -193,7 +191,7 @@
override fun visitCall(expression: IrCall): IrExpression {
expression.transformChildrenVoid(this)
- val function = expression.symbol.owner
+ val function = expression.target
if (function.parent !is IrClass ||
function.isStaticMethodOfClass ||
!function.parentAsClass.isInline ||
@@ -212,7 +210,7 @@
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
expression.transformChildrenVoid(this)
- val function = expression.symbol.owner
+ val function = expression.target
val klass = function.parentAsClass
return when {
!klass.isInline -> expression
@@ -221,11 +219,11 @@
}
}
- private fun getOrCreateStaticMethod(function: IrFunction): IrSimpleFunctionSymbol =
- transformedFunction.getOrPut(function.symbol) {
+ private fun getOrCreateStaticMethod(function: IrFunction): IrSimpleFunction =
+ transformedFunction.getOrPut(function) {
createStaticBodilessMethod(function).also {
function.parentAsClass.declarations.add(it)
- }.symbol
+ }
}
})
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt
index 807d6be..e9de632 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt
@@ -13,15 +13,9 @@
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.builders.irGet
import org.jetbrains.kotlin.ir.builders.irSetField
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.types.classOrNull
import org.jetbrains.kotlin.ir.util.dump
import org.jetbrains.kotlin.ir.util.parentAsClass
@@ -31,14 +25,14 @@
import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass {
- private val IrValueSymbol.classForImplicitThis: IrClass?
+ private val IrValueDeclaration.classForImplicitThis: IrClass?
// TODO: is this the correct way to get the class?
get() =
- if (this is IrValueParameterSymbol && owner.index == -1 &&
- (owner == (owner.parent as? IrFunction)?.dispatchReceiverParameter ||
- owner == (owner.parent as? IrClass)?.thisReceiver)
+ if (this is IrValueParameter && index == -1 &&
+ (this == (parent as? IrFunction)?.dispatchReceiverParameter ||
+ this == (parent as? IrClass)?.thisReceiver)
) {
- owner.type.classOrNull?.owner
+ type.classOrNull?.owner
} else
null
@@ -57,14 +51,14 @@
}
val blockBody = irConstructor.body as? IrBlockBody ?: throw AssertionError("Unexpected constructor body: ${irConstructor.body}")
- context.createIrBuilder(irConstructor.symbol, irConstructor.startOffset, irConstructor.endOffset).apply {
+ context.createIrBuilder(irConstructor, irConstructor.startOffset, irConstructor.endOffset).apply {
blockBody.statements.add(0, irSetField(irGet(irClass.thisReceiver!!), parentThisField, irGet(outerThisParameter)))
}
if (blockBody.statements.find { it is IrInstanceInitializerCall } == null) {
val delegatingConstructorCall =
blockBody.statements.find { it is IrDelegatingConstructorCall } as IrDelegatingConstructorCall?
?: throw AssertionError("Delegating constructor call expected: ${irConstructor.dump()}")
- delegatingConstructorCall.apply { dispatchReceiver = IrGetValueImpl(startOffset, endOffset, outerThisParameter.symbol) }
+ delegatingConstructorCall.apply { dispatchReceiver = IrGetValueImpl(startOffset, endOffset, outerThisParameter) }
}
blockBody.patchDeclarationParents(loweredConstructor)
loweredConstructor.body = blockBody
@@ -82,7 +76,7 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
expression.transformChildrenVoid(this)
- val implicitThisClass = expression.symbol.classForImplicitThis
+ val implicitThisClass = expression.target.classForImplicitThis
if (implicitThisClass == null || implicitThisClass == irClass) return expression
val startOffset = expression.startOffset
@@ -91,7 +85,7 @@
val function = currentFunction?.irElement as? IrFunction
val enclosingThisReceiver = function?.dispatchReceiverParameter ?: irClass.thisReceiver!!
- var irThis: IrExpression = IrGetValueImpl(startOffset, endOffset, enclosingThisReceiver.symbol, origin)
+ var irThis: IrExpression = IrGetValueImpl(startOffset, endOffset, enclosingThisReceiver, origin)
var innerClass = irClass
while (innerClass != implicitThisClass) {
if (!innerClass.isInner) {
@@ -103,10 +97,10 @@
irThis = if (function is IrConstructor && irClass == innerClass) {
// Might be before a super() call (e.g. an argument to one), in which case the JVM bytecode verifier will reject
// an attempt to access the field. Good thing we have a local variable as well.
- IrGetValueImpl(startOffset, endOffset, function.valueParameters[0].symbol, origin)
+ IrGetValueImpl(startOffset, endOffset, function.valueParameters[0], origin)
} else {
val outerThisField = context.declarationFactory.getOuterThisField(innerClass)
- IrGetFieldImpl(startOffset, endOffset, outerThisField.symbol, outerThisField.type, irThis, origin)
+ IrGetFieldImpl(startOffset, endOffset, outerThisField, outerThisField.type, irThis, origin)
}
innerClass = innerClass.parentAsClass
}
@@ -129,13 +123,13 @@
expression.transformChildrenVoid(this)
val dispatchReceiver = expression.dispatchReceiver ?: return expression
- val callee = expression.symbol
- val parent = callee.owner.parentAsClass
+ val callee = expression.target
+ val parent = callee.parentAsClass
if (!parent.isInner) return expression
- val newCallee = context.declarationFactory.getInnerClassConstructorWithOuterThisParameter(callee.owner)
+ val newCallee = context.declarationFactory.getInnerClassConstructorWithOuterThisParameter(callee)
val newCall = IrConstructorCallImpl.fromSymbolOwner(
- expression.startOffset, expression.endOffset, expression.type, newCallee.symbol, expression.origin
+ expression.startOffset, expression.endOffset, expression.type, newCallee, expression.origin
)
newCall.copyTypeArgumentsFrom(expression)
@@ -151,12 +145,12 @@
expression.transformChildrenVoid(this)
val dispatchReceiver = expression.dispatchReceiver ?: return expression
- val classConstructor = expression.symbol.owner
+ val classConstructor = expression.target
if (!classConstructor.parentAsClass.isInner) return expression
val newCallee = context.declarationFactory.getInnerClassConstructorWithOuterThisParameter(classConstructor)
val newCall = IrDelegatingConstructorCallImpl(
- expression.startOffset, expression.endOffset, context.irBuiltIns.unitType, newCallee.symbol, newCallee.descriptor,
+ expression.startOffset, expression.endOffset, context.irBuiltIns.unitType, newCallee, newCallee.descriptor,
expression.typeArgumentsCount
).apply { copyTypeArgumentsFrom(expression) }
@@ -171,18 +165,18 @@
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
expression.transformChildrenVoid(this)
- val callee = expression.symbol as? IrConstructorSymbol ?: return expression
- val parent = callee.owner.parent as? IrClass ?: return expression
+ val callee = expression.target as? IrConstructor ?: return expression
+ val parent = callee.parent as? IrClass ?: return expression
if (!parent.isInner) return expression
- val newCallee = context.declarationFactory.getInnerClassConstructorWithOuterThisParameter(callee.owner)
+ val newCallee = context.declarationFactory.getInnerClassConstructorWithOuterThisParameter(callee)
val newReference = expression.run {
IrFunctionReferenceImpl(
startOffset,
endOffset,
type,
- newCallee.symbol,
+ newCallee,
newCallee.descriptor,
typeArgumentsCount,
origin
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt
index 3a03b15..32a7363 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt
@@ -51,7 +51,7 @@
val callableReference = expression.dispatchReceiver as? IrCallableReference ?: return expression
//TODO rewrite checking
- val directMember = expression.symbol.owner.let {
+ val directMember = expression.target.let {
(it as? IrSimpleFunction)?.correspondingPropertySymbol?.owner ?: it
}
val irClass = directMember.parent as? IrClass ?: return expression
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LateinitLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LateinitLowering.kt
index 70cbe59..810c7b4 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LateinitLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LateinitLowering.kt
@@ -96,7 +96,7 @@
assert(!type.isPrimitiveType()) { "'lateinit' modifier is not allowed on primitive types" }
val startOffset = getter.startOffset
val endOffset = getter.endOffset
- val irBuilder = context.createIrBuilder(getter.symbol, startOffset, endOffset)
+ val irBuilder = context.createIrBuilder(getter, startOffset, endOffset)
irBuilder.run {
val body = IrBlockBodyImpl(startOffset, endOffset)
val resultVar = scope.createTemporaryVariable(
@@ -119,10 +119,10 @@
// Transform usages
irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrExpression {
- val irVar = nullableVariables[expression.symbol.owner] ?: return expression
+ val irVar = nullableVariables[expression.target] ?: return expression
val parent = irVar.parent as IrSymbolOwner
- val irBuilder = context.createIrBuilder(parent.symbol, expression.startOffset, expression.endOffset)
+ val irBuilder = context.createIrBuilder(parent, expression.startOffset, expression.endOffset)
return irBuilder.run {
irIfThenElse(
@@ -135,38 +135,38 @@
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
expression.transformChildrenVoid(this)
- val newVar = nullableVariables[expression.symbol.owner] ?: return expression
+ val newVar = nullableVariables[expression.target] ?: return expression
return with(expression) {
- IrSetVariableImpl(startOffset, endOffset, type, newVar.symbol, value, origin)
+ IrSetVariableImpl(startOffset, endOffset, type, newVar, value, origin)
}
}
override fun visitGetField(expression: IrGetField): IrExpression {
expression.transformChildrenVoid(this)
- val newField = nullableFields[expression.symbol.owner] ?: return expression
+ val newField = nullableFields[expression.target] ?: return expression
return with(expression) {
- IrGetFieldImpl(startOffset, endOffset, newField.symbol, newField.type, receiver, origin, superQualifierSymbol)
+ IrGetFieldImpl(startOffset, endOffset, newField, newField.type, receiver, origin, irSuperQualifier)
}
}
override fun visitSetField(expression: IrSetField): IrExpression {
expression.transformChildrenVoid(this)
- val newField = nullableFields[expression.symbol.owner] ?: return expression
+ val newField = nullableFields[expression.target] ?: return expression
return with(expression) {
- IrSetFieldImpl(startOffset, endOffset, newField.symbol, receiver, value, type, origin, superQualifierSymbol)
+ IrSetFieldImpl(startOffset, endOffset, newField, receiver, value, type, origin, irSuperQualifier)
}
}
override fun visitCall(expression: IrCall): IrExpression {
expression.transformChildrenVoid(this)
- if (!Symbols.isLateinitIsInitializedPropertyGetter(expression.symbol)) return expression
+ if (!Symbols.isLateinitIsInitializedPropertyGetter(expression.target)) return expression
val receiver = expression.extensionReceiver as IrPropertyReference
- val property = receiver.getter?.owner?.resolveFakeOverride()?.correspondingProperty!!.also { assert(it.isLateinit) }
+ val property = receiver.getter?.resolveFakeOverride()?.correspondingProperty!!.also { assert(it.isLateinit) }
- return expression.run { context.createIrBuilder(symbol, startOffset, endOffset) }.run {
+ return expression.run { context.createIrBuilder(target, startOffset, endOffset) }.run {
irNotEquals(irGetField(receiver.dispatchReceiver, property.backingField!!), irNull())
}
}
@@ -186,5 +186,5 @@
)
}
- private val throwErrorFunction by lazy { context.ir.symbols.ThrowUninitializedPropertyAccessException.owner }
+ private val throwErrorFunction by lazy { context.ir.symbols.ThrowUninitializedPropertyAccessException }
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt
index ec2e30e..d2a57c4 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt
@@ -25,7 +25,6 @@
import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
@@ -105,7 +104,7 @@
override fun irGet(startOffset: Int, endOffset: Int, valueDeclaration: IrValueDeclaration): IrExpression? {
val parameter = capturedValueToParameter[valueDeclaration] ?: return null
- return IrGetValueImpl(startOffset, endOffset, parameter.type, parameter.symbol)
+ return IrGetValueImpl(startOffset, endOffset, parameter.type, parameter)
}
}
@@ -137,8 +136,8 @@
val receiver = declaration.thisReceiver!!
return IrGetFieldImpl(
- startOffset, endOffset, field.symbol, field.type,
- receiver = IrGetValueImpl(startOffset, endOffset, receiver.type, receiver.symbol)
+ startOffset, endOffset, field, field.type,
+ receiver = IrGetValueImpl(startOffset, endOffset, receiver.type, receiver)
)
}
}
@@ -149,8 +148,8 @@
val receiver = member.dispatchReceiverParameter!!
return IrGetFieldImpl(
- startOffset, endOffset, field.symbol, field.type,
- receiver = IrGetValueImpl(startOffset, endOffset, receiver.type, receiver.symbol)
+ startOffset, endOffset, field, field.type,
+ receiver = IrGetValueImpl(startOffset, endOffset, receiver.type, receiver)
)
}
@@ -168,7 +167,7 @@
val newParameterToOld: MutableMap<IrValueParameter, IrValueParameter> = mutableMapOf()
val oldParameterToNew: MutableMap<IrValueParameter, IrValueParameter> = mutableMapOf()
- val newParameterToCaptured: MutableMap<IrValueParameter, IrValueSymbol> = mutableMapOf()
+ val newParameterToCaptured: MutableMap<IrValueParameter, IrValueDeclaration> = mutableMapOf()
fun lowerLocalDeclarations() {
collectLocalDeclarations()
@@ -242,14 +241,14 @@
}
override fun visitGetValue(expression: IrGetValue): IrExpression {
- val declaration = expression.symbol.owner
+ val declaration = expression.target
localContext?.irGet(expression.startOffset, expression.endOffset, declaration)?.let {
return it
}
oldParameterToNew[declaration]?.let {
- return IrGetValueImpl(expression.startOffset, expression.endOffset, it.type, it.symbol)
+ return IrGetValueImpl(expression.startOffset, expression.endOffset, it.type, it)
}
return expression
@@ -258,7 +257,7 @@
override fun visitCall(expression: IrCall): IrExpression {
expression.transformChildrenVoid(this)
- val oldCallee = expression.symbol.owner
+ val oldCallee = expression.target
val newCallee = (oldCallee.transformed ?: return expression) as IrSimpleFunction
return createNewCall(expression, newCallee).fillArguments2(expression, newCallee)
@@ -267,7 +266,7 @@
override fun visitConstructorCall(expression: IrConstructorCall): IrExpression {
expression.transformChildrenVoid(this)
- val oldCallee = expression.symbol.owner
+ val oldCallee = expression.target
val newCallee = (oldCallee.transformed ?: return expression) as IrConstructor
return createNewCall(expression, newCallee).fillArguments2(expression, newCallee)
@@ -276,13 +275,13 @@
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
expression.transformChildrenVoid(this)
- val oldCallee = expression.symbol.owner
+ val oldCallee = expression.target
val newCallee = transformedDeclarations[oldCallee] as IrConstructor? ?: return expression
return IrDelegatingConstructorCallImpl(
expression.startOffset, expression.endOffset,
context.irBuiltIns.unitType,
- newCallee.symbol,
+ newCallee,
newCallee.descriptor,
expression.typeArgumentsCount
).also {
@@ -310,16 +309,14 @@
oldExpression.getValueArgument(oldParameter.index)
} else {
// The callee expects captured value as argument.
- val capturedValueSymbol =
+ val capturedValue =
newParameterToCaptured[newValueParameterDeclaration]
?: throw AssertionError("Non-mapped parameter $newValueParameterDeclaration")
- val capturedValue = capturedValueSymbol.owner
-
localContext?.irGet(oldExpression.startOffset, oldExpression.endOffset, capturedValue) ?: run {
// Captured value is directly available for the caller.
val value = oldParameterToNew[capturedValue] ?: capturedValue
- IrGetValueImpl(oldExpression.startOffset, oldExpression.endOffset, value.symbol)
+ IrGetValueImpl(oldExpression.startOffset, oldExpression.endOffset, value)
}
}
@@ -334,13 +331,13 @@
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
expression.transformChildrenVoid(this)
- val oldCallee = expression.symbol.owner
+ val oldCallee = expression.target
val newCallee = oldCallee.transformed ?: return expression
return IrFunctionReferenceImpl(
expression.startOffset, expression.endOffset,
expression.type, // TODO functional type for transformed descriptor
- newCallee.symbol,
+ newCallee,
newCallee.descriptor,
expression.typeArgumentsCount,
expression.origin
@@ -354,18 +351,18 @@
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid(this)
- val oldReturnTarget = expression.returnTargetSymbol.owner as? IrFunction ?: return expression
+ val oldReturnTarget = expression.irReturnTarget as? IrFunction ?: return expression
val newReturnTarget = oldReturnTarget.transformed ?: return expression
return IrReturnImpl(
expression.startOffset, expression.endOffset,
context.irBuiltIns.nothingType,
- newReturnTarget.symbol, expression.value
+ newReturnTarget, expression.value
)
}
override fun visitDeclarationReference(expression: IrDeclarationReference): IrExpression {
- if (expression.symbol.owner in transformedDeclarations) {
+ if (expression.target in transformedDeclarations) {
TODO()
}
return super.visitDeclarationReference(expression)
@@ -408,8 +405,8 @@
0,
localClassContext.capturedValueToField.map { (capturedValue, field) ->
IrSetFieldImpl(
- irClass.startOffset, irClass.endOffset, field.symbol,
- IrGetValueImpl(irClass.startOffset, irClass.endOffset, irClass.thisReceiver!!.symbol),
+ irClass.startOffset, irClass.endOffset, field,
+ IrGetValueImpl(irClass.startOffset, irClass.endOffset, irClass.thisReceiver!!),
constructorContext.irGet(irClass.startOffset, irClass.endOffset, capturedValue)!!,
context.irBuiltIns.unitType,
STATEMENT_ORIGIN_INITIALIZER_OF_FIELD_FOR_CAPTURED_VALUE
@@ -439,10 +436,10 @@
IrCallImpl(
oldCall.startOffset, oldCall.endOffset,
newCallee.returnType,
- newCallee.symbol,
+ newCallee,
newCallee.descriptor,
oldCall.typeArgumentsCount,
- oldCall.origin, oldCall.superQualifierSymbol
+ oldCall.origin, oldCall.irSuperQualifier
).also {
it.copyTypeArgumentsFrom(oldCall)
}
@@ -451,7 +448,7 @@
IrConstructorCallImpl.fromSymbolOwner(
oldCall.startOffset, oldCall.endOffset,
newCallee.returnType,
- newCallee.symbol,
+ newCallee,
oldCall.origin
).also {
it.copyTypeArgumentsFrom(oldCall)
@@ -545,13 +542,12 @@
}
private fun createTransformedValueParameters(
- capturedValues: List<IrValueSymbol>,
+ capturedValues: List<IrValueDeclaration>,
oldDeclaration: IrFunction,
newDeclaration: IrFunction
) = ArrayList<IrValueParameter>(capturedValues.size + oldDeclaration.valueParameters.size).apply {
- capturedValues.mapIndexedTo(this) { i, capturedValue ->
+ capturedValues.mapIndexedTo(this) { i, p ->
val parameterDescriptor = WrappedValueParameterDescriptor()
- val p = capturedValue.owner
IrValueParameterImpl(
p.startOffset,
p.endOffset,
@@ -567,7 +563,7 @@
).also {
parameterDescriptor.bind(it)
it.parent = newDeclaration
- newParameterToCaptured[it] = capturedValue
+ newParameterToCaptured[it] = p
}
}
@@ -583,7 +579,7 @@
valueParameters.forEach {
val capturedValue = newParameterToCaptured[it]
if (capturedValue != null) {
- localContext.capturedValueToParameter[capturedValue.owner] = it
+ localContext.capturedValueToParameter[capturedValue] = it
}
}
@@ -671,13 +667,13 @@
val irField = createFieldForCapturedValue(
classDeclaration.startOffset,
classDeclaration.endOffset,
- suggestNameForCapturedValue(capturedValue.owner),
+ suggestNameForCapturedValue(capturedValue),
Visibilities.PRIVATE,
classDeclaration,
- capturedValue.owner.type
+ capturedValue.type
)
- localClassContext.capturedValueToField[capturedValue.owner] = irField
+ localClassContext.capturedValueToField[capturedValue] = irField
}
}
@@ -723,7 +719,7 @@
}
override fun createScope(declaration: IrSymbolOwner): ScopeWithIr {
- return ScopeWithCounter(Scope(declaration.symbol), declaration)
+ return ScopeWithCounter(Scope(declaration), declaration)
}
override fun visitSimpleFunction(declaration: IrSimpleFunction) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt
index 49cbbdf..f5b4e40 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt
@@ -28,7 +28,6 @@
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.IrSimpleType
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.classifierOrFail
@@ -43,11 +42,11 @@
class DeclarationIrBuilder(
backendContext: BackendContext,
- symbol: IrSymbol,
+ target: IrSymbolOwner,
startOffset: Int = UNDEFINED_OFFSET, endOffset: Int = UNDEFINED_OFFSET
) : IrBuilderWithScope(
IrLoweringContext(backendContext),
- Scope(symbol),
+ Scope(target),
startOffset,
endOffset
)
@@ -56,8 +55,8 @@
protected abstract fun remapVariable(value: IrValueDeclaration): IrValueDeclaration?
override fun visitGetValue(expression: IrGetValue): IrExpression =
- remapVariable(expression.symbol.owner)?.let {
- IrGetValueImpl(expression.startOffset, expression.endOffset, it.type, it.symbol, expression.origin)
+ remapVariable(expression.target)?.let {
+ IrGetValueImpl(expression.startOffset, expression.endOffset, it.type, it, expression.origin)
} ?: expression
}
@@ -72,11 +71,11 @@
}
fun BackendContext.createIrBuilder(
- symbol: IrSymbol,
+ target: IrSymbolOwner,
startOffset: Int = UNDEFINED_OFFSET,
endOffset: Int = UNDEFINED_OFFSET
) =
- DeclarationIrBuilder(this, symbol, startOffset, endOffset)
+ DeclarationIrBuilder(this, target, startOffset, endOffset)
fun <T : IrBuilder> T.at(element: IrElement) = this.at(element.startOffset, element.endOffset)
@@ -131,9 +130,9 @@
protected val builder: IrBuilderWithScope
get() = currentBuilder!!
- private inline fun <T> withBuilder(symbol: IrSymbol, block: () -> T): T {
+ private inline fun <T> withBuilder(owner: IrSymbolOwner, block: () -> T): T {
val oldBuilder = currentBuilder
- currentBuilder = context.createIrBuilder(symbol)
+ currentBuilder = context.createIrBuilder(owner)
return try {
block()
} finally {
@@ -142,20 +141,20 @@
}
override fun visitFunction(declaration: IrFunction): IrStatement {
- withBuilder(declaration.symbol) {
+ withBuilder(declaration) {
return super.visitFunction(declaration)
}
}
override fun visitField(declaration: IrField): IrStatement {
- withBuilder(declaration.symbol) {
+ withBuilder(declaration) {
// Transforms initializer:
return super.visitField(declaration)
}
}
override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer): IrStatement {
- withBuilder(declaration.symbol) {
+ withBuilder(declaration) {
return super.visitAnonymousInitializer(declaration)
}
}
@@ -180,7 +179,7 @@
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) {
assert(++numberOfCalls == 1) { "More than one delegating constructor call: ${symbol.owner}" }
- val delegatingClass = expression.symbol.owner.parent as IrClass
+ val delegatingClass = expression.target.parent as IrClass
// TODO: figure out why Lazy IR multiplies Declarations for descriptors and fix it
// It happens because of IrBuiltIns whose IrDeclarations are different for runtime and test
if (delegatingClass.descriptor == superClass.classifierOrFail.descriptor)
@@ -228,12 +227,12 @@
) : IrElementTransformer<Nothing?> {
override fun visitGetValue(expression: IrGetValue, data: Nothing?): IrExpression {
val irGetValue = expression
- if (irGetValue.symbol == oldThisReceiverParameter.symbol) {
+ if (irGetValue.target == oldThisReceiverParameter) {
val instanceField = context.declarationFactory.getFieldForObjectInstance(irClass)
return IrGetFieldImpl(
expression.startOffset,
expression.endOffset,
- instanceField.symbol,
+ instanceField,
irClass.defaultType
)
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ProvisionalFunctionExpressionLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ProvisionalFunctionExpressionLowering.kt
index e7ab960..11f7026 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ProvisionalFunctionExpressionLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ProvisionalFunctionExpressionLowering.kt
@@ -37,7 +37,7 @@
function,
IrFunctionReferenceImpl(
startOffset, endOffset, type,
- function.symbol, function.descriptor, 0,
+ function, function.descriptor, 0,
origin
)
)
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ReturnableBlockLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ReturnableBlockLowering.kt
index 5bbdede..6de6ebe 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ReturnableBlockLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ReturnableBlockLowering.kt
@@ -20,7 +20,6 @@
import org.jetbrains.kotlin.ir.expressions.impl.IrBlockImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrDoWhileLoopImpl
-import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
/**
* Replaces returnable blocks and `return`'s with loops and `break`'s correspondingly.
@@ -77,17 +76,17 @@
private class ReturnableBlockTransformer(val context: CommonBackendContext) : IrElementTransformerVoidWithContext() {
private var labelCnt = 0
- private val returnMap = mutableMapOf<IrReturnableBlockSymbol, (IrReturn) -> IrExpression>()
+ private val returnMap = mutableMapOf<IrReturnableBlock, (IrReturn) -> IrExpression>()
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid()
- return returnMap[expression.returnTargetSymbol]?.invoke(expression) ?: expression
+ return returnMap[expression.irReturnTarget]?.invoke(expression) ?: expression
}
override fun visitContainerExpression(expression: IrContainerExpression): IrExpression {
if (expression !is IrReturnableBlock) return super.visitContainerExpression(expression)
- val builder = context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol)
+ val builder = context.createIrBuilder(currentScope!!.scope.irScopeOwner)
val variable by lazy {
builder.scope.createTemporaryVariableDeclaration(expression.type, "tmp\$ret\$${labelCnt++}", true)
}
@@ -106,26 +105,26 @@
var hasReturned = false
- returnMap[expression.symbol] = { returnExpression ->
+ returnMap[expression] = { returnExpression ->
hasReturned = true
builder.irComposite(returnExpression) {
- +irSetVar(variable.symbol, returnExpression.value)
+ +irSetVar(variable, returnExpression.value)
+irBreak(loop)
}
}
val newStatements = expression.statements.mapIndexed { i, s ->
- if (i == expression.statements.lastIndex && s is IrReturn && s.returnTargetSymbol == expression.symbol) {
+ if (i == expression.statements.lastIndex && s is IrReturn && s.irReturnTarget == expression) {
s.transformChildrenVoid()
if (!hasReturned) s.value else {
- builder.irSetVar(variable.symbol, s.value)
+ builder.irSetVar(variable, s.value)
}
} else {
s.transform(this, null)
}
}
- returnMap.remove(expression.symbol)
+ returnMap.remove(expression)
if (!hasReturned) {
return IrCompositeImpl(
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt
index 1f5d54c..105bf1d 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SharedVariablesLowering.kt
@@ -23,8 +23,6 @@
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.util.dump
import org.jetbrains.kotlin.ir.visitors.*
import java.util.*
@@ -108,7 +106,7 @@
override fun visitValueAccess(expression: IrValueAccessExpression, data: IrDeclarationParent?) {
expression.acceptChildren(this, data)
- val value = expression.symbol.owner
+ val value = expression.target
if (value in relevantVars && (value as IrVariable).parent != data) {
sharedVariables.add(value)
}
@@ -117,7 +115,7 @@
}
private fun rewriteSharedVariables() {
- val transformedSymbols = HashMap<IrValueSymbol, IrVariableSymbol>()
+ val transformed = HashMap<IrValueDeclaration, IrVariable>()
irDeclaration.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitVariable(declaration: IrVariable): IrStatement {
@@ -127,7 +125,7 @@
val newDeclaration = context.sharedVariablesManager.declareSharedVariable(declaration)
newDeclaration.parent = declaration.parent
- transformedSymbols[declaration.symbol] = newDeclaration.symbol
+ transformed[declaration] = newDeclaration
return context.sharedVariablesManager.defineSharedValue(declaration, newDeclaration)
}
@@ -137,7 +135,7 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
expression.transformChildrenVoid(this)
- val newDeclaration = getTransformedSymbol(expression.symbol) ?: return expression
+ val newDeclaration = getTransformedSymbol(expression.target) ?: return expression
return context.sharedVariablesManager.getSharedValue(newDeclaration, expression)
}
@@ -145,15 +143,15 @@
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
expression.transformChildrenVoid(this)
- val newDeclaration = getTransformedSymbol(expression.symbol) ?: return expression
+ val newDeclaration = getTransformedSymbol(expression.target) ?: return expression
return context.sharedVariablesManager.setSharedValue(newDeclaration, expression)
}
- private fun getTransformedSymbol(oldSymbol: IrValueSymbol): IrVariableSymbol? =
- transformedSymbols.getOrElse(oldSymbol) {
- assert(oldSymbol.owner !in sharedVariables) {
- "Shared variable is not transformed: ${oldSymbol.owner.dump()}"
+ private fun getTransformedSymbol(old: IrValueDeclaration): IrVariable? =
+ transformed.getOrElse(old) {
+ assert(old !in sharedVariables) {
+ "Shared variable is not transformed: ${old.dump()}"
}
null
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SpecialBridgeMethods.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SpecialBridgeMethods.kt
index 5cc6155..ef58810 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SpecialBridgeMethods.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SpecialBridgeMethods.kt
@@ -46,7 +46,7 @@
IrConstImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, context.irBuiltIns.intType, IrConstKind.Int, -1)
private fun getSecondArg(bridge: IrSimpleFunction) =
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, bridge.valueParameters[1].symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, bridge.valueParameters[1])
private val SPECIAL_METHODS_WITH_DEFAULTS_MAP = mapOf<SpecialMethodDescription, (IrSimpleFunction) -> IrExpression>(
makeDescription("kotlin.collections.Collection", "contains", 1) to ::constFalse,
@@ -80,7 +80,7 @@
return sequence {
yield(this@search)
visited.add(this@search)
- overriddenSymbols.forEach { yieldAll(it.owner.search()) }
+ overridden.forEach { yieldAll(it.search()) }
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/StringConcatenationLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/StringConcatenationLowering.kt
index 39959aa..fdaf67c 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/StringConcatenationLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/StringConcatenationLowering.kt
@@ -58,7 +58,7 @@
private val nameToString = Name.identifier("toString")
private val nameAppend = Name.identifier("append")
- private val stringBuilder = context.ir.symbols.stringBuilder.owner
+ private val stringBuilder = context.ir.symbols.stringBuilder
//TODO: calculate and pass string length to the constructor.
private val constructor = stringBuilder.constructors.single {
@@ -113,7 +113,7 @@
with(declaration) {
buildersStack.add(
- context.createIrBuilder(declaration.symbol, startOffset, endOffset)
+ context.createIrBuilder(declaration, startOffset, endOffset)
)
transformChildrenVoid(this@StringConcatenationTransformer)
buildersStack.removeAt(buildersStack.lastIndex)
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt
index 5ed6571..a3d1f95 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/TailrecLowering.kt
@@ -22,7 +22,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
-import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
import org.jetbrains.kotlin.ir.util.explicitParameters
import org.jetbrains.kotlin.ir.util.getArgumentsWithIr
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
@@ -53,14 +52,14 @@
}
val oldBody = irFunction.body as IrBlockBody
- val builder = context.createIrBuilder(irFunction.symbol).at(oldBody)
+ val builder = context.createIrBuilder(irFunction).at(oldBody)
val parameters = irFunction.explicitParameters
irFunction.body = builder.irBlockBody {
// Define variables containing current values of parameters:
val parameterToVariable = parameters.associate {
- it to createTmpVariable(irGet(it), nameHint = it.symbol.suggestVariableName(), isMutable = true)
+ it to createTmpVariable(irGet(it), nameHint = it.suggestVariableName(), isMutable = true)
}
// (these variables are to be updated on any tail call).
@@ -72,7 +71,7 @@
// Read variables containing current values of parameters:
val parameterToNew = parameters.associate {
val variable = parameterToVariable[it]!!
- it to createTmpVariable(irGet(variable), nameHint = it.symbol.suggestVariableName())
+ it to createTmpVariable(irGet(variable), nameHint = it.suggestVariableName())
}
val transformer = BodyTransformer(
@@ -103,7 +102,7 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
expression.transformChildrenVoid(this)
- val value = parameterToNew[expression.symbol.owner] ?: return expression
+ val value = parameterToNew[expression.target] ?: return expression
return builder.at(expression).irGet(value)
}
@@ -127,7 +126,7 @@
at(argument)
// Note that argument can use values of parameters, so it is important that
// references to parameters are mapped using `parameterToNew`, not `parameterToVariable`.
- +irSetVar(parameterToVariable[parameter]!!.symbol, argument)
+ +irSetVar(parameterToVariable[parameter]!!, argument)
}
val specifiedParameters = parameterToArgument.map { (parameter, _) -> parameter }.toSet()
@@ -145,15 +144,15 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
expression.transformChildrenVoid(this)
- val variable = parameterToVariable[expression.symbol.owner] ?: return expression
+ val variable = parameterToVariable[expression.target] ?: return expression
return IrGetValueImpl(
expression.startOffset, expression.endOffset, variable.type,
- variable.symbol, expression.origin
+ variable, expression.origin
)
}
}, data = null)
- +irSetVar(parameterToVariable[parameter]!!.symbol, defaultValue)
+ +irSetVar(parameterToVariable[parameter]!!, defaultValue)
}
// Jump to the entry:
@@ -161,10 +160,10 @@
}
}
-private fun IrValueParameterSymbol.suggestVariableName(): String =
- if (owner.name.isSpecial) {
- val oldNameStr = owner.name.asString()
+private fun IrValueParameter.suggestVariableName(): String =
+ if (name.isSpecial) {
+ val oldNameStr = name.asString()
"$" + oldNameStr.substring(1, oldNameStr.length - 1)
} else {
- owner.name.identifier
+ name.identifier
}
\ No newline at end of file
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/FunctionInlining.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/FunctionInlining.kt
index ade9927..4b01c5d 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/FunctionInlining.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/FunctionInlining.kt
@@ -20,9 +20,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrReturnableBlockSymbolImpl
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.isNullable
@@ -39,18 +36,18 @@
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
expression.transformChildrenVoid(this)
val callee = when (expression) {
- is IrCall -> expression.symbol.owner
- is IrConstructorCall -> expression.symbol.owner
+ is IrCall -> expression.target
+ is IrConstructorCall -> expression.target
else -> return expression
}
if (!callee.needsInlining)
return expression
- if (Symbols.isLateinitIsInitializedPropertyGetter(callee.symbol))
+ if (Symbols.isLateinitIsInitializedPropertyGetter(callee))
return expression
- if (Symbols.isTypeOfIntrinsic(callee.symbol))
+ if (Symbols.isTypeOfIntrinsic(callee))
return expression
- val actualCallee = getFunctionDeclaration(callee.symbol)
+ val actualCallee = getFunctionDeclaration(callee)
val parent = allScopes.map { it.irElement }.filterIsInstance<IrDeclarationParent>().lastOrNull()
@@ -58,8 +55,8 @@
return inliner.inline()
}
- private fun getFunctionDeclaration(symbol: IrFunctionSymbol): IrFunction {
- val descriptor = symbol.descriptor.original
+ private fun getFunctionDeclaration(function: IrFunction): IrFunction {
+ val descriptor = function.descriptor.original
val languageVersionSettings = context.configuration.languageVersionSettings
// TODO: Remove these hacks when coroutine intrinsics are fixed.
return when {
@@ -67,12 +64,12 @@
error("Continuation.intercepted is not available with release coroutines")
descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(languageVersionSettings) ->
- context.ir.symbols.suspendCoroutineUninterceptedOrReturn.owner
+ context.ir.symbols.suspendCoroutineUninterceptedOrReturn
- symbol == context.ir.symbols.coroutineContextGetter ->
- context.ir.symbols.coroutineGetContext.owner
+ function == context.ir.symbols.coroutineContextGetter ->
+ context.ir.symbols.coroutineGetContext
- else -> (symbol.owner as? IrSimpleFunction)?.resolveFakeOverride() ?: symbol.owner
+ else -> (function as? IrSimpleFunction)?.resolveFakeOverride() ?: function
}
}
@@ -127,10 +124,6 @@
val irReturnableBlockSymbol = IrReturnableBlockSymbolImpl(copiedCallee.descriptor.original)
val endOffset = callee.endOffset
- /* creates irBuilder appending to the end of the given returnable block: thus why we initialize
- * irBuilder with (..., endOffset, endOffset).
- */
- val irBuilder = context.createIrBuilder(irReturnableBlockSymbol, endOffset, endOffset)
val transformer = ParameterSubstitutor()
statements.transform { it.transform(transformer, data = null) }
@@ -147,13 +140,17 @@
symbol = irReturnableBlockSymbol,
origin = if (isCoroutineIntrinsicCall) CoroutineIntrinsicLambdaOrigin else null,
statements = statements,
- inlineFunctionSymbol = callee.symbol
+ inlineFunction = callee
).apply {
+ /* creates irBuilder appending to the end of the given returnable block: thus why we initialize
+ * irBuilder with (..., endOffset, endOffset).
+ */
+ val irBuilder = context.createIrBuilder(this, endOffset, endOffset)
transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid(this)
- if (expression.returnTargetSymbol == copiedCallee.symbol)
+ if (expression.irReturnTarget == copiedCallee)
return irBuilder.irReturn(expression.value)
return expression
}
@@ -168,7 +165,7 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
val newExpression = super.visitGetValue(expression) as IrGetValue
- val argument = substituteMap[newExpression.symbol.owner] ?: return newExpression
+ val argument = substituteMap[newExpression.target] ?: return newExpression
argument.transformChildrenVoid(this) // Default argument can contain subjects for substitution.
@@ -184,14 +181,14 @@
return super.visitCall(expression)
val dispatchReceiver = expression.dispatchReceiver as IrGetValue
- val functionArgument = substituteMap[dispatchReceiver.symbol.owner] ?: return super.visitCall(expression)
- if ((dispatchReceiver.symbol.owner as? IrValueParameter)?.isNoinline == true)
+ val functionArgument = substituteMap[dispatchReceiver.target] ?: return super.visitCall(expression)
+ if ((dispatchReceiver.target as? IrValueParameter)?.isNoinline == true)
return super.visitCall(expression)
if (functionArgument is IrFunctionReference) {
functionArgument.transformChildrenVoid(this)
- val function = functionArgument.symbol.owner
+ val function = functionArgument.target
val functionParameters = function.explicitParameters
val boundFunctionParameters = functionArgument.getArgumentsWithIr()
val unboundFunctionParameters = functionParameters - boundFunctionParameters.map { it.first }
@@ -203,9 +200,9 @@
val immediateCall = with(expression) {
if (function is IrConstructor)
- IrConstructorCallImpl.fromSymbolOwner(startOffset, endOffset, function.returnType, function.symbol)
+ IrConstructorCallImpl.fromSymbolOwner(startOffset, endOffset, function.returnType, function)
else
- IrCallImpl(startOffset, endOffset, function.returnType, functionArgument.symbol)
+ IrCallImpl(startOffset, endOffset, function.returnType, functionArgument.target)
}.apply {
functionParameters.forEach {
val argument =
@@ -264,7 +261,7 @@
IrTypeOperatorCallImpl(startOffset, endOffset, type, IrTypeOperator.IMPLICIT_CAST, type, this)
private fun isLambdaCall(irCall: IrCall): Boolean {
- val callee = irCall.symbol.owner
+ val callee = irCall.target
val dispatchReceiver = callee.dispatchReceiverParameter ?: return false
assert(!dispatchReceiver.type.isKFunction())
@@ -290,11 +287,11 @@
val isImmutableVariableLoad: Boolean
get() = argumentExpression.let {
- it is IrGetValue && !it.symbol.owner.let { it is IrVariable && it.isVar }
+ it is IrGetValue && !it.target.let { it is IrVariable && it.isVar }
}
}
- // callee might be a copied version of callsite.symbol.owner
+ // callee might be a copied version of callsite
private fun buildParameterToArgument(callSite: IrFunctionAccessExpression, callee: IrFunction): List<ParameterToArgument> {
val parameterToArgument = mutableListOf<ParameterToArgument>()
@@ -306,7 +303,7 @@
)
val valueArguments =
- callSite.symbol.owner.valueParameters.map { callSite.getValueArgument(it.index) }.toMutableList()
+ callSite.target.valueParameters.map { callSite.getValueArgument(it.index) }.toMutableList()
if (callee.extensionReceiverParameter != null) {
parameterToArgument += ParameterToArgument(
@@ -374,7 +371,7 @@
val arguments = functionReference.getArgumentsWithIr().map { ParameterToArgument(it.first, it.second) }
val evaluationStatements = mutableListOf<IrStatement>()
val substitutor = ParameterSubstitutor()
- val referenced = functionReference.symbol.owner
+ val referenced = functionReference.target
arguments.forEach {
val newArgument = if (it.isImmutableVariableLoad) {
it.argumentExpression.transform( // Arguments may reference the previous ones - substitute them.
@@ -388,13 +385,13 @@
substitutor,
data = null
),
- nameHint = callee.symbol.owner.name.toString(),
+ nameHint = callee.name.toString(),
isMutable = false
)
evaluationStatements.add(newVariable)
- IrGetValueWithoutLocation(newVariable.symbol)
+ IrGetValueWithoutLocation(newVariable)
}
when (it.parameter) {
referenced.dispatchReceiverParameter -> functionReference.dispatchReceiver = newArgument
@@ -436,27 +433,27 @@
irExpression = IrBlockImpl (variableInitializer.startOffset,
variableInitializer.endOffset,
variableInitializer.type,
- InlinerExpressionLocationHint((currentScope.irElement as IrSymbolOwner).symbol)).apply {
+ InlinerExpressionLocationHint(currentScope.irElement as IrSymbolOwner)).apply {
statements.add(variableInitializer)
},
- nameHint = callee.symbol.owner.name.toString(),
+ nameHint = callee.name.toString(),
isMutable = false
)
evaluationStatements.add(newVariable)
- substituteMap[it.parameter] = IrGetValueWithoutLocation(newVariable.symbol)
+ substituteMap[it.parameter] = IrGetValueWithoutLocation(newVariable)
}
return evaluationStatements
}
}
private class IrGetValueWithoutLocation(
- symbol: IrValueSymbol,
+ target: IrValueDeclaration,
override val origin: IrStatementOrigin? = null
- ) : IrTerminalDeclarationReferenceBase<IrValueSymbol, ValueDescriptor>(
+ ) : IrTerminalDeclarationReferenceBase<IrValueDeclaration, ValueDescriptor>(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- symbol.owner.type,
- symbol, symbol.descriptor
+ target.type,
+ target, target.descriptor
), IrGetValue {
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D) =
visitor.visitGetValue(this, data)
@@ -466,16 +463,16 @@
}
fun withLocation(startOffset: Int, endOffset: Int) =
- IrGetValueImpl(startOffset, endOffset, type, symbol, origin)
+ IrGetValueImpl(startOffset, endOffset, type, target, origin)
}
}
-class InlinerExpressionLocationHint(val inlineAtSymbol: IrSymbol) : IrStatementOrigin {
+class InlinerExpressionLocationHint(val inlineAt: IrSymbolOwner) : IrStatementOrigin {
override fun toString(): String = "(${this.javaClass.simpleName} : $functionNameOrDefaultToString @${functionFileOrNull?.fileEntry?.name})"
private val functionFileOrNull: IrFile?
- get() = (inlineAtSymbol as? IrFunction)?.file
+ get() = (inlineAt as? IrFunction)?.file
private val functionNameOrDefaultToString: String
- get() = (inlineAtSymbol as? IrFunction)?.name?.asString() ?: inlineAtSymbol.toString()
+ get() = (inlineAt as? IrFunction)?.name?.asString() ?: inlineAt.toString()
}
\ No newline at end of file
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ForLoopsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ForLoopsLowering.kt
index 67986de..b34ae52 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ForLoopsLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ForLoopsLowering.kt
@@ -15,7 +15,6 @@
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -117,11 +116,11 @@
) : IrElementTransformerVoidWithContext() {
private val symbols = context.ir.symbols
- private val iteratorToLoopHeader = mutableMapOf<IrVariableSymbol, ForLoopHeader>()
- private val headerInfoBuilder = HeaderInfoBuilder(context, this::getScopeOwnerSymbol)
- private val headerProcessor = HeaderProcessor(context, headerInfoBuilder, this::getScopeOwnerSymbol)
+ private val iteratorToLoopHeader = mutableMapOf<IrVariable, ForLoopHeader>()
+ private val headerInfoBuilder = HeaderInfoBuilder(context, this::getScopeOwner)
+ private val headerProcessor = HeaderProcessor(context, headerInfoBuilder, this::getScopeOwner)
- fun getScopeOwnerSymbol() = currentScope!!.scope.scopeOwnerSymbol
+ fun getScopeOwner() = currentScope!!.scope.irScopeOwner
override fun visitVariable(declaration: IrVariable): IrStatement {
val initializer = declaration.initializer
@@ -145,10 +144,10 @@
* Returns null if the for-loop cannot be lowered.
*/
private fun processHeader(variable: IrVariable): IrStatement? {
- assert(variable.symbol !in iteratorToLoopHeader)
+ assert(variable !in iteratorToLoopHeader)
val forLoopInfo = headerProcessor.processHeader(variable)
?: return null // If the for-loop cannot be lowered.
- iteratorToLoopHeader[variable.symbol] = forLoopInfo
+ iteratorToLoopHeader[variable] = forLoopInfo
// Lower into a composite with additional declarations (e.g., induction variable)
// used in the loop condition and body.
@@ -166,7 +165,7 @@
return super.visitWhileLoop(loop)
}
- with(context.createIrBuilder(getScopeOwnerSymbol(), loop.startOffset, loop.endOffset)) {
+ with(context.createIrBuilder(getScopeOwner(), loop.startOffset, loop.endOffset)) {
// Visit the loop body to process the "next" statement and lower nested loops.
// Processing the "next" statement is necessary for building loops that need to
// reference the loop variable in the loop condition.
@@ -199,7 +198,7 @@
val iterator = expression.dispatchReceiver as IrGetValue
// Return null if we didn't lower the corresponding header.
- return iteratorToLoopHeader[iterator.symbol]
+ return iteratorToLoopHeader[iterator.target]
}
/**
@@ -224,7 +223,7 @@
// val i = initializeLoopVariable() // `inductionVariable` for progressions
// // `array[inductionVariable]` for arrays
// inductionVariable = inductionVariable + step
- return with(context.createIrBuilder(getScopeOwnerSymbol(), initializer.startOffset, initializer.endOffset)) {
+ return with(context.createIrBuilder(getScopeOwner(), initializer.startOffset, initializer.endOffset)) {
variable.initializer = forLoopInfo.initializeLoopVariable(symbols, this)
val increment = forLoopInfo.incrementInductionVariable(this)
IrCompositeImpl(
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt
index 762664a..3a9dca0 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderInfo.kt
@@ -9,11 +9,11 @@
import org.jetbrains.kotlin.backend.common.ir.Symbols
import org.jetbrains.kotlin.backend.common.lower.matchers.IrCallMatcher
import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.isSubtypeOfClass
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -175,9 +175,9 @@
fun match(expression: E): Boolean
/** Builds a [HeaderInfo] from the expression. */
- fun build(expression: E, data: D, scopeOwner: IrSymbol): HeaderInfo?
+ fun build(expression: E, data: D, scopeOwner: IrSymbolOwner): HeaderInfo?
- fun handle(expression: E, data: D, scopeOwner: IrSymbol) = if (match(expression)) {
+ fun handle(expression: E, data: D, scopeOwner: IrSymbolOwner) = if (match(expression)) {
build(expression, data, scopeOwner)
} else {
null
@@ -185,8 +185,8 @@
}
internal interface ExpressionHandler : HeaderInfoHandler<IrExpression, Nothing?> {
- fun build(expression: IrExpression, scopeOwner: IrSymbol): HeaderInfo?
- override fun build(expression: IrExpression, data: Nothing?, scopeOwner: IrSymbol) = build(expression, scopeOwner)
+ fun build(expression: IrExpression, scopeOwner: IrSymbolOwner): HeaderInfo?
+ override fun build(expression: IrExpression, data: Nothing?, scopeOwner: IrSymbolOwner) = build(expression, scopeOwner)
}
/** Matches a call to build an iterable and builds a [HeaderInfo] from the call's context. */
@@ -198,7 +198,7 @@
internal typealias ProgressionHandler = HeaderInfoFromCallHandler<ProgressionType>
-internal class HeaderInfoBuilder(context: CommonBackendContext, private val scopeOwnerSymbol: () -> IrSymbol) :
+internal class HeaderInfoBuilder(context: CommonBackendContext, private val scopeOwner: () -> IrSymbolOwner) :
IrElementVisitor<HeaderInfo?, Nothing?> {
private val symbols = context.ir.symbols
@@ -233,21 +233,21 @@
/** Builds a [HeaderInfo] for iterable expressions that are calls (e.g., `.reversed()`, `.indices`. */
override fun visitCall(expression: IrCall, data: Nothing?): HeaderInfo? {
// Return the HeaderInfo from the first successful match. First, try to match a `reversed()` call.
- val reversedHeaderInfo = reversedHandler.handle(expression, null, scopeOwnerSymbol())
+ val reversedHeaderInfo = reversedHandler.handle(expression, null, scopeOwner())
if (reversedHeaderInfo != null)
return reversedHeaderInfo
// Try to match a call to build a progression (e.g., `.indices`, `downTo`).
val progressionType = ProgressionType.fromIrType(expression.type, symbols)
val progressionHeaderInfo =
- progressionType?.run { progressionHandlers.firstNotNullResult { it.handle(expression, this, scopeOwnerSymbol()) } }
+ progressionType?.run { progressionHandlers.firstNotNullResult { it.handle(expression, this, scopeOwner()) } }
return progressionHeaderInfo ?: super.visitCall(expression, data)
}
/** Builds a [HeaderInfo] for iterable expressions not handled in [visitCall]. */
override fun visitExpression(expression: IrExpression, data: Nothing?): HeaderInfo? {
- return expressionHandlers.firstNotNullResult { it.handle(expression, null, scopeOwnerSymbol()) }
+ return expressionHandlers.firstNotNullResult { it.handle(expression, null, scopeOwner()) }
?: super.visitExpression(expression, data)
}
}
\ No newline at end of file
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt
index 70ba88a..3d0fbbf 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt
@@ -14,13 +14,13 @@
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.builders.*
import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrLoop
import org.jetbrains.kotlin.ir.expressions.impl.IrDoWhileLoopImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrWhileLoopImpl
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.functions
import org.jetbrains.kotlin.ir.util.getPackageFragment
@@ -66,8 +66,8 @@
it.valueParameters[0].type == step.type
}
irSetVar(
- inductionVariable.symbol, irCallOp(
- plusFun.symbol, plusFun.returnType,
+ inductionVariable, irCallOp(
+ plusFun, plusFun.returnType,
irGet(inductionVariable),
irGet(step)
)
@@ -245,7 +245,7 @@
internal class HeaderProcessor(
private val context: CommonBackendContext,
private val headerInfoBuilder: HeaderInfoBuilder,
- private val scopeOwnerSymbol: () -> IrSymbol
+ private val scopeOwner: () -> IrSymbolOwner
) {
private val symbols = context.ir.symbols
@@ -274,7 +274,7 @@
val iterable = (variable.initializer as? IrCall)?.let {
val extensionReceiver = it.extensionReceiver
if (extensionReceiver != null) {
- val function = it.symbol.owner
+ val function = it.target
if (it.valueArgumentsCount == 0
&& function.isTopLevel
&& function.getPackageFragment()?.fqName == FqName("kotlin.text")
@@ -292,7 +292,7 @@
val headerInfo = iterable?.accept(headerInfoBuilder, null)
?: return null // If the iterable is not supported.
- val builder = context.createIrBuilder(scopeOwnerSymbol(), variable.startOffset, variable.endOffset)
+ val builder = context.createIrBuilder(scopeOwner(), variable.startOffset, variable.endOffset)
with(builder) builder@{
with(headerInfo) {
// For this loop:
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ProgressionHandlers.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ProgressionHandlers.kt
index 836e9a2..9b5cdee 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ProgressionHandlers.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ProgressionHandlers.kt
@@ -12,12 +12,11 @@
import org.jetbrains.kotlin.backend.common.lower.matchers.createIrCallMatcher
import org.jetbrains.kotlin.backend.common.lower.matchers.singleArgumentExtension
import org.jetbrains.kotlin.ir.builders.*
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -35,7 +34,7 @@
parameter(0) { it.type in progressionElementTypes }
}
- override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbol) =
+ override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbolOwner) =
with(context.createIrBuilder(scopeOwner, expression.startOffset, expression.endOffset)) {
ProgressionHeaderInfo(
data,
@@ -57,7 +56,7 @@
parameter(0) { it.type in progressionElementTypes }
}
- override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbol): HeaderInfo? =
+ override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbolOwner): HeaderInfo? =
with(context.createIrBuilder(scopeOwner, expression.startOffset, expression.endOffset)) {
ProgressionHeaderInfo(
data,
@@ -79,7 +78,7 @@
parameter(0) { it.type in progressionElementTypes }
}
- override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbol): HeaderInfo? =
+ override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbolOwner): HeaderInfo? =
with(context.createIrBuilder(scopeOwner, expression.startOffset, expression.endOffset)) {
// `A until B` is essentially the same as `A .. (B-1)`. However, B could be MIN_VALUE and hence `(B-1)` could underflow.
// If B is MIN_VALUE, then `A until B` is an empty range. We handle this special case be adding an additional "not empty"
@@ -222,7 +221,7 @@
/** Builds a [HeaderInfo] for progressions built using the `indices` extension property. */
internal abstract class IndicesHandler(protected val context: CommonBackendContext) : ProgressionHandler {
- override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbol): HeaderInfo? =
+ override fun build(expression: IrCall, data: ProgressionType, scopeOwner: IrSymbolOwner): HeaderInfo? =
with(context.createIrBuilder(scopeOwner, expression.startOffset, expression.endOffset)) {
// `last = array.size - 1` (last is inclusive) for the loop `for (i in array.indices)`.
val receiver = expression.extensionReceiver!!
@@ -268,7 +267,7 @@
override val IrType.sizePropertyGetter
get() = getClass()?.properties?.first { it.name.asString() == "length" }?.let {
it.getter!!
- } ?: context.ir.symbols.charSequence.getPropertyGetter("length")!!.owner
+ } ?: context.ir.symbols.charSequence.getPropertyGetter("length")!!
}
/** Builds a [HeaderInfo] for calls to reverse an iterable. */
@@ -290,7 +289,7 @@
}
// Reverse the HeaderInfo from the underlying progression or array (if any).
- override fun build(expression: IrCall, data: Nothing?, scopeOwner: IrSymbol) =
+ override fun build(expression: IrCall, data: Nothing?, scopeOwner: IrSymbolOwner) =
expression.extensionReceiver!!.accept(visitor, null)?.asReversed()
}
@@ -301,7 +300,7 @@
override fun match(expression: IrExpression) = ProgressionType.fromIrType(expression.type, symbols) != null
- override fun build(expression: IrExpression, scopeOwner: IrSymbol): HeaderInfo? =
+ override fun build(expression: IrExpression, scopeOwner: IrSymbolOwner): HeaderInfo? =
with(context.createIrBuilder(scopeOwner, expression.startOffset, expression.endOffset)) {
// Directly use the `first/last/step` properties of the progression.
val progression = scope.createTemporaryVariable(expression, nameHint = "progression")
@@ -331,7 +330,7 @@
}
internal abstract class IndexedGetIterationHandler(protected val context: CommonBackendContext) : ExpressionHandler {
- override fun build(expression: IrExpression, scopeOwner: IrSymbol): HeaderInfo? =
+ override fun build(expression: IrExpression, scopeOwner: IrSymbolOwner): HeaderInfo? =
with(context.createIrBuilder(scopeOwner, expression.startOffset, expression.endOffset)) {
// Consider the case like:
//
@@ -391,9 +390,9 @@
override val IrType.sizePropertyGetter
get() = getClass()?.properties?.first { it.name.asString() == "length" }?.let {
it.getter!!
- } ?: context.ir.symbols.charSequence.getPropertyGetter("length")!!.owner
+ } ?: context.ir.symbols.charSequence.getPropertyGetter("length")!!
override val IrType.getFunction
get() = getClass()?.functions?.first { it.name.asString() == "get" }
- ?: context.ir.symbols.charSequence.getSimpleFunction("get")!!.owner
+ ?: context.ir.symbols.charSequence.getSimpleFunction("get")!!
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/Utils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/Utils.kt
index 108102e..c1be0d9 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/Utils.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/Utils.kt
@@ -22,7 +22,7 @@
this
} else {
val function = type.getClass()!!.functions.first { it.name == numberCastFunctionName }
- IrCallImpl(startOffset, endOffset, function.returnType, function.symbol)
+ IrCallImpl(startOffset, endOffset, function.returnType, function)
.apply { dispatchReceiver = this@castIfNecessary }
}
}
@@ -35,7 +35,7 @@
is Long -> IrConstImpl(startOffset, endOffset, type, IrConstKind.Long, -value)
else -> {
val unaryMinusFun = type.getClass()!!.functions.first { it.name == OperatorNameConventions.UNARY_MINUS }
- IrCallImpl(startOffset, endOffset, type, unaryMinusFun.symbol, unaryMinusFun.descriptor).apply {
+ IrCallImpl(startOffset, endOffset, type, unaryMinusFun, unaryMinusFun.descriptor).apply {
dispatchReceiver = this@negate
}
}
@@ -51,7 +51,7 @@
is Char -> IrConstImpl(startOffset, endOffset, type, IrConstKind.Char, thisValue - 1)
else -> {
val decFun = type.getClass()!!.functions.first { it.name == OperatorNameConventions.DEC }
- IrCallImpl(startOffset, endOffset, type, decFun.symbol, decFun.descriptor).apply {
+ IrCallImpl(startOffset, endOffset, type, decFun, decFun.descriptor).apply {
dispatchReceiver = this@decrement
}
}
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/matchers/IrCallMatcher.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/matchers/IrCallMatcher.kt
index d2fc995..aa097ca 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/matchers/IrCallMatcher.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/matchers/IrCallMatcher.kt
@@ -20,7 +20,7 @@
private val calleeRestriction: IrFunctionMatcher = createIrFunctionRestrictions(restrictions)
- override fun invoke(call: IrCall) = calleeRestriction(call.symbol.owner)
+ override fun invoke(call: IrCall) = calleeRestriction(call.target)
}
internal class IrCallExtensionReceiverMatcher(
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrBackendUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrBackendUtils.kt
index 33eb31a..5dc821c 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrBackendUtils.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrBackendUtils.kt
@@ -17,25 +17,24 @@
package org.jetbrains.kotlin.ir.util
import org.jetbrains.kotlin.backend.common.atMostOne
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.declarations.IrProperty
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.name.Name
-fun IrClassSymbol.getPropertyDeclaration(name: String) =
- this.owner.declarations.filterIsInstance<IrProperty>()
+fun IrClass.getPropertyDeclaration(name: String) =
+ this.declarations.filterIsInstance<IrProperty>()
.atMostOne { it.descriptor.name == Name.identifier(name) }
-fun IrClassSymbol.getSimpleFunction(name: String): IrSimpleFunctionSymbol? =
- owner.findDeclaration<IrSimpleFunction> { it.name.asString() == name }?.symbol
+fun IrClass.getSimpleFunction(name: String): IrSimpleFunction? =
+ findDeclaration<IrSimpleFunction> { it.name.asString() == name }
-fun IrClassSymbol.getPropertyGetter(name: String): IrSimpleFunctionSymbol? =
- this.getPropertyDeclaration(name)?.getter?.symbol ?: this.getSimpleFunction("<get-$name>")
+fun IrClass.getPropertyGetter(name: String): IrSimpleFunction? =
+ this.getPropertyDeclaration(name)?.getter ?: this.getSimpleFunction("<get-$name>")
-fun IrClassSymbol.getPropertySetter(name: String): IrSimpleFunctionSymbol? =
- this.getPropertyDeclaration(name)?.setter?.symbol ?: this.getSimpleFunction("<set-$name>")
+fun IrClass.getPropertySetter(name: String): IrSimpleFunction? =
+ this.getPropertyDeclaration(name)?.setter ?: this.getSimpleFunction("<set-$name>")
-fun IrClassSymbol.getPropertyField(name: String): IrFieldSymbol? =
- this.getPropertyDeclaration(name)?.backingField?.symbol
+fun IrClass.getPropertyField(name: String): IrField? =
+ this.getPropertyDeclaration(name)?.backingField
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt
index 4d343e6..91ec177 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/util/IrTypeUtils.kt
@@ -82,12 +82,12 @@
}
fun IrType.substitute(params: List<IrTypeParameter>, arguments: List<IrType>): IrType =
- substitute(params.map { it.symbol }.zip(arguments).toMap())
+ substitute(params.zip(arguments).toMap())
-fun IrType.substitute(substitutionMap: Map<IrTypeParameterSymbol, IrType>): IrType {
+fun IrType.substitute(substitutionMap: Map<IrTypeParameter, IrType>): IrType {
if (this !is IrSimpleType) return this
- substitutionMap[classifier]?.let { return it }
+ substitutionMap[classifier.owner]?.let { return it }
val newArguments = arguments.map {
if (it is IrTypeProjection) {
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt
index 7b2f791..f2fb422 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt
@@ -180,7 +180,7 @@
}!!
val charClassSymbol = getInternalClassWithoutPackage("kotlin.Char")
- val charConstructor = charClassSymbol.constructors.single().owner
+ val charConstructor = charClassSymbol.constructors.single()
val stringClassSymbol = getInternalClassWithoutPackage("kotlin.String")
val stringConstructorSymbol = stringClassSymbol.constructors.single()
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt
index b018332..910fa2d 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt
@@ -128,7 +128,7 @@
private val coroutinePackage = module.getPackage(COROUTINE_PACKAGE_FQNAME)
private val coroutineIntrinsicsPackage = module.getPackage(COROUTINE_INTRINSICS_PACKAGE_FQNAME)
- val enumEntryToGetInstanceFunction = mutableMapOf<IrEnumEntrySymbol, IrSimpleFunction>()
+ val enumEntryToGetInstanceFunction = mutableMapOf<IrEnumEntry, IrSimpleFunction>()
val objectToGetInstanceFunction = mutableMapOf<IrClassSymbol, IrSimpleFunction>()
val enumEntryExternalToInstanceField = mutableMapOf<IrEnumEntrySymbol, IrField>()
val callableReferencesCache = mutableMapOf<CallableReferenceKey, IrSimpleFunction>()
@@ -254,14 +254,14 @@
val suiteFun = getFunctions(FqName("kotlin.test.suite")).singleOrNull()?.let { symbolTable.referenceSimpleFunction(it) }
val testFun = getFunctions(FqName("kotlin.test.test")).singleOrNull()?.let { symbolTable.referenceSimpleFunction(it) }
- val coroutineImplLabelPropertyGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("state")!!.owner }
- val coroutineImplLabelPropertySetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("state")!!.owner }
- val coroutineImplResultSymbolGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("result")!!.owner }
- val coroutineImplResultSymbolSetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("result")!!.owner }
- val coroutineImplExceptionPropertyGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("exception")!!.owner }
- val coroutineImplExceptionPropertySetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("exception")!!.owner }
- val coroutineImplExceptionStatePropertyGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("exceptionState")!!.owner }
- val coroutineImplExceptionStatePropertySetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("exceptionState")!!.owner }
+ val coroutineImplLabelPropertyGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("state")!! }
+ val coroutineImplLabelPropertySetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("state")!! }
+ val coroutineImplResultSymbolGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("result")!! }
+ val coroutineImplResultSymbolSetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("result")!! }
+ val coroutineImplExceptionPropertyGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("exception")!! }
+ val coroutineImplExceptionPropertySetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("exception")!! }
+ val coroutineImplExceptionStatePropertyGetter by lazy { ir.symbols.coroutineImpl.getPropertyGetter("exceptionState")!! }
+ val coroutineImplExceptionStatePropertySetter by lazy { ir.symbols.coroutineImpl.getPropertySetter("exceptionState")!! }
val primitiveClassProperties by lazy {
primitiveClassesObject.owner.declarations.filterIsInstance<IrProperty>()
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt
index 3c7b228..3c2d8af 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt
@@ -390,7 +390,8 @@
val jsPhases = namedIrModulePhase(
name = "IrModuleLowering",
description = "IR module lowering",
- lower = validateIrBeforeLowering then
+ lower = desymbolizePhase then
+ validateIrBeforeLowering then
testGenerationPhase then
expectDeclarationsRemovingPhase then
stripTypeAliasDeclarationsPhase then
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt
index b13b06d6..b9bf082 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt
@@ -26,7 +26,6 @@
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.IrSetVariable
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
@@ -72,7 +71,7 @@
override fun defineSharedValue(originalDeclaration: IrVariable, sharedVariableDeclaration: IrVariable) = sharedVariableDeclaration
- override fun getSharedValue(sharedVariableSymbol: IrVariableSymbol, originalGet: IrGetValue) = IrGetFieldImpl(
+ override fun getSharedValue(sharedVariable: IrVariable, originalGet: IrGetValue) = IrGetFieldImpl(
originalGet.startOffset, originalGet.endOffset,
closureBoxFieldDeclaration.symbol,
originalGet.type,
@@ -80,13 +79,13 @@
originalGet.startOffset,
originalGet.endOffset,
closureBoxType,
- sharedVariableSymbol,
+ sharedVariable,
originalGet.origin
),
originalGet.origin
)
- override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetVariable): IrExpression =
+ override fun setSharedValue(sharedVariable: IrVariable, originalSet: IrSetVariable): IrExpression =
IrSetFieldImpl(
originalSet.startOffset,
originalSet.endOffset,
@@ -95,7 +94,7 @@
originalSet.startOffset,
originalSet.endOffset,
closureBoxType,
- sharedVariableSymbol,
+ sharedVariable,
originalSet.origin
),
originalSet.value,
@@ -181,10 +180,10 @@
declaration.valueParameters += parameterDeclaration
- val receiver = JsIrBuilder.buildGetValue(closureBoxClassDeclaration.thisReceiver!!.symbol)
- val value = JsIrBuilder.buildGetValue(parameterDeclaration.symbol)
+ val receiver = JsIrBuilder.buildGetValue(closureBoxClassDeclaration.thisReceiver!!)
+ val value = JsIrBuilder.buildGetValue(parameterDeclaration)
- val setField = JsIrBuilder.buildSetField(closureBoxFieldDeclaration.symbol, receiver, value, closureBoxFieldDeclaration.type)
+ val setField = JsIrBuilder.buildSetField(closureBoxFieldDeclaration, receiver, value, closureBoxFieldDeclaration.type)
declaration.body = IrBlockBodyImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, listOf(setField))
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt
index 17f1b57..30a6bbc 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt
@@ -15,7 +15,6 @@
import org.jetbrains.kotlin.ir.declarations.impl.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.symbols.impl.*
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.name.Name
@@ -26,11 +25,11 @@
object SYNTHESIZED_STATEMENT : IrStatementOriginImpl("SYNTHESIZED_STATEMENT")
object SYNTHESIZED_DECLARATION : IrDeclarationOriginImpl("SYNTHESIZED_DECLARATION")
- fun buildCall(target: IrFunctionSymbol, type: IrType? = null, typeArguments: List<IrType>? = null): IrCall =
+ fun buildCall(target: IrFunction, type: IrType? = null, typeArguments: List<IrType>? = null): IrCall =
IrCallImpl(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- type ?: target.owner.returnType,
+ type ?: target.returnType,
target,
target.descriptor,
target.descriptor.typeParametersCount,
@@ -42,8 +41,8 @@
}
}
- fun buildReturn(targetSymbol: IrFunctionSymbol, value: IrExpression, type: IrType) =
- IrReturnImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, targetSymbol, value)
+ fun buildReturn(target: IrFunction, value: IrExpression, type: IrType) =
+ IrReturnImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, target, value)
fun buildThrow(type: IrType, value: IrExpression) = IrThrowImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, value)
@@ -142,34 +141,34 @@
fun buildAnonymousInitializer() =
IrAnonymousInitializerImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, SYNTHESIZED_DECLARATION, IrAnonymousInitializerSymbolImpl(WrappedClassDescriptor()))
- fun buildGetObjectValue(type: IrType, classSymbol: IrClassSymbol) =
- IrGetObjectValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, classSymbol)
+ fun buildGetObjectValue(type: IrType, irClass: IrClass) =
+ IrGetObjectValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, irClass)
- fun buildGetValue(symbol: IrValueSymbol) =
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, symbol.owner.type, symbol, SYNTHESIZED_STATEMENT)
+ fun buildGetValue(target: IrValueDeclaration) =
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target.type, target, SYNTHESIZED_STATEMENT)
- fun buildSetVariable(symbol: IrVariableSymbol, value: IrExpression, type: IrType) =
- IrSetVariableImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, symbol, value, SYNTHESIZED_STATEMENT)
+ fun buildSetVariable(target: IrVariable, value: IrExpression, type: IrType) =
+ IrSetVariableImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, target, value, SYNTHESIZED_STATEMENT)
- fun buildGetField(symbol: IrFieldSymbol, receiver: IrExpression?, superQualifierSymbol: IrClassSymbol? = null, type: IrType? = null) =
+ fun buildGetField(target: IrField, receiver: IrExpression?, irSuperQualifier: IrClass? = null, type: IrType? = null) =
IrGetFieldImpl(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- symbol,
- type ?: symbol.owner.type,
+ target,
+ type ?: target.type,
receiver,
SYNTHESIZED_STATEMENT,
- superQualifierSymbol
+ irSuperQualifier
)
fun buildSetField(
- symbol: IrFieldSymbol,
+ target: IrField,
receiver: IrExpression?,
value: IrExpression,
type: IrType,
- superQualifierSymbol: IrClassSymbol? = null
+ irSuperQualifier: IrClass? = null
) =
- IrSetFieldImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, symbol, receiver, value, type, SYNTHESIZED_STATEMENT, superQualifierSymbol)
+ IrSetFieldImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target, receiver, value, type, SYNTHESIZED_STATEMENT, irSuperQualifier)
fun buildBlockBody(statements: List<IrStatement>) = IrBlockBodyImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, statements)
@@ -180,8 +179,8 @@
fun buildComposite(type: IrType, statements: List<IrStatement> = emptyList()) =
IrCompositeImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, SYNTHESIZED_STATEMENT, statements)
- fun buildFunctionReference(type: IrType, symbol: IrFunctionSymbol) =
- IrFunctionReferenceImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, symbol, symbol.descriptor, 0, null)
+ fun buildFunctionReference(type: IrType, target: IrFunction) =
+ IrFunctionReferenceImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, target, target.descriptor, 0, null)
fun buildVar(
type: IrType,
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/AutoboxingTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/AutoboxingTransformer.kt
index 4dd202d..9df6c35 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/AutoboxingTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/AutoboxingTransformer.kt
@@ -35,7 +35,7 @@
}
is IrGetObjectValue ->
- this.symbol == irBuiltIns.unitClass
+ this.target == irBuiltIns.unitClass
else -> false
}
@@ -43,16 +43,16 @@
override fun IrExpression.useAs(type: IrType): IrExpression {
val actualType = when (this) {
- is IrConstructorCall -> symbol.owner.returnType
+ is IrConstructorCall -> target.returnType
is IrCall -> {
- val function = this.symbol.owner
+ val function = this.target
if (function.let { it is IrSimpleFunction && it.isSuspend }) {
irBuiltIns.anyNType
} else {
function.realOverrideTarget.returnType
}
}
- is IrGetField -> this.symbol.owner.type
+ is IrGetField -> this.target.type
is IrTypeOperatorCall -> when (this.operator) {
IrTypeOperator.IMPLICIT_INTEGER_COERCION ->
@@ -65,7 +65,7 @@
}
is IrGetValue -> {
- val value = this.symbol.owner
+ val value = this.target
if (value is IrValueParameter && value.isDispatchReceiver) {
irBuiltIns.anyNType
} else {
@@ -132,11 +132,11 @@
val nullCheck = buildIfElse(
type = resultType,
cond = buildCall(irBuiltIns.eqeqSymbol).apply {
- putValueArgument(0, buildGetValue(tmp.symbol))
+ putValueArgument(0, buildGetValue(tmp))
putValueArgument(1, buildNull(irBuiltIns.nothingNType))
},
thenBranch = buildNull(irBuiltIns.nothingNType),
- elseBranch = call(buildGetValue(tmp.symbol))
+ elseBranch = call(buildGetValue(tmp))
)
buildBlock(
type = resultType,
@@ -148,24 +148,21 @@
}
}
- private val IrFunctionAccessExpression.target: IrFunction
+ private val IrFunctionAccessExpression.callTarget: IrFunction
get() = when (this) {
- is IrConstructorCall -> this.symbol.owner
- is IrDelegatingConstructorCall -> this.symbol.owner
- is IrCall -> this.callTarget
+ is IrConstructorCall -> this.target
+ is IrDelegatingConstructorCall -> this.target
+ is IrCall -> this.target.realOverrideTarget
else -> TODO(this.render())
}
- private val IrCall.callTarget: IrFunction
- get() = symbol.owner.realOverrideTarget
-
override fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression): IrExpression {
- return this.useAsArgument(expression.target.dispatchReceiverParameter!!)
+ return this.useAsArgument(expression.callTarget.dispatchReceiverParameter!!)
}
override fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression): IrExpression {
- return this.useAsArgument(expression.target.extensionReceiverParameter!!)
+ return this.useAsArgument(expression.callTarget.extensionReceiverParameter!!)
}
override fun IrExpression.useAsValueArgument(
@@ -173,7 +170,7 @@
parameter: IrValueParameter
): IrExpression {
- return this.useAsArgument(expression.target.valueParameters[parameter.index])
+ return this.useAsArgument(expression.callTarget.valueParameters[parameter.index])
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt
index 9fa8c92..56f7646 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt
@@ -25,7 +25,7 @@
class JsBlockDecomposerLowering(val context: JsIrBackendContext) : AbstractBlockDecomposerLowering(context) {
override fun unreachableExpression(): IrExpression =
- JsIrBuilder.buildCall(context.intrinsics.unreachable.symbol, context.irBuiltIns.nothingType)
+ JsIrBuilder.buildCall(context.intrinsics.unreachable, context.irBuiltIns.nothingType)
}
abstract class AbstractBlockDecomposerLowering(context: CommonBackendContext) : DeclarationContainerLoweringPass {
@@ -58,7 +58,7 @@
private fun IrExpressionBody.toBlockBody(containingFunction: IrFunction): IrBlockBody {
expression.patchDeclarationParents(containingFunction)
- val returnStatement = JsIrBuilder.buildReturn(containingFunction.symbol, expression, nothingType)
+ val returnStatement = JsIrBuilder.buildReturn(containingFunction, expression, nothingType)
return IrBlockBodyImpl(expression.startOffset, expression.endOffset).apply {
statements += returnStatement
}
@@ -81,7 +81,7 @@
val lastStatement = newBody.statements.last()
if (newBody.statements.size > 1 || lastStatement !is IrReturn || lastStatement.value != expression) {
- expression = JsIrBuilder.buildCall(initFunction.symbol, expression.type)
+ expression = JsIrBuilder.buildCall(initFunction, expression.type)
return listOf(initFunction, irField)
}
}
@@ -166,7 +166,7 @@
val composite = expression.value as? IrComposite ?: return expression
return materializeLastExpression(composite) {
- IrReturnImpl(expression.startOffset, expression.endOffset, expression.type, expression.returnTargetSymbol, it)
+ IrReturnImpl(expression.startOffset, expression.endOffset, expression.type, expression.irReturnTarget, it)
}
}
@@ -209,12 +209,12 @@
IrSetFieldImpl(
startOffset,
endOffset,
- symbol,
- JsIrBuilder.buildGetValue(irVar.symbol),
+ target,
+ JsIrBuilder.buildGetValue(irVar),
setValue,
type,
origin,
- superQualifierSymbol
+ irSuperQualifier
)
}
return result
@@ -223,7 +223,7 @@
if (receiverResult != null) {
return materializeLastExpression(receiverResult) {
expression.run {
- IrSetFieldImpl(startOffset, endOffset, symbol, it, value, type, origin, superQualifierSymbol)
+ IrSetFieldImpl(startOffset, endOffset, target, it, value, type, origin, irSuperQualifier)
}
}
}
@@ -233,12 +233,12 @@
val receiver = expression.receiver?.let {
val irVar = makeTempVar(it.type, it)
valueResult!!.statements.add(0, irVar)
- JsIrBuilder.buildGetValue(irVar.symbol)
+ JsIrBuilder.buildGetValue(irVar)
}
return materializeLastExpression(valueResult!!) {
expression.run {
- IrSetFieldImpl(startOffset, endOffset, symbol, receiver, it, type, origin, superQualifierSymbol)
+ IrSetFieldImpl(startOffset, endOffset, target, receiver, it, type, origin, irSuperQualifier)
}
}
}
@@ -249,7 +249,7 @@
val composite = expression.value as? IrComposite ?: return expression
return materializeLastExpression(composite) {
- expression.run { IrSetVariableImpl(startOffset, endOffset, type, symbol, it, origin) }
+ expression.run { IrSetVariableImpl(startOffset, endOffset, type, target, it, origin) }
}
}
@@ -420,7 +420,7 @@
val composite = expression.receiver as? IrComposite ?: return expression
return materializeLastExpression(composite) {
- expression.run { IrGetFieldImpl(startOffset, endOffset, symbol, type, it, origin, superQualifierSymbol) }
+ expression.run { IrGetFieldImpl(startOffset, endOffset, target, type, it, origin, irSuperQualifier) }
}
}
@@ -489,7 +489,7 @@
// TODO: do not wrap if value is pure (const, variable, etc)
val irVar = makeTempVar(value.type, value)
newStatements += irVar
- JsIrBuilder.buildGetValue(irVar.symbol)
+ JsIrBuilder.buildGetValue(irVar)
}
}
@@ -632,7 +632,7 @@
expression as? IrBlock ?: expression.let { IrBlockImpl(it.startOffset, it.endOffset, it.type, null, listOf(it)) }
private fun wrap(expression: IrExpression, variable: IrVariable) =
- wrap(JsIrBuilder.buildSetVariable(variable.symbol, expression, unitType))
+ wrap(JsIrBuilder.buildSetVariable(variable, expression, unitType))
// try {
// try_block {}
@@ -663,7 +663,7 @@
val newTry = aTry.run { IrTryImpl(startOffset, endOffset, unitType, newTryResult, newCatches, finallyExpression) }
newTry.transformChildrenVoid(statementTransformer)
- val newStatements = listOf(irVar, newTry, JsIrBuilder.buildGetValue(irVar.symbol))
+ val newStatements = listOf(irVar, newTry, JsIrBuilder.buildGetValue(irVar))
return JsIrBuilder.buildComposite(aTry.type, newStatements)
}
@@ -714,7 +714,7 @@
expression.run { IrWhenImpl(startOffset, endOffset, unitType, origin, newBranches) }
.transform(statementTransformer, null) // deconstruct into `if-else` chain
- return JsIrBuilder.buildComposite(expression.type, listOf(irVar, newWhen, JsIrBuilder.buildGetValue(irVar.symbol)))
+ return JsIrBuilder.buildComposite(expression.type, listOf(irVar, newWhen, JsIrBuilder.buildGetValue(irVar)))
} else {
val newBranches = decomposedResults.map { (branch, condition, result) ->
when {
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt
index dd0e9c3..5b18581 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BridgesConstruction.kt
@@ -18,7 +18,6 @@
import org.jetbrains.kotlin.backend.common.lower.irBlockBody
import org.jetbrains.kotlin.backend.common.lower.irNot
import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.backend.js.JsLoweredDeclarationOrigin
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.backend.js.utils.functionSignature
@@ -140,7 +139,7 @@
extensionReceiverParameter = bridge.extensionReceiverParameter?.copyTo(this)
valueParameters += bridge.valueParameters.map { p -> p.copyTo(this) }
annotations += bridge.annotations
- overriddenSymbols.addAll(delegateTo.overriddenSymbols)
+ overridden.addAll(delegateTo.overridden)
}
context.createIrBuilder(irFunction.symbol).irBlockBody(irFunction) {
@@ -190,7 +189,7 @@
!function.parentAsClass.isInterface
override fun getOverridden() =
- function.overriddenSymbols.map { IrBasedFunctionHandle(it.owner) }
+ function.overridden.map { IrBasedFunctionHandle(it) }
}
// Wrapper around function that compares and hashCodes it based on signature
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt
index 82b6db6..df7e404 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CallableReferenceLowering.kt
@@ -22,7 +22,6 @@
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
import org.jetbrains.kotlin.ir.types.IrSimpleType
@@ -64,7 +63,7 @@
inner class CallableReferenceLowerTransformer : IrElementTransformerVoid() {
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
expression.transformChildrenVoid(this)
- val declaration = expression.symbol.owner
+ val declaration = expression.target
if (declaration.origin == JsIrBackendContext.callableClosureOrigin) return expression
val key = makeCallableKey(declaration, expression)
val factory = callableToFactoryFunction.getOrPut(key) { lowerKFunctionReference(declaration, expression) }
@@ -73,7 +72,7 @@
override fun visitPropertyReference(expression: IrPropertyReference): IrExpression {
expression.transformChildrenVoid(this)
- val declaration = expression.getter!!.owner
+ val declaration = expression.getter!!
val key = makeCallableKey(declaration, expression)
val factory = callableToFactoryFunction.getOrPut(key) { lowerKPropertyReference(declaration, expression) }
return redirectToFunction(expression, factory)
@@ -81,7 +80,7 @@
override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrExpression {
expression.transformChildrenVoid(this)
- val key = makeCallableKey(expression.getter.owner, expression)
+ val key = makeCallableKey(expression.getter, expression)
val factory = callableToFactoryFunction.getOrPut(key) { lowerLocalKPropertyReference(expression) }
return redirectToFunction(expression, factory)
}
@@ -159,7 +158,7 @@
val closureFunction = buildClosureFunction(declaration, factoryFunction, functionReference, functionReference.type.arity)
val additionalDeclarations = generateFactoryBodyWithGuard(factoryFunction) {
- val irClosureReference = JsIrBuilder.buildFunctionReference(functionReference.type, closureFunction.symbol)
+ val irClosureReference = JsIrBuilder.buildFunctionReference(functionReference.type, closureFunction)
val irVar = JsIrBuilder.buildVar(irClosureReference.type, factoryFunction, initializer = irClosureReference)
@@ -168,7 +167,7 @@
JsIrBuilder.buildString(context.irBuiltIns.stringType, getReferenceName(declaration))
}
- Pair(listOf(closureFunction, irVar, irSetName), irVar.symbol)
+ Pair(listOf(closureFunction, irVar, irSetName), irVar)
}
newDeclarations += additionalDeclarations + factoryFunction
@@ -198,31 +197,31 @@
val arity = propertyReference.type.arity
val factoryName = createPropertyFactoryName(getterDeclaration.correspondingPropertySymbol!!.owner)
- val factoryFunction = buildFactoryFunction(propertyReference.getter!!.owner, propertyReference, factoryName)
+ val factoryFunction = buildFactoryFunction(propertyReference.getter!!, propertyReference, factoryName)
- val getterFunction = propertyReference.getter?.let { buildClosureFunction(it.owner, factoryFunction, propertyReference, arity) }!!
- val setterFunction = propertyReference.setter?.let { buildClosureFunction(it.owner, factoryFunction, propertyReference, arity + 1) }
+ val getterFunction = propertyReference.getter?.let { buildClosureFunction(it, factoryFunction, propertyReference, arity) }!!
+ val setterFunction = propertyReference.setter?.let { buildClosureFunction(it, factoryFunction, propertyReference, arity + 1) }
val additionalDeclarations = generateFactoryBodyWithGuard(factoryFunction) {
val statements = mutableListOf<IrStatement>(getterFunction)
- val getterFunctionTypeSymbol = context.ir.symbols.functionN(getterFunction.valueParameters.size + 1)
+ val getterFunctionClass = context.ir.symbols.functionN(getterFunction.valueParameters.size + 1)
- val getterFunctionIrType = IrSimpleTypeImpl(getterFunctionTypeSymbol, false, emptyList(), emptyList())
- val irGetReference = JsIrBuilder.buildFunctionReference(getterFunctionIrType, getterFunction.symbol)
+ val getterFunctionIrType = IrSimpleTypeImpl(getterFunctionClass.symbol, false, emptyList(), emptyList())
+ val irGetReference = JsIrBuilder.buildFunctionReference(getterFunctionIrType, getterFunction)
val irVar = JsIrBuilder.buildVar(getterFunctionIrType, factoryFunction, initializer = irGetReference)
statements += irVar
statements += setDynamicProperty(irVar.symbol, Namer.KPROPERTY_GET) {
- JsIrBuilder.buildGetValue(irVar.symbol)
+ JsIrBuilder.buildGetValue(irVar)
}
if (setterFunction != null) {
statements += setterFunction
- val setterFunctionTypeSymbol = context.ir.symbols.functionN(setterFunction.valueParameters.size + 1)
- val setterFunctionIrType = IrSimpleTypeImpl(setterFunctionTypeSymbol, false, emptyList(), emptyList())
- val irSetReference = JsIrBuilder.buildFunctionReference(setterFunctionIrType, setterFunction.symbol)
+ val setterFunctionClass = context.ir.symbols.functionN(setterFunction.valueParameters.size + 1)
+ val setterFunctionIrType = IrSimpleTypeImpl(setterFunctionClass.symbol, false, emptyList(), emptyList())
+ val irSetReference = JsIrBuilder.buildFunctionReference(setterFunctionIrType, setterFunction)
statements += setDynamicProperty(irVar.symbol, Namer.KPROPERTY_SET) { irSetReference }
}
@@ -234,7 +233,7 @@
)
}
- Pair(statements, irVar.symbol)
+ Pair(statements, irVar)
}
newDeclarations += additionalDeclarations + factoryFunction
@@ -258,31 +257,30 @@
// }
val arity = propertyReference.type.arity
- val declaration = propertyReference.delegate.owner
+ val declaration = propertyReference.delegate
val factoryName = createPropertyFactoryName(declaration)
- val factoryFunction = buildFactoryFunction(propertyReference.getter.owner, propertyReference, factoryName)
+ val factoryFunction = buildFactoryFunction(propertyReference.getter, propertyReference, factoryName)
val closureFunction = buildClosureFunction(context.irBuiltIns.throwIseSymbol.owner, factoryFunction, propertyReference, arity)
val additionalDeclarations = generateFactoryBodyWithGuard(factoryFunction) {
val statements = mutableListOf<IrStatement>(closureFunction)
- val getterFunctionTypeSymbol = context.ir.symbols.functionN(closureFunction.valueParameters.size + 1)
- val getterFunctionIrType = IrSimpleTypeImpl(getterFunctionTypeSymbol, false, emptyList(), emptyList())
- val irGetReference = JsIrBuilder.buildFunctionReference(getterFunctionIrType, closureFunction.symbol)
+ val getterFunctionClass = context.ir.symbols.functionN(closureFunction.valueParameters.size + 1)
+ val getterFunctionIrType = IrSimpleTypeImpl(getterFunctionClass.symbol, false, emptyList(), emptyList())
+ val irGetReference = JsIrBuilder.buildFunctionReference(getterFunctionIrType, closureFunction)
val irVar = JsIrBuilder.buildVar(getterFunctionIrType, factoryFunction, initializer = irGetReference)
- val irVarSymbol = irVar.symbol
statements += irVar
- statements += setDynamicProperty(irVarSymbol, Namer.KPROPERTY_GET) {
- JsIrBuilder.buildGetValue(irVarSymbol)
+ statements += setDynamicProperty(irVar, Namer.KPROPERTY_GET) {
+ JsIrBuilder.buildGetValue(irVar)
}
- statements += setDynamicProperty(irVarSymbol, Namer.KCALLABLE_NAME) {
+ statements += setDynamicProperty(irVar, Namer.KCALLABLE_NAME) {
JsIrBuilder.buildString(context.irBuiltIns.stringType, getReferenceName(declaration))
}
- Pair(statements, irVarSymbol)
+ Pair(statements, irVar)
}
newDeclarations += additionalDeclarations + factoryFunction
@@ -292,10 +290,10 @@
private fun generateFactoryBodyWithGuard(
factoryFunction: IrSimpleFunction,
- builder: () -> Pair<List<IrStatement>, IrValueSymbol>
+ builder: () -> Pair<List<IrStatement>, IrValueDeclaration>
): List<IrDeclaration> {
- val (bodyStatements, varSymbol) = builder()
+ val (bodyStatements, variable) = builder()
val statements = mutableListOf<IrStatement>()
val returnValue: IrExpression
val returnStatements: List<IrDeclaration>
@@ -310,13 +308,13 @@
val irNull = { JsIrBuilder.buildNull(context.irBuiltIns.nothingNType) }
val cacheVar = JsIrBuilder.buildVar(type, factoryFunction.parent, cacheName, true, initializer = irNull())
- val irCacheValue = { JsIrBuilder.buildGetValue(cacheVar.symbol) }
+ val irCacheValue = { JsIrBuilder.buildGetValue(cacheVar) }
val irIfCondition = JsIrBuilder.buildCall(context.irBuiltIns.eqeqSymbol).apply {
putValueArgument(0, irCacheValue())
putValueArgument(1, irNull())
}
val irSetCache =
- JsIrBuilder.buildSetVariable(cacheVar.symbol, JsIrBuilder.buildGetValue(varSymbol), context.irBuiltIns.unitType)
+ JsIrBuilder.buildSetVariable(cacheVar, JsIrBuilder.buildGetValue(variable), context.irBuiltIns.unitType)
val thenStatements = mutableListOf<IrStatement>().apply {
addAll(bodyStatements)
add(irSetCache)
@@ -328,11 +326,11 @@
returnStatements = listOf(cacheVar)
} else {
statements += bodyStatements
- returnValue = JsIrBuilder.buildGetValue(varSymbol)
+ returnValue = JsIrBuilder.buildGetValue(variable)
returnStatements = emptyList()
}
- statements += JsIrBuilder.buildReturn(factoryFunction.symbol, returnValue, context.irBuiltIns.nothingType)
+ statements += JsIrBuilder.buildReturn(factoryFunction, returnValue, context.irBuiltIns.nothingType)
factoryFunction.body = JsIrBuilder.buildBlockBody(statements)
return returnStatements
@@ -491,9 +489,8 @@
)
// the params which are passed to closure
- val boundParamSymbols = factoryFunction.valueParameters.map { it.symbol }
+ val boundParamDeclarations = factoryFunction.valueParameters
val unboundParamDeclarations = generateSignatureForClosure(declaration, factoryFunction, closureFunction, reference, arity)
- val unboundParamSymbols = unboundParamDeclarations.map { it.symbol }
closureFunction.valueParameters += unboundParamDeclarations
@@ -503,7 +500,7 @@
val irCall =
if (target is IrConstructorSymbol) IrConstructorCallImpl.fromSymbolOwner(returnType, target) else JsIrBuilder.buildCall(
- callTarget.symbol,
+ callTarget,
type = returnType
)
@@ -512,31 +509,31 @@
if (callTarget.dispatchReceiverParameter != null) {
val dispatchReceiverDeclaration =
- if (reference.dispatchReceiver != null) boundParamSymbols[gp++] else unboundParamSymbols[cp++]
+ if (reference.dispatchReceiver != null) boundParamDeclarations[gp++] else unboundParamDeclarations[cp++]
irCall.dispatchReceiver = JsIrBuilder.buildGetValue(dispatchReceiverDeclaration)
}
if (callTarget.extensionReceiverParameter != null) {
val extensionReceiverDeclaration =
- if (reference.extensionReceiver != null) boundParamSymbols[gp++] else unboundParamSymbols[cp++]
+ if (reference.extensionReceiver != null) boundParamDeclarations[gp++] else unboundParamDeclarations[cp++]
irCall.extensionReceiver = JsIrBuilder.buildGetValue(extensionReceiverDeclaration)
}
var j = 0
- for (i in gp until boundParamSymbols.size) {
- irCall.putValueArgument(j++, JsIrBuilder.buildGetValue(boundParamSymbols[i]))
+ for (i in gp until boundParamDeclarations.size) {
+ irCall.putValueArgument(j++, JsIrBuilder.buildGetValue(boundParamDeclarations[i]))
}
- for (i in cp until unboundParamSymbols.size) {
- val closureParam = unboundParamSymbols[i].owner
- val value = JsIrBuilder.buildGetValue(unboundParamSymbols[i])
+ for (i in cp until unboundParamDeclarations.size) {
+ val closureParam = unboundParamDeclarations[i]
+ val value = JsIrBuilder.buildGetValue(unboundParamDeclarations[i])
val parameter = callTarget.valueParameters[j]
val argument =
if (parameter.varargElementType == closureParam.type) {
// fun foo(x: X, vararg y: Y): Z
// val r: (X, Y) -> Z = ::foo
- val tailValues = unboundParamSymbols.drop(i)
+ val tailValues = unboundParamDeclarations.drop(i)
IrVarargImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, parameter.type, parameter.varargElementType!!, tailValues.map {
JsIrBuilder.buildGetValue(it)
})
@@ -545,14 +542,14 @@
if (j == callTarget.valueParameters.size) break
}
- val irClosureReturn = JsIrBuilder.buildReturn(closureFunction.symbol, irCall, context.irBuiltIns.nothingType)
+ val irClosureReturn = JsIrBuilder.buildReturn(closureFunction, irCall, context.irBuiltIns.nothingType)
closureFunction.body = JsIrBuilder.buildBlockBody(listOf(irClosureReturn))
return closureFunction
}
- private inline fun setDynamicProperty(r: IrValueSymbol, property: String, value: () -> IrExpression): IrStatement {
+ private inline fun setDynamicProperty(r: IrValueDeclaration, property: String, value: () -> IrExpression): IrStatement {
return IrDynamicOperatorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, context.irBuiltIns.unitType, IrDynamicOperator.EQ).apply {
receiver = IrDynamicMemberExpressionImpl(startOffset, endOffset, context.dynamicType, property, JsIrBuilder.buildGetValue(r))
arguments += value()
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ClassReferenceLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ClassReferenceLowering.kt
index 8a75b14..f937d41 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ClassReferenceLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ClassReferenceLowering.kt
@@ -78,7 +78,7 @@
}
private fun getPrimitiveClass(target: IrSimpleFunction, returnType: IrType) =
- JsIrBuilder.buildCall(target.symbol, returnType).apply {
+ JsIrBuilder.buildCall(target, returnType).apply {
dispatchReceiver = JsIrBuilder.buildGetObjectValue(primitiveClassesObject.owner.defaultType, primitiveClassesObject)
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ConstLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ConstLowering.kt
index b3408b7..a39daf6 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ConstLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ConstLowering.kt
@@ -32,7 +32,7 @@
vararg args: C
): IrExpression {
val constructor = irClass.constructors.single()
- val argType = constructor.owner.valueParameters.first().type
+ val argType = constructor.valueParameters.first().type
return IrConstructorCallImpl.fromSymbolOwner(irClass.owner.defaultType, constructor).apply {
for (i in args.indices) {
putValueArgument(i, carrierFactory(UNDEFINED_OFFSET, UNDEFINED_OFFSET, argType, args[i]))
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt
index c2ded07..8536d19 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt
@@ -45,7 +45,7 @@
override fun lower(irFile: IrFile) {
irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetEnumValue(expression: IrGetEnumValue): IrExpression {
- val enumEntry = expression.symbol.owner
+ val enumEntry = expression.target
val klass = enumEntry.parent as IrClass
return if (klass.isExternal) lowerExternalEnumEntry(enumEntry, klass) else lowerEnumEntry(enumEntry, klass)
}
@@ -54,7 +54,7 @@
private fun lowerExternalEnumEntry(enumEntry: IrEnumEntry, klass: IrClass) =
context.enumEntryExternalToInstanceField.getOrPut(enumEntry.symbol) { createFieldForEntry(enumEntry, klass) }.let {
- JsIrBuilder.buildGetField(it.symbol, classAsReceiver(klass), null, klass.defaultType)
+ JsIrBuilder.buildGetField(it, classAsReceiver(klass), null, klass.defaultType)
}
private fun classAsReceiver(irClass: IrClass): IrExpression {
@@ -75,13 +75,13 @@
}
private fun lowerEnumEntry(enumEntry: IrEnumEntry, klass: IrClass) =
- context.enumEntryToGetInstanceFunction.getOrPut(enumEntry.symbol) {
+ context.enumEntryToGetInstanceFunction.getOrPut(enumEntry) {
JsIrBuilder.buildFunction(
createEntryAccessorName(klass.name.identifier, enumEntry),
returnType = enumEntry.getType(klass),
parent = klass
)
- }.run { JsIrBuilder.buildCall(symbol) }
+ }.run { JsIrBuilder.buildCall(this) }
}
class EnumClassLowering(val context: JsIrBackendContext) : DeclarationContainerLoweringPass {
@@ -222,14 +222,14 @@
}
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall) =
- builder.irDelegatingConstructorCall(expression.symbol.owner).apply {
+ builder.irDelegatingConstructorCall(expression.target).apply {
for (i in 0..1) {
putValueArgument(i, builder.irGet(constructor.valueParameters[i]))
}
}
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
- var delegatingConstructor = expression.symbol.owner
+ var delegatingConstructor = expression.target
val constructorWasTransformed = delegatingConstructor.symbol in loweredEnumConstructors
if (constructorWasTransformed)
@@ -261,7 +261,7 @@
irClass.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrExpression {
- fromOldToNewParameter[expression.symbol]?.let {
+ fromOldToNewParameter[expression.target]?.let {
return builder.irGet(it)
}
@@ -289,7 +289,7 @@
builder.irCall(constructor)
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrExpression {
- var constructor = expression.symbol.owner
+ var constructor = expression.target
val constructorWasTransformed = constructor.symbol in loweredEnumConstructors
// Enum entry class constructors are not transformed
@@ -457,7 +457,7 @@
initEntryInstancesFun: IrSimpleFunction,
entryInstances: List<IrField>
) = enumEntries.mapIndexed { index, enumEntry ->
- context.enumEntryToGetInstanceFunction.getOrPut(enumEntry.symbol) {
+ context.enumEntryToGetInstanceFunction.getOrPut(enumEntry) {
buildFunction(createEntryAccessorName(enumName, enumEntry), enumEntry.getType(irClass))
}.apply {
body = context.createIrBuilder(symbol).irBlockBody(this) {
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt
index c998974..7d1ee24 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt
@@ -24,7 +24,6 @@
import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
-import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
class JsDefaultArgumentStubGenerator(override val context: JsIrBackendContext) : DefaultArgumentStubGenerator(context, true, true) {
@@ -50,7 +49,7 @@
private fun resolveInvoke(paramCount: Int): IrSimpleFunction {
assert(paramCount > 0)
- val functionKlass = context.ir.symbols.functionN(paramCount).owner
+ val functionKlass = context.ir.symbols.functionN(paramCount)
return functionKlass.declarations.filterIsInstance<IrSimpleFunction>().first { it.name == Name.identifier("invoke") }
}
}
@@ -62,7 +61,7 @@
irBody.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitCall(expression: IrCall): IrExpression {
super.visitCall(expression)
- if (expression.origin != DEFAULT_DISPATCH_CALL || expression.superQualifierSymbol == null) return expression
+ if (expression.origin != DEFAULT_DISPATCH_CALL || expression.irSuperQualifier == null) return expression
val binding = buildBoundSuperCall(expression)
@@ -75,7 +74,7 @@
private fun buildBoundSuperCall(irCall: IrCall): IrExpression {
- val originalFunction = context.ir.defaultParameterDeclarationsCache.entries.first { it.value == irCall.symbol.owner }.key
+ val originalFunction = context.ir.defaultParameterDeclarationsCache.entries.first { it.value == irCall.target }.key
val reference = irCall.run {
IrFunctionReferenceImpl(
@@ -97,7 +96,7 @@
context.intrinsics.jsBind.symbol,
context.intrinsics.jsBind.descriptor,
BIND_CALL,
- superQualifierSymbol
+ irSuperQualifier
)
}.apply {
putValueArgument(0, irCall.dispatchReceiver?.deepCopyWithSymbols())
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt
index 3287984..a926606 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MultipleCatchesLowering.kt
@@ -63,7 +63,7 @@
if (aTry.catches.isEmpty()) return aTry.also { assert(it.finallyExpression != null) }
val pendingExceptionDeclaration = JsIrBuilder.buildVar(context.dynamicType, data, "\$p")
- val pendingException = { JsIrBuilder.buildGetValue(pendingExceptionDeclaration.symbol) }
+ val pendingException = { JsIrBuilder.buildGetValue(pendingExceptionDeclaration) }
val branches = mutableListOf<IrBranch>()
var isCaughtDynamic = false
@@ -81,7 +81,7 @@
val catchBody = catch.result.transform(object : IrElementTransformer<IrValueSymbol> {
override fun visitGetValue(expression: IrGetValue, data: IrValueSymbol) =
- if (expression.symbol == data)
+ if (expression.target == data)
castedPendingException()
else
expression
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ObjectLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ObjectLowering.kt
index 3c6b1f2..c7551c7 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ObjectLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ObjectLowering.kt
@@ -13,7 +13,6 @@
import org.jetbrains.kotlin.backend.common.lower.irIfThen
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.builders.*
import org.jetbrains.kotlin.ir.builders.declarations.buildField
@@ -83,9 +82,9 @@
override fun lower(irFile: IrFile) {
irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetObjectValue(expression: IrGetObjectValue): IrExpression {
- val obj: IrClass = expression.symbol.owner
+ val obj: IrClass = expression.target
if (obj.isEffectivelyExternal()) return expression
- return JsIrBuilder.buildCall(getOrCreateGetInstanceFunction(objectToGetInstanceFunction, obj).symbol)
+ return JsIrBuilder.buildCall(getOrCreateGetInstanceFunction(objectToGetInstanceFunction, obj))
}
})
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrimitiveCompanionLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrimitiveCompanionLowering.kt
index 6072e60..a1d6de8 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrimitiveCompanionLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrimitiveCompanionLowering.kt
@@ -53,7 +53,7 @@
override fun lower(irFile: IrFile) {
irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetObjectValue(expression: IrGetObjectValue): IrExpression {
- val irClass = expression.symbol.owner
+ val irClass = expression.target
val actualCompanion = getActualPrimitiveCompanion(irClass) ?: return expression
return IrGetObjectValueImpl(
expression.startOffset,
@@ -66,7 +66,7 @@
override fun visitCall(expression: IrCall): IrExpression {
val newCall = super.visitCall(expression) as IrCall
- val function = expression.symbol.owner as IrSimpleFunction
+ val function = expression.target as IrSimpleFunction
val actualFunction = getActualPrimitiveCompanionPropertyAccessor(function)
?: return newCall
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt
index 99bcc83..d2860ccc 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt
@@ -69,7 +69,7 @@
override fun visitCall(expression: IrCall): IrExpression {
super.visitCall(expression)
- return memberMap[expression.symbol]?.let {
+ return memberMap[expression.target]?.let {
transformPrivateToStaticCall(expression, it)
} ?: expression
}
@@ -77,7 +77,7 @@
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
super.visitFunctionReference(expression)
- return memberMap[expression.symbol]?.let {
+ return memberMap[expression.target]?.let {
transformPrivateToStaticReference(expression) {
IrFunctionReferenceImpl(
expression.startOffset, expression.endOffset,
@@ -98,7 +98,7 @@
IrPropertyReferenceImpl(
expression.startOffset, expression.endOffset,
expression.type,
- expression.symbol, // TODO remap property symbol based on remapped getter/setter?
+ expression.target, // TODO remap property symbol based on remapped getter/setter?
expression.typeArgumentsCount,
expression.field,
memberMap[expression.getter]?.symbol ?: expression.getter,
@@ -116,7 +116,7 @@
staticTarget.symbol, staticTarget.descriptor,
expression.typeArgumentsCount,
expression.origin,
- expression.superQualifierSymbol
+ expression.irSuperQualifier
)
newExpression.extensionReceiver = expression.extensionReceiver
@@ -213,7 +213,7 @@
staticFunction.body = function.body?.deepCopyWithSymbols(staticFunction)
staticFunction.transform(object : IrElementTransformerVoid() {
- override fun visitGetValue(expression: IrGetValue) = parameterMapping[expression.symbol.owner]?.let {
+ override fun visitGetValue(expression: IrGetValue) = parameterMapping[expression.target]?.let {
expression.run { IrGetValueImpl(startOffset, endOffset, type, it.symbol, origin) }
} ?: expression
}, null)
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt
index 81f5660..0147562 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/SecondaryCtorLowering.kt
@@ -83,19 +83,19 @@
private fun generateFactoryBody(constructor: IrConstructor, irClass: IrClass, stub: IrSimpleFunction, delegate: IrSimpleFunction) {
val type = irClass.defaultType
val createFunctionIntrinsic = context.intrinsics.jsObjectCreate
- val irCreateCall = JsIrBuilder.buildCall(createFunctionIntrinsic.symbol, type, listOf(type))
- val irDelegateCall = JsIrBuilder.buildCall(delegate.symbol, type).also { call ->
+ val irCreateCall = JsIrBuilder.buildCall(createFunctionIntrinsic, type, listOf(type))
+ val irDelegateCall = JsIrBuilder.buildCall(delegate, type).also { call ->
for (i in 0 until stub.typeParameters.size) {
call.putTypeArgument(i, stub.typeParameters[i].toIrType())
}
for (i in 0 until stub.valueParameters.size) {
- call.putValueArgument(i, JsIrBuilder.buildGetValue(stub.valueParameters[i].symbol))
+ call.putValueArgument(i, JsIrBuilder.buildGetValue(stub.valueParameters[i]))
}
call.putValueArgument(constructor.valueParameters.size, irCreateCall)
}
- val irReturn = JsIrBuilder.buildReturn(stub.symbol, irDelegateCall, context.irBuiltIns.nothingType)
+ val irReturn = JsIrBuilder.buildReturn(stub, irDelegateCall, context.irBuiltIns.nothingType)
stub.body = JsIrBuilder.buildBlockBody(listOf(irReturn))
@@ -104,7 +104,7 @@
private fun generateInitBody(constructor: IrConstructor, irClass: IrClass, delegate: IrSimpleFunction) {
val thisParam = delegate.valueParameters.last()
val oldThisReceiver = irClass.thisReceiver!!
- val retStmt = JsIrBuilder.buildReturn(delegate.symbol, JsIrBuilder.buildGetValue(thisParam.symbol), context.irBuiltIns.nothingType)
+ val retStmt = JsIrBuilder.buildReturn(delegate, JsIrBuilder.buildGetValue(thisParam), context.irBuiltIns.nothingType)
val statements = (constructor.body!!.deepCopyWithSymbols(delegate) as IrStatementContainer).statements
val oldValueParameters = constructor.valueParameters + oldThisReceiver
@@ -131,7 +131,7 @@
IrGetValueImpl(expression.startOffset, expression.endOffset, newThisSymbol.owner.type, newThisSymbol)
)
- override fun visitGetValue(expression: IrGetValue) = symbolMapping[expression.symbol.owner]?.let {
+ override fun visitGetValue(expression: IrGetValue) = symbolMapping[expression.target]?.let {
expression.run { IrGetValueImpl(startOffset, endOffset, type, it.symbol, origin) }
} ?: expression
}
@@ -202,7 +202,7 @@
override fun visitConstructorCall(expression: IrConstructorCall, data: IrFunction?): IrElement {
super.visitConstructorCall(expression, data)
- val target = expression.symbol.owner
+ val target = expression.target
return if (target.isSecondaryConstructorCall) {
val ctor = oldCtorToNewMap.getOrPut(target) {
buildConstructorStubDeclarations(target, target.parentAsClass)
@@ -214,7 +214,7 @@
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: IrFunction?): IrElement {
super.visitDelegatingConstructorCall(expression, data)
- val target = expression.symbol.owner
+ val target = expression.target
return if (target.isSecondaryConstructorCall) {
val klass = target.parentAsClass
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TestGenerator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TestGenerator.kt
index 83eac2e..1016318 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TestGenerator.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TestGenerator.kt
@@ -15,7 +15,6 @@
import org.jetbrains.kotlin.ir.expressions.IrBlockBody
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
import org.jetbrains.kotlin.ir.util.defaultType
import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
@@ -42,7 +41,7 @@
private data class FunctionWithBody(val function: IrSimpleFunction, val body: IrBlockBody)
- private fun IrSimpleFunctionSymbol.createInvocation(
+ private fun IrSimpleFunction.createInvocation(
name: String,
parentBody: IrBlockBody,
ignored: Boolean = false
@@ -62,8 +61,8 @@
putValueArgument(0, JsIrBuilder.buildString(context.irBuiltIns.stringType, name))
putValueArgument(1, JsIrBuilder.buildBoolean(context.irBuiltIns.booleanType, ignored))
- val refType = IrSimpleTypeImpl(context.ir.symbols.functionN(0), false, emptyList(), emptyList())
- putValueArgument(2, JsIrBuilder.buildFunctionReference(refType, function.symbol))
+ val refType = IrSimpleTypeImpl(context.ir.symbols.functionN(0).symbol, false, emptyList(), emptyList())
+ putValueArgument(2, JsIrBuilder.buildFunctionReference(refType, function))
}
return FunctionWithBody(function, body)
@@ -102,15 +101,15 @@
body.statements += classVal
body.statements += beforeFuns.map {
- JsIrBuilder.buildCall(it.symbol).apply {
- dispatchReceiver = JsIrBuilder.buildGetValue(classVal.symbol)
+ JsIrBuilder.buildCall(it).apply {
+ dispatchReceiver = JsIrBuilder.buildGetValue(classVal)
}
}
val returnStatement = JsIrBuilder.buildReturn(
- fn.symbol,
- JsIrBuilder.buildCall(testFun.symbol).apply {
- dispatchReceiver = JsIrBuilder.buildGetValue(classVal.symbol)
+ fn,
+ JsIrBuilder.buildCall(testFun).apply {
+ dispatchReceiver = JsIrBuilder.buildGetValue(classVal)
},
context.irBuiltIns.unitType
)
@@ -122,8 +121,8 @@
tryResult = returnStatement
finallyExpression = JsIrBuilder.buildComposite(context.irBuiltIns.unitType).apply {
statements += afterFuns.map {
- JsIrBuilder.buildCall(it.symbol).apply {
- dispatchReceiver = JsIrBuilder.buildGetValue(classVal.symbol)
+ JsIrBuilder.buildCall(it).apply {
+ dispatchReceiver = JsIrBuilder.buildGetValue(classVal)
}
}
}
@@ -133,10 +132,10 @@
private fun IrClass.instance(): IrExpression {
return if (kind == ClassKind.OBJECT) {
- JsIrBuilder.buildGetObjectValue(defaultType, symbol)
+ JsIrBuilder.buildGetObjectValue(defaultType, this)
} else {
declarations.asSequence().filterIsInstance<IrConstructor>().single { it.isPrimary }.let { constructor ->
- IrConstructorCallImpl.fromSymbolOwner(defaultType, constructor.symbol).also {
+ IrConstructorCallImpl.fromSymbolOwner(defaultType, constructor).also {
if (isInner) {
it.dispatchReceiver = (parent as IrClass).instance()
}
@@ -158,5 +157,5 @@
get() = hasAnnotation("kotlin.test.AfterTest")
private fun IrAnnotationContainer.hasAnnotation(fqName: String) =
- annotations.any { it.symbol.owner.fqNameWhenAvailable?.parent()?.asString() == fqName }
+ annotations.any { it.target.fqNameWhenAvailable?.parent()?.asString() == fqName }
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ThrowableLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ThrowableLowering.kt
index 1b3ac75..4672c58 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ThrowableLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ThrowableLowering.kt
@@ -6,23 +6,16 @@
package org.jetbrains.kotlin.ir.backend.js.lower
import org.jetbrains.kotlin.backend.common.FileLoweringPass
-import org.jetbrains.kotlin.backend.common.lower.callsSuper
-import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
-import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
import org.jetbrains.kotlin.ir.declarations.IrFile
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
import org.jetbrains.kotlin.ir.types.isNullableString
-import org.jetbrains.kotlin.ir.types.isString
import org.jetbrains.kotlin.ir.types.makeNotNull
-import org.jetbrains.kotlin.ir.util.defaultType
import org.jetbrains.kotlin.ir.util.isThrowable
-import org.jetbrains.kotlin.ir.util.isThrowableTypeOrSubtype
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
@@ -53,7 +46,7 @@
)
else -> {
val arg = getValueArgument(0)!!
- val parameter = symbol.owner.valueParameters[0]
+ val parameter = target.valueParameters[0]
when {
parameter.type.isNullableString() -> ThrowableArguments(message = arg, cause = nullValue())
else -> {
@@ -69,7 +62,7 @@
override fun visitConstructorCall(expression: IrConstructorCall, data: IrDeclarationParent): IrExpression {
expression.transformChildren(this, data)
- if (expression.symbol !in throwableConstructors) return expression
+ if (expression.target !in throwableConstructors) return expression
val (messageArg, causeArg) = expression.extractThrowableArguments()
@@ -83,7 +76,7 @@
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: IrDeclarationParent): IrExpression {
expression.transformChildren(this, data)
- if (expression.symbol !in throwableConstructors) return expression
+ if (expression.target !in throwableConstructors) return expression
val (messageArg, causeArg) = expression.extractThrowableArguments()
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt
index 2532087..88a9e1d 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt
@@ -27,7 +27,7 @@
class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass {
private val unit = context.irBuiltIns.unitType
- private val unitValue get() = JsIrBuilder.buildGetObjectValue(unit, unit.classifierOrFail as IrClassSymbol)
+ private val unitValue get() = JsIrBuilder.buildGetObjectValue(unit, unit.classifierOrFail as IrClass)
private val lit24 get() = JsIrBuilder.buildInt(context.irBuiltIns.intType, 24)
private val lit16 get() = JsIrBuilder.buildInt(context.irBuiltIns.intType, 16)
@@ -184,7 +184,7 @@
): () -> IrExpressionWithCopy {
val varDeclaration = JsIrBuilder.buildVar(value.type, declaration, initializer = value)
newStatements += varDeclaration
- return { JsIrBuilder.buildGetValue(varDeclaration.symbol) }
+ return { JsIrBuilder.buildGetValue(varDeclaration) }
}
private fun generateTypeCheck(argument: () -> IrExpressionWithCopy, toType: IrType): IrExpression {
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/VarargLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/VarargLowering.kt
index 36cda0b..339ba4d 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/VarargLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/VarargLowering.kt
@@ -9,7 +9,6 @@
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.declarations.IrFile
-import org.jetbrains.kotlin.ir.declarations.name
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
@@ -189,7 +188,7 @@
for (i in 0 until size) {
val argument = expression.getValueArgument(i)
- val parameter = expression.symbol.owner.valueParameters[i]
+ val parameter = expression.target.valueParameters[i]
val varargElementType = parameter.varargElementType
if (argument == null && varargElementType != null) {
val arrayInfo = InlineClassArrayInfo(varargElementType, parameter.type)
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/BuiltInConstructorCalls.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/BuiltInConstructorCalls.kt
index 1d6da11..35ef1db 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/BuiltInConstructorCalls.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/BuiltInConstructorCalls.kt
@@ -19,7 +19,7 @@
override fun transformFunctionAccess(call: IrFunctionAccessExpression): IrExpression =
if (call is IrConstructorCall) {
// Do not transform Delegation calls
- when (call.symbol) {
+ when (call.target) {
intrinsics.stringConstructorSymbol -> JsIrBuilder.buildString(context.irBuiltIns.stringType, "")
intrinsics.anyConstructorSymbol -> irConstructorCall(call, intrinsics.jsObjectConstructorSymbol)
else -> call
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLoweringUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLoweringUtils.kt
index 9391699..c7fb4e9 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLoweringUtils.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLoweringUtils.kt
@@ -8,31 +8,30 @@
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.irCall
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.types.SimpleType
-typealias SymbolToTransformer = MutableMap<IrFunctionSymbol, (IrFunctionAccessExpression) -> IrExpression>
+typealias FunctionToTransformer = MutableMap<IrFunction, (IrFunctionAccessExpression) -> IrExpression>
-internal fun SymbolToTransformer.add(from: Map<SimpleType, IrFunctionSymbol>, to: IrFunctionSymbol) {
+internal fun FunctionToTransformer.add(from: Map<SimpleType, IrFunction>, to: IrFunction) {
from.forEach { _, func ->
add(func, to)
}
}
-internal fun SymbolToTransformer.add(from: Map<SimpleType, IrFunctionSymbol>, to: (IrFunctionAccessExpression) -> IrExpression) {
+internal fun FunctionToTransformer.add(from: Map<SimpleType, IrFunction>, to: (IrFunctionAccessExpression) -> IrExpression) {
from.forEach { _, func ->
add(func, to)
}
}
-internal fun SymbolToTransformer.add(from: IrFunctionSymbol, to: (IrFunctionAccessExpression) -> IrExpression) {
+internal fun FunctionToTransformer.add(from: IrFunction, to: (IrFunctionAccessExpression) -> IrExpression) {
put(from, to)
}
-internal fun SymbolToTransformer.add(from: IrFunctionSymbol, to: IrFunctionSymbol, dispatchReceiverAsFirstArgument: Boolean = false) {
+internal fun FunctionToTransformer.add(from: IrFunction, to: IrFunction, dispatchReceiverAsFirstArgument: Boolean = false) {
put(from) { call -> irCall(call, to, dispatchReceiverAsFirstArgument) }
}
@@ -46,12 +45,8 @@
internal typealias MemberToTransformer = HashMap<SimpleMemberKey, (IrFunctionAccessExpression) -> IrExpression>
-internal fun MemberToTransformer.add(type: IrType, name: Name, v: IrFunctionSymbol) {
- add(type, name) { irCall(it, v, receiversAsArguments = true) }
-}
-
internal fun MemberToTransformer.add(type: IrType, name: Name, v: IrFunction) {
- add(type, name, v.symbol)
+ add(type, name) { irCall(it, v, receiversAsArguments = true) }
}
internal fun MemberToTransformer.add(type: IrType, name: Name, v: (IrFunctionAccessExpression) -> IrExpression) {
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EnumIntrinsicsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EnumIntrinsicsTransformer.kt
index daba1d1..970bb25 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EnumIntrinsicsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EnumIntrinsicsTransformer.kt
@@ -27,7 +27,7 @@
if (!enum.isEnumClass) return call
val staticMethod = enum.findDeclaration(staticMethodPredicate)
if (staticMethod == null || !staticMethod.isStaticMethodOfClass)
- throw IllegalStateException("Enum class should have static method for ${call.symbol.owner.name}")
+ throw IllegalStateException("Enum class should have static method for ${call.target.name}")
return irCall(call, staticMethod.symbol)
}
@@ -42,7 +42,7 @@
it.name == Name.identifier("values") && it.valueParameters.count() == 0
}
- override fun transformFunctionAccess(call: IrFunctionAccessExpression) = when (call.symbol) {
+ override fun transformFunctionAccess(call: IrFunctionAccessExpression) = when (call.target) {
context.intrinsics.enumValueOfIntrinsic -> transformEnumValueOfIntrinsic(call)
context.intrinsics.enumValuesIntrinsic -> transformEnumValuesIntrinsic(call)
else -> call
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EqualityAndComparisonCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EqualityAndComparisonCallsTransformer.kt
index 4f5fcba..6330d77 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EqualityAndComparisonCallsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EqualityAndComparisonCallsTransformer.kt
@@ -23,10 +23,10 @@
private val intrinsics = context.intrinsics
private val irBuiltIns = context.irBuiltIns
- private val symbolToTransformer: SymbolToTransformer = mutableMapOf()
+ private val functionToTransformer: FunctionToTransformer = mutableMapOf()
init {
- symbolToTransformer.run {
+ functionToTransformer.run {
add(irBuiltIns.eqeqeqSymbol, intrinsics.jsEqeqeq)
add(irBuiltIns.eqeqSymbol, ::transformEqeqOperator)
// ieee754equals can only be applied in between statically known Floats, Doubles, null or undefined
@@ -59,12 +59,12 @@
}
override fun transformFunctionAccess(call: IrFunctionAccessExpression): IrExpression {
- val symbol = call.symbol
- symbolToTransformer[symbol]?.let {
+ val target = call.target
+ functionToTransformer[target]?.let {
return it(call)
}
- return when (symbol.owner.name) {
+ return when (target.name) {
Name.identifier("compareTo") -> transformCompareToMethodCall(call)
Name.identifier("equals") -> transformEqualsMethodCall(call as IrCall)
else -> call
@@ -113,14 +113,14 @@
(0 until valueArgumentsCount).all { getValueArgument(it)!!.type.isNullable() }
private fun transformCompareToMethodCall(call: IrFunctionAccessExpression): IrExpression {
- val function = call.symbol.owner as IrSimpleFunction
+ val function = call.target as IrSimpleFunction
if (function.parent !is IrClass) return call
fun IrSimpleFunction.isFakeOverriddenFromComparable(): Boolean = when {
origin != IrDeclarationOrigin.FAKE_OVERRIDE ->
!isStaticMethodOfClass && parentAsClass.thisReceiver!!.type.isComparable()
- else -> overriddenSymbols.all { it.owner.isFakeOverriddenFromComparable() }
+ else -> overridden.all { it.isFakeOverriddenFromComparable() }
}
return when {
@@ -137,7 +137,7 @@
private fun transformEqualsMethodCall(call: IrCall): IrExpression {
- val function = call.symbol.owner
+ val function = call.target
return when {
// Nothing special
!function.isEqualsInheritedFromAny() -> call
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt
index 4c5a7a9..0a8b9c9 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ExceptionHelperCallsTransformer.kt
@@ -27,5 +27,5 @@
)
override fun transformFunctionAccess(call: IrFunctionAccessExpression) =
- helperMapping[call.symbol]?.let { irCall(call, it) } ?: call
+ helperMapping[call.target]?.let { irCall(call, it) } ?: call
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/JsonIntrinsics.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/JsonIntrinsics.kt
index 240a84b..c059925 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/JsonIntrinsics.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/JsonIntrinsics.kt
@@ -32,7 +32,7 @@
}
}
- when (call.symbol.owner.fqNameWhenAvailable) {
+ when (call.target.fqNameWhenAvailable) {
FqName("kotlin.js.Json.get") ->
return generateMemberAccess()
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/MethodsOfAnyCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/MethodsOfAnyCallsTransformer.kt
index 2f5a62a..35504bb 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/MethodsOfAnyCallsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/MethodsOfAnyCallsTransformer.kt
@@ -39,7 +39,7 @@
}
put(Name.identifier("hashCode")) { call ->
- if (call.symbol.owner.isFakeOverriddenFromAny()) {
+ if (call.target.isFakeOverriddenFromAny()) {
if ((call as IrCall).isSuperToAny()) {
irCall(call, intrinsics.jsGetObjectHashCode, receiversAsArguments = true)
} else {
@@ -54,8 +54,8 @@
override fun transformFunctionAccess(call: IrFunctionAccessExpression): IrExpression {
- val symbol = call.symbol
- nameToTransformer[symbol.owner.name]?.let {
+ val target = call.target
+ nameToTransformer[target.name]?.let {
return it(call)
}
@@ -63,7 +63,7 @@
}
private fun shouldReplaceToStringWithRuntimeCall(call: IrFunctionAccessExpression): Boolean {
- val function = call.symbol.owner
+ val function = call.target
if (function.valueParameters.size != 0 && function.name.asString() != "toString" )
return false
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberConversionCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberConversionCallsTransformer.kt
index a286e73..91927168 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberConversionCallsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberConversionCallsTransformer.kt
@@ -8,7 +8,6 @@
import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.backend.js.utils.ConversionNames
-import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
@@ -76,7 +75,7 @@
}
override fun transformFunctionAccess(call: IrFunctionAccessExpression): IrExpression {
- val function = call.symbol.owner
+ val function = call.target
function.dispatchReceiverParameter?.also {
val key = SimpleMemberKey(it.type, function.name)
memberToTransformer[key]?.also {
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberOperatorCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberOperatorCallsTransformer.kt
index 2690a9c..9068319 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberOperatorCallsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NumberOperatorCallsTransformer.kt
@@ -8,6 +8,7 @@
import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.backend.js.utils.OperatorNames
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -73,7 +74,7 @@
}
override fun transformFunctionAccess(call: IrFunctionAccessExpression): IrExpression {
- val function = call.symbol.owner
+ val function = call.target
function.dispatchReceiverParameter?.also {
val key = SimpleMemberKey(it.type, function.name)
memberToTransformer[key]?.also {
@@ -85,7 +86,7 @@
private fun transformRangeTo(call: IrFunctionAccessExpression): IrExpression {
if (call.valueArgumentsCount != 1) return call
- return with(call.symbol.owner.valueParameters[0].type) {
+ return with(call.target.valueParameters[0].type) {
when {
isByte() || isShort() || isInt() ->
irCall(call, intrinsics.jsNumberRangeToNumber, receiversAsArguments = true)
@@ -108,7 +109,7 @@
}
class BinaryOp(call: IrFunctionAccessExpression) {
- val function = call.symbol.owner
+ val function = call.target
val name = function.name
val lhs = function.dispatchReceiverParameter!!.type
val rhs = function.valueParameters[0].type
@@ -224,8 +225,8 @@
}
}
- fun IrFunctionSymbol.call(vararg arguments: IrExpression) =
- JsIrBuilder.buildCall(this, owner.returnType).apply {
+ fun IrFunction.call(vararg arguments: IrExpression) =
+ JsIrBuilder.buildCall(this, returnType).apply {
for ((idx, arg) in arguments.withIndex()) {
putValueArgument(idx, arg)
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/PrimitiveContainerMemberCallTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/PrimitiveContainerMemberCallTransformer.kt
index 35b9fd1..6564b09 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/PrimitiveContainerMemberCallTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/PrimitiveContainerMemberCallTransformer.kt
@@ -7,23 +7,20 @@
import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.expressions.IrCall
-import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.util.getSimpleFunction
import org.jetbrains.kotlin.ir.util.getPropertyGetter
class PrimitiveContainerMemberCallTransformer(private val context: JsIrBackendContext) : CallsTransformer {
private val intrinsics = context.intrinsics
- private val symbolToTransformer: SymbolToTransformer = mutableMapOf()
+ private val functionToTransformer: FunctionToTransformer = mutableMapOf()
init {
- symbolToTransformer.run {
+ functionToTransformer.run {
// Arrays
add(context.intrinsics.array.sizeProperty, context.intrinsics.jsArrayLength, true)
add(context.intrinsics.array.getFunction, context.intrinsics.jsArrayGet, true)
@@ -60,8 +57,8 @@
}
override fun transformFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
- val symbol = expression.symbol
- symbolToTransformer[symbol]?.let {
+ val symbol = expression.target
+ functionToTransformer[symbol]?.let {
return it(expression)
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ReflectionCallsTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ReflectionCallsTransformer.kt
index e85bf48..cc8673d 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ReflectionCallsTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/ReflectionCallsTransformer.kt
@@ -34,7 +34,7 @@
addWithPredicate(
Name.special(Namer.KCALLABLE_GET_NAME),
{ call ->
- call.symbol.owner.dispatchReceiverParameter?.run { type.isSubtypeOfClass(context.irBuiltIns.kCallableClass) } ?: false
+ call.target.dispatchReceiverParameter?.run { type.isSubtypeOfClass(context.irBuiltIns.kCallableClass) } ?: false
},
{ call ->
IrDynamicMemberExpressionImpl(
@@ -49,7 +49,7 @@
addWithPredicate(
Name.identifier(Namer.KPROPERTY_GET),
{ call ->
- call.symbol.owner.dispatchReceiverParameter?.run { type.isSubtypeOfClass(context.irBuiltIns.kPropertyClass) } ?: false
+ call.target.dispatchReceiverParameter?.run { type.isSubtypeOfClass(context.irBuiltIns.kPropertyClass) } ?: false
},
{ call -> buildDynamicCall(Namer.KPROPERTY_GET, call) }
)
@@ -57,7 +57,7 @@
addWithPredicate(
Name.identifier(Namer.KPROPERTY_SET),
{ call ->
- call.symbol.owner.dispatchReceiverParameter?.run { type.isSubtypeOfClass(context.irBuiltIns.kPropertyClass) } ?: false
+ call.target.dispatchReceiverParameter?.run { type.isSubtypeOfClass(context.irBuiltIns.kPropertyClass) } ?: false
},
{ call -> buildDynamicCall(Namer.KPROPERTY_SET, call) }
)
@@ -65,8 +65,8 @@
}
override fun transformFunctionAccess(call: IrFunctionAccessExpression): IrExpression {
- val symbol = call.symbol
- nameToTransformer[symbol.owner.name]?.let {
+ val symbol = call.target
+ nameToTransformer[symbol.name]?.let {
return it(call)
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/JsSuspendFunctionsLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/JsSuspendFunctionsLowering.kt
index 69a210d..9d43965 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/JsSuspendFunctionsLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/JsSuspendFunctionsLowering.kt
@@ -15,9 +15,7 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.util.explicitParameters
import org.jetbrains.kotlin.ir.util.patchDeclarationParents
import org.jetbrains.kotlin.ir.visitors.*
@@ -65,8 +63,8 @@
stateMachineFunction,
"suspendResult",
true,
- initializer = JsIrBuilder.buildCall(coroutineImplResultSymbolGetter.symbol).apply {
- dispatchReceiver = JsIrBuilder.buildGetValue(stateMachineFunction.dispatchReceiverParameter!!.symbol)
+ initializer = JsIrBuilder.buildCall(coroutineImplResultSymbolGetter).apply {
+ dispatchReceiver = JsIrBuilder.buildGetValue(stateMachineFunction.dispatchReceiverParameter!!)
}
)
@@ -88,7 +86,7 @@
}
val suspendableNodes = collectSuspendableNodes(body)
- val thisReceiver = (stateMachineFunction.dispatchReceiverParameter as IrValueParameter).symbol
+ val thisReceiver = stateMachineFunction.dispatchReceiverParameter as IrValueParameter
val stateMachineBuilder = StateMachineBuilder(
suspendableNodes,
@@ -126,36 +124,35 @@
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid(this)
- return if (expression.returnTargetSymbol != simplifiedFunction.symbol)
+ return if (expression.irReturnTarget != simplifiedFunction.symbol)
expression
else
- JsIrBuilder.buildReturn(stateMachineFunction.symbol, expression.value, expression.type)
+ JsIrBuilder.buildReturn(stateMachineFunction, expression.value, expression.type)
}
})
val liveLocals = computeLivenessAtSuspensionPoints(functionBody).values.flatten().toSet()
- val localToPropertyMap = mutableMapOf<IrValueSymbol, IrFieldSymbol>()
+ val localToPropertyMap = mutableMapOf<IrValueDeclaration, IrField>()
var localCounter = 0
// TODO: optimize by using the same property for different locals.
liveLocals.forEach {
if (it != suspendState && it != suspendResult) {
- localToPropertyMap.getOrPut(it.symbol) {
+ localToPropertyMap.getOrPut(it) {
coroutineClass.addField(Name.identifier("${it.name}${localCounter++}"), it.type, (it as? IrVariable)?.isVar ?: false)
- .symbol
}
}
}
simplifiedFunction.explicitParameters.forEach {
- localToPropertyMap.getOrPut(it.symbol) {
- argumentToPropertiesMap.getValue(it).symbol
+ localToPropertyMap.getOrPut(it) {
+ argumentToPropertiesMap.getValue(it)
}
}
stateMachineFunction.transform(LiveLocalsTransformer(localToPropertyMap, { JsIrBuilder.buildGetValue(thisReceiver) }, unit), null)
}
- private fun assignStateIds(entryState: SuspendState, thisReceiver: IrValueParameterSymbol, switch: IrWhen, rootLoop: IrLoop) {
+ private fun assignStateIds(entryState: SuspendState, thisReceiver: IrValueParameter, switch: IrWhen, rootLoop: IrLoop) {
val visited = mutableSetOf<SuspendState>()
val sortedStates = DFS.topologicalOrder(listOf(entryState), { it.successors }, { visited.add(it) })
@@ -165,7 +162,7 @@
for (state in sortedStates) {
val condition = JsIrBuilder.buildCall(eqeqeqInt).apply {
- putValueArgument(0, JsIrBuilder.buildCall(coroutineImplLabelPropertyGetter.symbol).also {
+ putValueArgument(0, JsIrBuilder.buildCall(coroutineImplLabelPropertyGetter).also {
it.dispatchReceiver = JsIrBuilder.buildGetValue(thisReceiver)
})
putValueArgument(1, JsIrBuilder.buildInt(context.irBuiltIns.intType, state.id))
@@ -204,10 +201,10 @@
override fun initializeStateMachine(coroutineConstructors: List<IrConstructor>, coroutineClassThis: IrValueDeclaration) {
for (it in coroutineConstructors) {
(it.body as? IrBlockBody)?.run {
- val receiver = JsIrBuilder.buildGetValue(coroutineClassThis.symbol)
+ val receiver = JsIrBuilder.buildGetValue(coroutineClassThis)
assert(exceptionTrapId >= 0)
val id = JsIrBuilder.buildInt(context.irBuiltIns.intType, exceptionTrapId)
- statements += JsIrBuilder.buildCall(coroutineImplExceptionStatePropertySetter.symbol).also { call ->
+ statements += JsIrBuilder.buildCall(coroutineImplExceptionStatePropertySetter).also { call ->
call.dispatchReceiver = receiver
call.putValueArgument(0, id)
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt
index a0b5366..bac4e2a 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt
@@ -16,13 +16,12 @@
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
import org.jetbrains.kotlin.ir.visitors.*
@@ -63,8 +62,8 @@
private val exStateSymbolGetter: IrSimpleFunction,
private val exStateSymbolSetter: IrSimpleFunction,
private val stateSymbolSetter: IrSimpleFunction,
- private val thisSymbol: IrValueParameterSymbol,
- private val suspendResult: IrVariableSymbol
+ private val thisValueParameter: IrValueParameter,
+ private val suspendResult: IrVariable
) : IrElementVisitorVoid {
private val loopMap = mutableMapOf<IrLoop, LoopBounds>()
@@ -73,7 +72,7 @@
private val booleanNotSymbol = context.irBuiltIns.booleanNotSymbol
private val eqeqeqSymbol = context.irBuiltIns.eqeqeqSymbol
- private val thisReceiver get() = JsIrBuilder.buildGetValue(thisSymbol)
+ private val thisReceiver get() = JsIrBuilder.buildGetValue(thisValueParameter)
private var hasExceptions = false
@@ -93,7 +92,6 @@
private fun buildGlobalCatch(): IrCatch {
val catchVariable = globalExceptionVar
- val globalExceptionSymbol = globalExceptionVar.symbol
val block = JsIrBuilder.buildBlock(unit)
if (hasExceptions) {
val thenBlock = JsIrBuilder.buildBlock(unit)
@@ -105,22 +103,22 @@
block.statements += JsIrBuilder.buildIfElse(unit, check, thenBlock, elseBlock)
thenBlock.statements += JsIrBuilder.buildThrow(
nothing,
- JsIrBuilder.buildGetValue(globalExceptionSymbol)
+ JsIrBuilder.buildGetValue(catchVariable)
)
// TODO: exception table
- elseBlock.statements += JsIrBuilder.buildCall(stateSymbolSetter.symbol, unit).apply {
+ elseBlock.statements += JsIrBuilder.buildCall(stateSymbolSetter, unit).apply {
dispatchReceiver = thisReceiver
putValueArgument(0, exceptionState())
}
- elseBlock.statements += JsIrBuilder.buildCall(exceptionSymbolSetter.symbol, unit).apply {
+ elseBlock.statements += JsIrBuilder.buildCall(exceptionSymbolSetter, unit).apply {
dispatchReceiver = thisReceiver
- putValueArgument(0, JsIrBuilder.buildGetValue(globalExceptionSymbol))
+ putValueArgument(0, JsIrBuilder.buildGetValue(catchVariable))
}
} else {
block.statements += JsIrBuilder.buildThrow(
nothing,
- JsIrBuilder.buildGetValue(globalExceptionSymbol)
+ JsIrBuilder.buildGetValue(catchVariable)
)
}
@@ -130,7 +128,7 @@
private var currentState = entryState
private var currentBlock = entryState.entryBlock
- private val returnableBlockMap = mutableMapOf<IrReturnableBlockSymbol, Pair<SuspendState, IrVariableSymbol?>>()
+ private val returnableBlockMap = mutableMapOf<IrReturnableBlockSymbol, Pair<SuspendState, IrVariable?>>()
private val catchBlockStack = mutableListOf(rootExceptionTrap)
@@ -175,7 +173,7 @@
private fun doDispatchImpl(target: SuspendState, block: IrContainerExpression, andContinue: Boolean) {
val irDispatch = IrDispatchPoint(target)
currentState.successors.add(target)
- block.addStatement(JsIrBuilder.buildCall(stateSymbolSetter.symbol, unit).apply {
+ block.addStatement(JsIrBuilder.buildCall(stateSymbolSetter, unit).apply {
dispatchReceiver = thisReceiver
putValueArgument(0, irDispatch)
})
@@ -255,9 +253,7 @@
val exitState = SuspendState(unit)
val resultVariable = if (hasResultingValue(expression)) {
- val irVar = tempVar(expression.type, "RETURNABLE_BLOCK")
- addStatement(irVar)
- irVar.symbol
+ tempVar(expression.type, "RETURNABLE_BLOCK").also { addStatement(it) }
} else null
returnableBlockMap[expression.symbol] = Pair(exitState, resultVariable)
@@ -292,7 +288,7 @@
currentState.successors += continueState
transformLastExpression {
- JsIrBuilder.buildCall(stateSymbolSetter.symbol, unit).apply {
+ JsIrBuilder.buildCall(stateSymbolSetter, unit).apply {
dispatchReceiver = thisReceiver
putValueArgument(0, dispatch)
}
@@ -325,7 +321,7 @@
doDispatch(headState)
}
- private fun wrap(expression: IrExpression, variable: IrVariableSymbol) =
+ private fun wrap(expression: IrExpression, variable: IrVariable) =
JsIrBuilder.buildSetVariable(variable, expression, unit)
override fun visitWhen(expression: IrWhen) {
@@ -334,16 +330,16 @@
val exitState = SuspendState(expression.type)
- val varSymbol: IrVariableSymbol?
+ val variable: IrVariable?
val branches: List<IrBranch>
if (hasResultingValue(expression)) {
val irVar = tempVar(expression.type, "WHEN_RESULT")
- varSymbol = irVar.symbol
+ variable = irVar
addStatement(irVar)
branches = expression.branches.map {
- val wrapped = wrap(it.result, varSymbol)
+ val wrapped = wrap(it.result, variable)
if (it.result in suspendableNodes) {
suspendableNodes += wrapped
}
@@ -353,7 +349,7 @@
}
}
} else {
- varSymbol = null
+ variable = null
branches = expression.branches
}
@@ -390,8 +386,8 @@
maybeDoDispatch(exitState)
updateState(exitState)
- if (varSymbol != null) {
- addStatement(JsIrBuilder.buildGetValue(varSymbol))
+ if (variable != null) {
+ addStatement(JsIrBuilder.buildGetValue(variable))
}
}
@@ -439,7 +435,7 @@
transformLastExpression {
irVar.apply { initializer = it }
}
- JsIrBuilder.buildGetValue(irVar.symbol)
+ JsIrBuilder.buildGetValue(irVar)
} else {
arg?.deepCopyWithSymbols(function.owner)
}
@@ -487,12 +483,12 @@
IrSetFieldImpl(
startOffset,
endOffset,
- symbol,
+ target,
receiver,
value,
unit,
origin,
- superQualifierSymbol
+ irSuperQualifier
)
})
}
@@ -520,10 +516,10 @@
override fun visitReturn(expression: IrReturn) {
expression.acceptChildrenVoid(this)
- if (expression.returnTargetSymbol is IrReturnableBlockSymbol) {
- val (exitState, varSymbol) = returnableBlockMap[expression.returnTargetSymbol]!!
- if (varSymbol != null) {
- transformLastExpression { JsIrBuilder.buildSetVariable(varSymbol, it, it.type) }
+ if (expression.irReturnTarget is IrReturnableBlockSymbol) {
+ val (exitState, irVar) = returnableBlockMap[expression.irReturnTarget]!!
+ if (irVar != null) {
+ transformLastExpression { JsIrBuilder.buildSetVariable(irVar, it, it.type) }
}
maybeDoDispatch(exitState)
} else {
@@ -555,17 +551,17 @@
val exitState = SuspendState(unit)
- val varSymbol = if (hasResultingValue(aTry)) tempVar(aTry.type, "TRY_RESULT") else null
+ val variable = if (hasResultingValue(aTry)) tempVar(aTry.type, "TRY_RESULT") else null
- if (varSymbol != null) {
- addStatement(varSymbol)
+ if (variable != null) {
+ addStatement(variable)
}
// TODO: refact it with exception table, see coroutinesInternal.kt
setupExceptionState(tryState.catchState)
- val tryResult = if (varSymbol != null) {
- JsIrBuilder.buildSetVariable(varSymbol.symbol, aTry.tryResult, unit).also {
+ val tryResult = if (variable != null) {
+ JsIrBuilder.buildSetVariable(variable, aTry.tryResult, unit).also {
if (it.value in suspendableNodes) suspendableNodes += it
}
} else aTry.tryResult
@@ -591,8 +587,8 @@
val irVar = catch.catchParameter.also {
it.initializer = initializer
}
- val catchResult = if (varSymbol != null) {
- JsIrBuilder.buildSetVariable(varSymbol.symbol, catch.result, unit).also {
+ val catchResult = if (variable != null) {
+ JsIrBuilder.buildSetVariable(variable, catch.result, unit).also {
if (it.value in suspendableNodes) suspendableNodes += it
}
} else catch.result
@@ -633,22 +629,22 @@
updateState(exitState)
- if (varSymbol != null) {
- addStatement(JsIrBuilder.buildGetValue(varSymbol.symbol))
+ if (variable != null) {
+ addStatement(JsIrBuilder.buildGetValue(variable))
}
}
private fun setupExceptionState(target: SuspendState) {
addStatement(
- JsIrBuilder.buildCall(exStateSymbolSetter.symbol, unit).apply {
+ JsIrBuilder.buildCall(exStateSymbolSetter, unit).apply {
dispatchReceiver = thisReceiver
putValueArgument(0, IrDispatchPoint(target))
}
)
}
- private fun exceptionState() = JsIrBuilder.buildCall(exStateSymbolGetter.symbol).also { it.dispatchReceiver = thisReceiver }
- private fun pendingException() = JsIrBuilder.buildCall(exceptionSymbolGetter.symbol).also { it.dispatchReceiver = thisReceiver }
+ private fun exceptionState() = JsIrBuilder.buildCall(exStateSymbolGetter).also { it.dispatchReceiver = thisReceiver }
+ private fun pendingException() = JsIrBuilder.buildCall(exceptionSymbolGetter).also { it.dispatchReceiver = thisReceiver }
private fun buildTryState() = TryState(currentState, SuspendState(unit))
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendLoweringUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendLoweringUtils.kt
index c4e46dd..c5dd810 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendLoweringUtils.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/SuspendLoweringUtils.kt
@@ -6,18 +6,15 @@
package org.jetbrains.kotlin.ir.backend.js.lower.coroutines
import org.jetbrains.kotlin.backend.common.ir.isSuspend
-import org.jetbrains.kotlin.backend.common.pop
-import org.jetbrains.kotlin.backend.common.push
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.declarations.IrValueDeclaration
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
-import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.*
@@ -64,7 +61,7 @@
override fun visitReturn(expression: IrReturn) {
super.visitReturn(expression)
- if (expression.returnTargetSymbol is IrReturnableBlockSymbol && isSuspendableNode(expression.returnTargetSymbol.owner)) {
+ if (expression.irReturnTarget is IrReturnableBlock && isSuspendableNode(expression.irReturnTarget)) {
markNode(expression)
}
}
@@ -82,19 +79,19 @@
}
class LiveLocalsTransformer(
- private val localMap: Map<IrValueSymbol, IrFieldSymbol>,
+ private val localMap: Map<IrValueDeclaration, IrField>,
private val receiver: () -> IrExpression,
private val unitType: IrType
) :
IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrExpression {
- val field = localMap[expression.symbol] ?: return expression
+ val field = localMap[expression.target] ?: return expression
return expression.run { IrGetFieldImpl(startOffset, endOffset, field, type, receiver(), origin) }
}
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
expression.transformChildrenVoid(this)
- val field = localMap[expression.symbol] ?: return expression
+ val field = localMap[expression.target] ?: return expression
return expression.run { IrSetFieldImpl(startOffset, endOffset, field, receiver(), value, unitType, origin) }
}
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsExpressionTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsExpressionTransformer.kt
index 44cee71..97f09cb 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsExpressionTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsExpressionTransformer.kt
@@ -10,12 +10,10 @@
import org.jetbrains.kotlin.ir.backend.js.utils.*
import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.types.isUnit
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.js.backend.ast.*
-import org.jetbrains.kotlin.util.OperatorNameConventions
@Suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")
class IrElementToJsExpressionTransformer : BaseIrElementToJsNodeTransformer<JsExpression, JsGenerationContext> {
@@ -29,7 +27,7 @@
body.expression.accept(this, context)
override fun visitFunctionReference(expression: IrFunctionReference, context: JsGenerationContext): JsExpression {
- val irFunction = expression.symbol.owner
+ val irFunction = expression.target
return irFunction.accept(IrFunctionToJsTransformer(), context).apply { name = null }
}
@@ -63,9 +61,7 @@
}
override fun visitGetField(expression: IrGetField, context: JsGenerationContext): JsExpression {
- val symbol = expression.symbol
- val field = symbol.owner
-
+ val field = expression.target
val fieldParent = field.parent
if (fieldParent is IrClass && field.isEffectivelyExternal()) {
@@ -85,37 +81,37 @@
}
override fun visitGetValue(expression: IrGetValue, context: JsGenerationContext): JsExpression =
- context.getNameForValueDeclaration(expression.symbol.owner).makeRef()
+ context.getNameForValueDeclaration(expression.target).makeRef()
override fun visitGetObjectValue(expression: IrGetObjectValue, context: JsGenerationContext): JsExpression {
- val obj = expression.symbol.owner
+ val obj = expression.target
assert(obj.kind == ClassKind.OBJECT)
assert(obj.isEffectivelyExternal()) { "Non external IrGetObjectValue must be lowered" }
return context.getRefForExternalClass(obj)
}
override fun visitSetField(expression: IrSetField, context: JsGenerationContext): JsExpression {
- val fieldName = context.getNameForField(expression.symbol.owner)
+ val fieldName = context.getNameForField(expression.target)
val dest = JsNameRef(fieldName, expression.receiver?.accept(this, context))
val source = expression.value.accept(this, context)
return jsAssignment(dest, source)
}
override fun visitSetVariable(expression: IrSetVariable, context: JsGenerationContext): JsExpression {
- val ref = JsNameRef(context.getNameForValueDeclaration(expression.symbol.owner))
+ val ref = JsNameRef(context.getNameForValueDeclaration(expression.target))
val value = expression.value.accept(this, context)
return JsBinaryOperation(JsBinaryOperator.ASG, ref, value)
}
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, context: JsGenerationContext): JsExpression {
- val classNameRef = context.getNameForConstructor(expression.symbol.owner).makeRef()
+ val classNameRef = context.getNameForConstructor(expression.target).makeRef()
val callFuncRef = JsNameRef(Namer.CALL_FUNCTION, classNameRef)
val fromPrimary = context.currentFunction is IrConstructor
val thisRef =
if (fromPrimary) JsThisRef() else context.getNameForValueDeclaration(context.currentFunction!!.valueParameters.last()).makeRef()
val arguments = translateCallArguments(expression, context, this)
- val constructor = expression.symbol.owner
+ val constructor = expression.target
if (constructor.parentAsClass.isInline) {
assert(constructor.isPrimary) {
"Delegation to secondary inline constructors must be lowered into simple function calls"
@@ -127,7 +123,7 @@
}
override fun visitConstructorCall(expression: IrConstructorCall, context: JsGenerationContext): JsExpression {
- val function = expression.symbol.owner
+ val function = expression.target
val arguments = translateCallArguments(expression, context, this)
val klass = function.parentAsClass
return if (klass.isInline) {
@@ -149,7 +145,7 @@
}
override fun visitCall(expression: IrCall, context: JsGenerationContext): JsExpression {
- if (context.checkIfJsCode(expression.symbol)) {
+ if (context.checkIfJsCode(expression.target)) {
val statements = translateJsCodeIntoStatementList(expression.getValueArgument(0) ?: error("JsCode is expected"))
if (statements.isEmpty()) return JsPrefixOperation(JsUnaryOperator.VOID, JsIntLiteral(3)) // TODO: report warning or even error
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt
index a12b55b..242f787 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt
@@ -65,14 +65,14 @@
}
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, context: JsGenerationContext): JsStatement {
- if (expression.symbol.owner.constructedClassType.isAny()) {
+ if (expression.target.constructedClassType.isAny()) {
return JsEmpty
}
return expression.accept(IrElementToJsExpressionTransformer(), context).makeStmt()
}
override fun visitCall(expression: IrCall, data: JsGenerationContext): JsStatement {
- if (data.checkIfJsCode(expression.symbol)) {
+ if (data.checkIfJsCode(expression.target)) {
val statements = translateJsCodeIntoStatementList(expression.getValueArgument(0) ?: error("JsCode is expected"))
return when (statements.size) {
0 -> JsEmpty
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/JsIntrinsicTransformers.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/JsIntrinsicTransformers.kt
index 4377e4a9..fe853d7 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/JsIntrinsicTransformers.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/JsIntrinsicTransformers.kt
@@ -174,11 +174,11 @@
add(intrinsics.jsBind) { call, context: JsGenerationContext ->
val receiver = call.getValueArgument(0)!!
val reference = call.getValueArgument(1) as IrFunctionReference
- val superClass = call.superQualifierSymbol!!
+ val superClass = call.irSuperQualifier!!
val jsReceiver = receiver.accept(IrElementToJsExpressionTransformer(), context)
- val functionName = context.getNameForMemberFunction(reference.symbol.owner as IrSimpleFunction)
- val superName = context.getNameForClass(superClass.owner).makeRef()
+ val functionName = context.getNameForMemberFunction(reference.target as IrSimpleFunction)
+ val superName = context.getNameForClass(superClass).makeRef()
val qPrototype = JsNameRef(functionName, prototypeOf(superName))
val bindRef = JsNameRef(Namer.BIND_FUNCTION, qPrototype)
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt
index 9dcf225..b124a82 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt
@@ -62,7 +62,7 @@
}
private fun isNativeInvoke(call: IrCall): Boolean {
- val simpleFunction = call.symbol.owner as? IrSimpleFunction ?: return false
+ val simpleFunction = call.target as? IrSimpleFunction ?: return false
val receiverType = simpleFunction.dispatchReceiverParameter?.type ?: return false
if (simpleFunction.isSuspend) return false
@@ -75,7 +75,7 @@
context: JsGenerationContext,
transformer: IrElementToJsExpressionTransformer
): JsExpression {
- val function = expression.symbol.owner.realOverrideTarget
+ val function = expression.target.realOverrideTarget
require(function is IrSimpleFunction) { "Only IrSimpleFunction could be called via IrCall" } // TODO: fix it in IrCall
val symbol = function.symbol
@@ -106,12 +106,12 @@
return JsInvocation(jsDispatchReceiver!!, arguments)
}
- expression.superQualifierSymbol?.let { superQualifier ->
- val (target, klass) = if (superQualifier.owner.isInterface) {
+ expression.irSuperQualifier?.let { superQualifier ->
+ val (target, klass) = if (superQualifier.isInterface) {
val impl = function.resolveFakeOverride()!!
Pair(impl, impl.parentAsClass)
} else {
- Pair(function, superQualifier.owner)
+ Pair(function, superQualifier)
}
val qualifierName = context.getNameForClass(klass).makeRef()
@@ -206,7 +206,7 @@
val argument = expression.getValueArgument(index)
val result = argument?.accept(transformer, context)
if (result == null) {
- assert(expression is IrFunctionAccessExpression && expression.symbol.owner.isExternalOrInheritedFromExternal())
+ assert(expression is IrFunctionAccessExpression && expression.target.isExternalOrInheritedFromExternal())
JsPrefixOperation(JsUnaryOperator.VOID, JsIntLiteral(1))
} else
result
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt
index 0ad389f..df355ab 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsGenerationContext.kt
@@ -7,7 +7,6 @@
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.js.backend.ast.JsName
import org.jetbrains.kotlin.js.backend.ast.JsNameRef
import org.jetbrains.kotlin.js.backend.ast.JsScope
@@ -43,9 +42,9 @@
}
private fun isCoroutineDoResume(): Boolean {
- val overriddenSymbols = (currentFunction as? IrSimpleFunction)?.overriddenSymbols ?: return false
- return staticContext.doResumeFunctionSymbol in overriddenSymbols
+ val overriddenSymbols = (currentFunction as? IrSimpleFunction)?.overridden ?: return false
+ return staticContext.doResumeFunction in overriddenSymbols
}
- fun checkIfJsCode(symbol: IrFunctionSymbol): Boolean = symbol == staticContext.backendContext.intrinsics.jsCode
+ fun checkIfJsCode(target: IrFunction): Boolean = target == staticContext.backendContext.intrinsics.jsCode
}
\ No newline at end of file
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsStaticContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsStaticContext.kt
index cf4dd75..be2014b 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsStaticContext.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/JsStaticContext.kt
@@ -20,9 +20,9 @@
val intrinsics = JsIntrinsicTransformers(backendContext)
val classModels = mutableMapOf<IrClassSymbol, JsIrClassModel>()
- val coroutineImplDeclaration = backendContext.ir.symbols.coroutineImpl.owner
- val doResumeFunctionSymbol = coroutineImplDeclaration.declarations
- .filterIsInstance<IrSimpleFunction>().single { it.name.asString() == "doResume" }.symbol
+ val coroutineImplDeclaration = backendContext.ir.symbols.coroutineImpl
+ val doResumeFunction = coroutineImplDeclaration.declarations
+ .filterIsInstance<IrSimpleFunction>().single { it.name.asString() == "doResume" }
val initializerBlock = JsGlobalBlock()
}
\ No newline at end of file
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt
index 495076f..f41ead4 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt
@@ -26,10 +26,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrLocalDelegatedPropertySymbol
-import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
import org.jetbrains.kotlin.ir.util.SymbolTable
@@ -70,11 +66,11 @@
localClassInfo[container.attributeOwnerId] = value
}
- internal val localDelegatedProperties = mutableMapOf<IrClass, List<IrLocalDelegatedPropertySymbol>>()
+ internal val localDelegatedProperties = mutableMapOf<IrClass, List<IrLocalDelegatedProperty>>()
internal val multifileFacadesToAdd = mutableMapOf<JvmClassName, MutableList<IrClass>>()
internal val multifileFacadeForPart = mutableMapOf<IrClass, JvmClassName>()
- internal val multifileFacadeMemberToPartMember = mutableMapOf<IrFunctionSymbol, IrFunctionSymbol>()
+ internal val multifileFacadeMemberToPartMember = mutableMapOf<IrFunction, IrFunction>()
override var inVerbosePhase: Boolean = false
@@ -88,26 +84,26 @@
val suspendFunctionViews = mutableMapOf<IrFunction, IrFunction>()
val fakeContinuation: IrExpression = createFakeContinuation(this)
- val staticDefaultStubs = mutableMapOf<IrFunctionSymbol, IrFunction>()
+ val staticDefaultStubs = mutableMapOf<IrFunction, IrFunction>()
- internal fun getTopLevelClass(fqName: FqName): IrClassSymbol {
+ internal fun getTopLevelClass(fqName: FqName): IrClass {
val descriptor = state.module.getPackage(fqName.parent()).memberScope.getContributedClassifier(
fqName.shortName(), NoLookupLocation.FROM_BACKEND
) as ClassDescriptor? ?: error("Class is not found: $fqName")
return referenceClass(descriptor)
}
- internal fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol =
- symbolTable.referenceClass(descriptor)
+ internal fun referenceClass(descriptor: ClassDescriptor): IrClass =
+ symbolTable.referenceClass(descriptor).owner
- internal fun referenceTypeParameter(descriptor: TypeParameterDescriptor): IrTypeParameterSymbol =
- symbolTable.referenceTypeParameter(descriptor)
+ internal fun referenceTypeParameter(descriptor: TypeParameterDescriptor): IrTypeParameter =
+ symbolTable.referenceTypeParameter(descriptor).owner
- internal fun referenceFunction(descriptor: FunctionDescriptor): IrFunctionSymbol =
+ internal fun referenceFunction(descriptor: FunctionDescriptor): IrFunction =
if (descriptor is ClassConstructorDescriptor)
- symbolTable.referenceConstructor(descriptor)
+ symbolTable.referenceConstructor(descriptor).owner
else
- symbolTable.referenceSimpleFunction(descriptor)
+ symbolTable.referenceSimpleFunction(descriptor).owner
override fun log(message: () -> String) {
/*TODO*/
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt
index 0100f50..3fd2f3f 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt
@@ -67,10 +67,10 @@
state, sourceManager, irModuleFragment.irBuiltins, irModuleFragment, symbolTable, phaseConfig, firMode
)
state.irBasedMapAsmMethod = { descriptor ->
- context.methodSignatureMapper.mapAsmMethod(context.referenceFunction(descriptor).owner)
+ context.methodSignatureMapper.mapAsmMethod(context.referenceFunction(descriptor))
}
state.mapInlineClass = { descriptor ->
- context.typeMapper.mapType(context.referenceClass(descriptor).owner.defaultType)
+ context.typeMapper.mapType(context.referenceClass(descriptor).defaultType)
}
//TODO
ExternalDependenciesGenerator(
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt
index 75b24db..e36f8c0 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt
@@ -230,7 +230,8 @@
val jvmPhases = namedIrModulePhase(
name = "IrLowering",
description = "IR lowering",
- lower = expectDeclarationsRemovingPhase then
+ lower = desymbolizePhase then
+ expectDeclarationsRemovingPhase then
fileClassPhase then
performByIrFile(lower = jvmFilePhases) then
generateMultifileFacadesPhase
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
index e419c0c..0811c3d 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
@@ -14,11 +14,8 @@
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor
import org.jetbrains.kotlin.ir.builders.declarations.*
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
+import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
-import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.symbols.impl.IrExternalPackageFragmentSymbolImpl
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
@@ -47,33 +44,33 @@
private val irBuiltIns = context.irBuiltIns
- private val nullPointerExceptionClass: IrClassSymbol =
+ private val nullPointerExceptionClass: IrClass =
createClass(FqName("java.lang.NullPointerException")) { klass ->
klass.addConstructor().apply {
addValueParameter("message", irBuiltIns.stringType)
}
}
- override val ThrowNullPointerException: IrFunctionSymbol =
+ override val ThrowNullPointerException: IrFunction =
nullPointerExceptionClass.constructors.single()
- override val ThrowNoWhenBranchMatchedException: IrSimpleFunctionSymbol
+ override val ThrowNoWhenBranchMatchedException: IrFunction
get() = error("Unused in JVM IR")
- private val typeCastExceptionClass: IrClassSymbol =
+ private val typeCastExceptionClass: IrClass =
createClass(FqName("kotlin.TypeCastException")) { klass ->
klass.addConstructor().apply {
addValueParameter("message", irBuiltIns.stringType)
}
}
- override val ThrowTypeCastException: IrFunctionSymbol =
+ override val ThrowTypeCastException: IrFunction =
typeCastExceptionClass.constructors.single()
private fun createPackage(fqName: FqName): IrPackageFragment =
IrExternalPackageFragmentImpl(IrExternalPackageFragmentSymbolImpl(EmptyPackageFragmentDescriptor(context.state.module, fqName)))
- private fun createClass(fqName: FqName, classKind: ClassKind = ClassKind.CLASS, block: (IrClass) -> Unit = {}): IrClassSymbol =
+ private fun createClass(fqName: FqName, classKind: ClassKind = ClassKind.CLASS, block: (IrClass) -> Unit = {}): IrClass =
buildClass {
name = fqName.shortName()
kind = classKind
@@ -88,9 +85,9 @@
}
createImplicitParameterDeclarationWithWrappedDescriptor()
block(this)
- }.symbol
+ }
- private val intrinsicsClass: IrClassSymbol = createClass(
+ private val intrinsicsClass: IrClass = createClass(
JvmClassName.byInternalName(IrIntrinsicMethods.INTRINSICS_CLASS_NAME).fqNameForTopLevelClassMaybeWithDollars
) { klass ->
klass.addFunction("throwUninitializedPropertyAccessException", irBuiltIns.unitType, isStatic = true).apply {
@@ -106,63 +103,63 @@
}
}
- val checkExpressionValueIsNotNull: IrSimpleFunctionSymbol =
- intrinsicsClass.functions.single { it.owner.name.asString() == "checkExpressionValueIsNotNull" }
+ val checkExpressionValueIsNotNull: IrSimpleFunction =
+ intrinsicsClass.functions.single { it.name.asString() == "checkExpressionValueIsNotNull" }
- val checkNotNullExpressionValue: IrSimpleFunctionSymbol =
- intrinsicsClass.functions.single { it.owner.name.asString() == "checkNotNullExpressionValue" }
+ val checkNotNullExpressionValue: IrSimpleFunction =
+ intrinsicsClass.functions.single { it.name.asString() == "checkNotNullExpressionValue" }
- override val ThrowUninitializedPropertyAccessException: IrSimpleFunctionSymbol =
- intrinsicsClass.functions.single { it.owner.name.asString() == "throwUninitializedPropertyAccessException" }
+ override val ThrowUninitializedPropertyAccessException: IrSimpleFunction =
+ intrinsicsClass.functions.single { it.name.asString() == "throwUninitializedPropertyAccessException" }
- override val stringBuilder: IrClassSymbol
+ override val stringBuilder: IrClass
get() = context.getTopLevelClass(FqName("java.lang.StringBuilder"))
- override val defaultConstructorMarker: IrClassSymbol =
+ override val defaultConstructorMarker: IrClass =
createClass(FqName("kotlin.jvm.internal.DefaultConstructorMarker"))
- override val copyRangeTo: Map<ClassDescriptor, IrSimpleFunctionSymbol>
+ override val copyRangeTo: Map<ClassDescriptor, IrSimpleFunction>
get() = error("Unused in JVM IR")
- override val coroutineImpl: IrClassSymbol
+ override val coroutineImpl: IrClass
get() = TODO("not implemented")
- override val coroutineSuspendedGetter: IrSimpleFunctionSymbol
+ override val coroutineSuspendedGetter: IrSimpleFunction
get() = TODO("not implemented")
- override val getContinuation: IrSimpleFunctionSymbol
+ override val getContinuation: IrSimpleFunction
get() = TODO("not implemented")
- override val coroutineContextGetter: IrSimpleFunctionSymbol
+ override val coroutineContextGetter: IrSimpleFunction
get() = TODO("not implemented")
- override val suspendCoroutineUninterceptedOrReturn: IrSimpleFunctionSymbol
+ override val suspendCoroutineUninterceptedOrReturn: IrSimpleFunction
get() = TODO("not implemented")
- override val coroutineGetContext: IrSimpleFunctionSymbol
+ override val coroutineGetContext: IrSimpleFunction
get() = TODO("not implemented")
- override val returnIfSuspended: IrSimpleFunctionSymbol
+ override val returnIfSuspended: IrSimpleFunction
get() = TODO("not implemented")
- val javaLangClass: IrClassSymbol =
+ val javaLangClass: IrClass =
if (firMode) createClass(FqName("java.lang.Class")) else context.getTopLevelClass(FqName("java.lang.Class"))
- private val javaLangAssertionError: IrClassSymbol =
+ private val javaLangAssertionError: IrClass =
if (firMode) createClass(FqName("java.lang.AssertionError")) else context.getTopLevelClass(FqName("java.lang.AssertionError"))
- val assertionErrorConstructor by lazy<IrConstructorSymbol> {
+ val assertionErrorConstructor by lazy<IrConstructor> {
javaLangAssertionError.constructors.single {
- it.owner.valueParameters.size == 1 && it.owner.valueParameters[0].type.isNullableAny()
+ it.valueParameters.size == 1 && it.valueParameters[0].type.isNullableAny()
}
}
- val continuationClass: IrClassSymbol =
+ val continuationClass: IrClass =
createClass(DescriptorUtils.CONTINUATION_INTERFACE_FQ_NAME_RELEASE, ClassKind.INTERFACE) { klass ->
klass.addTypeParameter("T", irBuiltIns.anyNType, Variance.IN_VARIANCE)
}
- val lambdaClass: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.Lambda")) { klass ->
+ val lambdaClass: IrClass = createClass(FqName("kotlin.jvm.internal.Lambda")) { klass ->
klass.addConstructor().apply {
addValueParameter("arity", irBuiltIns.intType)
}
@@ -174,7 +171,7 @@
klass.addFunction("getOwner", irBuiltIns.kDeclarationContainerClass.typeWith(), Modality.OPEN)
}
- val functionReference: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.FunctionReference")) { klass ->
+ val functionReference: IrClass = createClass(FqName("kotlin.jvm.internal.FunctionReference")) { klass ->
klass.addConstructor().apply {
addValueParameter("arity", irBuiltIns.intType)
}
@@ -189,12 +186,12 @@
generateCallableReferenceMethods(klass)
}
- val functionReferenceReceiverField: IrFieldSymbol = functionReference.fieldByName("receiver")
- val functionReferenceGetSignature: IrSimpleFunctionSymbol = functionReference.functionByName("getSignature")
- val functionReferenceGetName: IrSimpleFunctionSymbol = functionReference.functionByName("getName")
- val functionReferenceGetOwner: IrSimpleFunctionSymbol = functionReference.functionByName("getOwner")
+ val functionReferenceReceiverField: IrField = functionReference.fieldByName("receiver")
+ val functionReferenceGetSignature: IrSimpleFunction = functionReference.functionByName("getSignature")
+ val functionReferenceGetName: IrSimpleFunction = functionReference.functionByName("getName")
+ val functionReferenceGetOwner: IrSimpleFunction = functionReference.functionByName("getOwner")
- fun getFunction(parameterCount: Int): IrClassSymbol =
+ fun getFunction(parameterCount: Int): IrClass =
symbolTable.referenceClass(builtIns.getFunction(parameterCount))
private val jvmFunctionClasses = storageManager.createMemoizedFunction { n: Int ->
@@ -212,10 +209,10 @@
}
}
- fun getJvmFunctionClass(parameterCount: Int): IrClassSymbol =
+ fun getJvmFunctionClass(parameterCount: Int): IrClass =
jvmFunctionClasses(parameterCount)
- val functionN: IrClassSymbol = createClass(FqName("kotlin.jvm.functions.FunctionN"), ClassKind.INTERFACE) { klass ->
+ val functionN: IrClass = createClass(FqName("kotlin.jvm.functions.FunctionN"), ClassKind.INTERFACE) { klass ->
val returnType = klass.addTypeParameter("R", irBuiltIns.anyNType, Variance.OUT_VARIANCE)
klass.addFunction("invoke", returnType.defaultType, Modality.ABSTRACT).apply {
@@ -291,10 +288,10 @@
}
}
- fun getPropertyReferenceClass(mutable: Boolean, parameterCount: Int, impl: Boolean): IrClassSymbol =
+ fun getPropertyReferenceClass(mutable: Boolean, parameterCount: Int, impl: Boolean): IrClass =
propertyReferenceClasses(PropertyReferenceKey(mutable, parameterCount, impl))
- val reflection: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.Reflection")) { klass ->
+ val reflection: IrClass = createClass(FqName("kotlin.jvm.internal.Reflection")) { klass ->
// We use raw types for java.lang.Class and kotlin.reflect.KClass here for simplicity and because this is what's used
// at declaration site at kotlin.jvm.internal.Reflection.
val rawJavaLangClass = javaLangClass.typeWith()
@@ -323,14 +320,14 @@
}
}
- val getOrCreateKotlinPackage: IrSimpleFunctionSymbol =
+ val getOrCreateKotlinPackage: IrSimpleFunction =
reflection.functionByName("getOrCreateKotlinPackage")
- val desiredAssertionStatus: IrSimpleFunctionSymbol by lazy {
+ val desiredAssertionStatus: IrSimpleFunction by lazy {
javaLangClass.functionByName("desiredAssertionStatus")
}
- val unsafeCoerceIntrinsic: IrSimpleFunctionSymbol =
+ val unsafeCoerceIntrinsic: IrSimpleFunction =
buildFun {
name = Name.special("<unsafe-coerce>")
origin = IrDeclarationOrigin.IR_BUILTINS_STUB
@@ -340,9 +337,9 @@
val dst = addTypeParameter("R", irBuiltIns.anyNType)
addValueParameter("v", src.defaultType)
returnType = dst.defaultType
- }.symbol
+ }
- private val collectionToArrayClass: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.CollectionToArray")) { klass ->
+ private val collectionToArrayClass: IrClass = createClass(FqName("kotlin.jvm.internal.CollectionToArray")) { klass ->
klass.origin = JvmLoweredDeclarationOrigin.TO_ARRAY
val arrayType = irBuiltIns.arrayClass.typeWith(irBuiltIns.anyNType)
@@ -357,13 +354,13 @@
}
}
- val nonGenericToArray: IrSimpleFunctionSymbol =
- collectionToArrayClass.functions.single { it.owner.name.asString() == "toArray" && it.owner.valueParameters.size == 1 }
+ val nonGenericToArray: IrSimpleFunction =
+ collectionToArrayClass.functions.single { it.name.asString() == "toArray" && it.valueParameters.size == 1 }
- val genericToArray: IrSimpleFunctionSymbol =
- collectionToArrayClass.functions.single { it.owner.name.asString() == "toArray" && it.owner.valueParameters.size == 2 }
+ val genericToArray: IrSimpleFunction =
+ collectionToArrayClass.functions.single { it.name.asString() == "toArray" && it.valueParameters.size == 2 }
- val kClassJava: IrPropertySymbol =
+ val kClassJava: IrProperty =
buildProperty {
name = Name.identifier("java")
}.apply {
@@ -372,9 +369,9 @@
addExtensionReceiver(irBuiltIns.kClassClass.typeWith())
returnType = javaLangClass.typeWith()
}
- }.symbol
+ }
- val spreadBuilder: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.SpreadBuilder")) { klass ->
+ val spreadBuilder: IrClass = createClass(FqName("kotlin.jvm.internal.SpreadBuilder")) { klass ->
klass.addConstructor().apply {
addValueParameter("size", irBuiltIns.intType)
}
@@ -394,7 +391,7 @@
}
}
- val primitiveSpreadBuilders: Map<IrType, IrClassSymbol> = irBuiltIns.primitiveIrTypes.associateWith { irType ->
+ val primitiveSpreadBuilders: Map<IrType, IrClass> = irBuiltIns.primitiveIrTypes.associateWith { irType ->
val name = irType.classOrNull!!.owner.name
createClass(FqName("kotlin.jvm.internal.${name}SpreadBuilder")) { klass ->
klass.addConstructor().apply {
@@ -416,7 +413,7 @@
}
}
- private val systemClass: IrClassSymbol = createClass(FqName("java.lang.System")) { klass ->
+ private val systemClass: IrClass = createClass(FqName("java.lang.System")) { klass ->
klass.addFunction("arraycopy", irBuiltIns.unitType, isStatic = true).apply {
addValueParameter("src", irBuiltIns.anyNType)
addValueParameter("srcPos", irBuiltIns.intType)
@@ -426,10 +423,10 @@
}
}
- val systemArraycopy: IrSimpleFunctionSymbol = systemClass.functionByName("arraycopy")
+ val systemArraycopy: IrSimpleFunction = systemClass.functionByName("arraycopy")
}
-private fun IrClassSymbol.functionByName(name: String): IrSimpleFunctionSymbol =
- functions.single { it.owner.name.asString() == name }
-private fun IrClassSymbol.fieldByName(name: String): IrFieldSymbol =
- fields.single { it.owner.name.asString() == name }
+private fun IrClass.functionByName(name: String): IrSimpleFunction =
+ functions.single { it.name.asString() == name }
+private fun IrClass.fieldByName(name: String): IrField =
+ fields.single { it.name.asString() == name }
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt
index ad21874..4d5f6ec 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt
@@ -172,7 +172,7 @@
private fun genAnnotationArguments(annotation: IrConstructorCall, annotationVisitor: AnnotationVisitor) {
val annotationClass = annotation.annotationClass
- for (param in annotation.symbol.owner.valueParameters) {
+ for (param in annotation.target.valueParameters) {
val value = annotation.getValueArgument(param.index)
if (value == null) {
if (param.defaultValue != null) continue // Default value will be supplied by JVM at runtime.
@@ -200,7 +200,7 @@
when (value) {
is IrConst<*> -> annotationVisitor.visit(name, value.value)
is IrConstructorCall -> {
- val callee = value.symbol.owner
+ val callee = value.target
when {
callee.parentAsClass.isAnnotationClass -> {
val internalAnnName = typeMapper.mapType(callee.returnType).descriptor
@@ -212,8 +212,8 @@
}
}
is IrGetEnumValue -> {
- val enumClassInternalName = typeMapper.mapClass(value.symbol.owner.parentAsClass).descriptor
- val enumEntryName = value.symbol.owner.name
+ val enumClassInternalName = typeMapper.mapClass(value.target.parentAsClass).descriptor
+ val enumEntryName = value.target.name
annotationVisitor.visitEnum(name, enumClassInternalName, enumEntryName.asString())
}
is IrVararg -> { // array constructor
@@ -270,7 +270,7 @@
fun IrConstructorCall.applicableTargetSet() =
annotationClass.applicableTargetSet() ?: KotlinTarget.DEFAULT_TARGET_SET
- val IrConstructorCall.annotationClass get() = symbol.owner.parentAsClass
+ val IrConstructorCall.annotationClass get() = target.parentAsClass
}
}
@@ -288,13 +288,13 @@
val retentionArgument =
getAnnotation(KotlinBuiltIns.FQ_NAMES.retention)?.getValueArgument(RETENTION_PARAMETER_NAME)
as? IrGetEnumValue?: return null
- val retentionArgumentValue = retentionArgument.symbol.owner
+ val retentionArgumentValue = retentionArgument.target
return KotlinRetention.valueOf(retentionArgumentValue.name.asString())
}
// To be generalized to IrMemberAccessExpression as soon as properties get symbols.
private fun IrConstructorCall.getValueArgument(name: Name): IrExpression? {
- val index = symbol.owner.valueParameters.find { it.name == name }?.index ?: return null
+ val index = target.valueParameters.find { it.name == name }?.index ?: return null
return getValueArgument(index)
}
@@ -311,6 +311,6 @@
val valueArgument = targetEntry.getValueArgument(TARGET_ALLOWED_TARGETS)
as? IrVararg ?: return null
return valueArgument.elements.filterIsInstance<IrGetEnumValue>().mapNotNull {
- KotlinTarget.valueOrNull(it.symbol.owner.name.asString())
+ KotlinTarget.valueOrNull(it.target.name.asString())
}.toSet()
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt
index 6f4895b..9468663 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt
@@ -338,7 +338,7 @@
// TODO: Since the class could have been reparented in lowerings, this could
// be a class instead of the actual function that the class is nested inside
// in the source.
- val containingDeclaration = irClass.symbol.owner.parent
+ val containingDeclaration = irClass.parent
if (containingDeclaration is IrFunction) {
val method = methodSignatureMapper.mapAsmMethod(containingDeclaration)
visitor.visitOuterClass(outerClassName, method.name, method.descriptor)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt
index 39a94bd..33e1eb6 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt
@@ -146,8 +146,8 @@
it.body = body?.deepCopyWithSymbols(this)
it.body?.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrGetValue =
- valueParametersMapping[expression.symbol.owner]?.let { newParam ->
- expression.run { IrGetValueImpl(startOffset, endOffset, type, newParam.symbol, origin) }
+ valueParametersMapping[expression.target]?.let { newParam ->
+ expression.run { IrGetValueImpl(startOffset, endOffset, type, newParam, origin) }
} ?: expression
override fun visitCall(expression: IrCall): IrExpression {
@@ -164,9 +164,9 @@
callerIsInlineLambda: Boolean
): IrCall {
if (!isSuspend) return this
- val view = (symbol.owner as IrSimpleFunction).getOrCreateSuspendFunctionViewIfNeeded(context)
- if (view == symbol.owner) return this
- return IrCallImpl(startOffset, endOffset, view.returnType, view.symbol).also {
+ val view = (target as IrSimpleFunction).getOrCreateSuspendFunctionViewIfNeeded(context)
+ if (view == target) return this
+ return IrCallImpl(startOffset, endOffset, view.returnType, view).also {
it.copyTypeArgumentsFrom(this)
it.dispatchReceiver = dispatchReceiver
it.extensionReceiver = extensionReceiver
@@ -176,9 +176,9 @@
val continuationParameter =
when {
caller.isInvokeSuspendOfLambda(context) || caller.isInvokeSuspendOfContinuation(context) ->
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, caller.dispatchReceiverParameter!!.symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, caller.dispatchReceiverParameter!!)
callerIsInlineLambda -> context.fakeContinuation
- else -> IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, caller.valueParameters.last().symbol)
+ else -> IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, caller.valueParameters.last())
}
it.putValueArgument(valueArgumentsCount, continuationParameter)
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
index acddc15..0484052 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
@@ -34,7 +34,6 @@
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.*
@@ -213,7 +212,7 @@
private fun generateNonNullAssertion(param: IrValueParameter) {
val asmType = param.type.asmType
if (!param.type.unboxInlineClass().isNullable() && !isPrimitive(asmType)) {
- mv.load(findLocalIndex(param.symbol), asmType)
+ mv.load(findLocalIndex(param), asmType)
mv.aconst(param.name.asString())
val methodName =
if (state.languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4) "checkNotNullParameter"
@@ -255,7 +254,7 @@
val type = typeMapper.mapType(param)
// NOTE: we expect all value parameters to be present in the frame.
mv.visitLocalVariable(
- name, type.descriptor, null, startLabel, endLabel, findLocalIndex(param.symbol)
+ name, type.descriptor, null, startLabel, endLabel, findLocalIndex(param)
)
}
@@ -286,7 +285,7 @@
}
info.variables.reversed().forEach {
- frameMap.leave(it.declaration.symbol)
+ frameMap.leave(it.declaration)
}
}
@@ -307,17 +306,17 @@
}
override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: BlockInfo): PromisedValue {
- classCodegen.context.irIntrinsics.getIntrinsic(expression.symbol)
+ classCodegen.context.irIntrinsics.getIntrinsic(expression.target)
?.invoke(expression, this, data)?.let { return it.coerce(expression.type) }
val callable = methodSignatureMapper.mapToCallableMethod(expression)
- val callee = expression.symbol.owner
+ val callee = expression.target
val callGenerator = getOrCreateCallGenerator(expression, data, callable.signature)
val asmType = if (expression is IrConstructorCall) typeMapper.mapTypeAsDeclaration(expression.type) else expression.asmType
when {
expression is IrConstructorCall -> {
- closureReifiedMarkers[expression.symbol.owner.parentAsClass]?.let {
+ closureReifiedMarkers[expression.target.parentAsClass]?.let {
if (it.wereUsedReifiedParameters()) {
putNeedClassReificationMarker(v)
propagateChildReifiedTypeParametersUsages(it)
@@ -335,7 +334,7 @@
for (argumentIndex in 0 until expression.typeArgumentsCount) {
val classifier = expression.getTypeArgument(argumentIndex)?.classifierOrNull
- if (classifier is IrTypeParameterSymbol && classifier.owner.isReified) {
+ if (classifier is IrTypeParameter && classifier.isReified) {
consumeReifiedOperationMarker(classifier)
}
}
@@ -358,7 +357,7 @@
}
callGenerator.beforeValueParametersStart()
- expression.symbol.owner.valueParameters.forEachIndexed { i, irParameter ->
+ expression.target.valueParameters.forEachIndexed { i, irParameter ->
val arg = expression.getValueArgument(i)
val parameterType = callable.valueParameterTypes[i]
require(arg != null) { "Null argument in ExpressionCodegen for parameter ${irParameter.render()}" }
@@ -400,7 +399,7 @@
override fun visitVariable(declaration: IrVariable, data: BlockInfo): PromisedValue {
val varType = typeMapper.mapType(declaration)
- val index = frameMap.enter(declaration.symbol, varType)
+ val index = frameMap.enter(declaration, varType)
declaration.markLineNumber(startOffset = true)
@@ -417,15 +416,15 @@
override fun visitGetValue(expression: IrGetValue, data: BlockInfo): PromisedValue {
// Do not generate line number information for loads from compiler-generated
// temporary variables. They do not correspond to variable loads in user code.
- if (expression.symbol.owner.origin != IrDeclarationOrigin.IR_TEMPORARY_VARIABLE)
+ if (expression.target.origin != IrDeclarationOrigin.IR_TEMPORARY_VARIABLE)
expression.markLineNumber(startOffset = true)
- val type = frameMap.typeOf(expression.symbol)
- mv.load(findLocalIndex(expression.symbol), type)
+ val type = frameMap.typeOf(expression.target)
+ mv.load(findLocalIndex(expression.target), type)
return MaterialValue(this, type, expression.type)
}
override fun visitFieldAccess(expression: IrFieldAccessExpression, data: BlockInfo): PromisedValue {
- val callee = expression.symbol.owner
+ val callee = expression.target
callee.constantValue()?.let {
// Handling const reads before codegen is important for constant folding.
assert(expression is IrSetField) { "read of const val ${callee.name} not inlined by ConstLowering" }
@@ -466,7 +465,7 @@
// i.e., not in an initializer block or constructor body.
val isFieldInitializer = expression.origin == null
val skip = (inPrimaryConstructor || inClassInit) && isFieldInitializer && expressionValue is IrConst<*> &&
- isDefaultValueForType(expression.symbol.owner.type.asmType, expressionValue.value)
+ isDefaultValueForType(expression.target.type.asmType, expressionValue.value)
return if (skip) defaultValue(expression.type) else super.visitSetField(expression, data)
}
@@ -485,19 +484,19 @@
else -> !isPrimitive(type) && value == null
}
- private fun findLocalIndex(irSymbol: IrSymbol): Int {
- val index = frameMap.getIndex(irSymbol)
+ private fun findLocalIndex(declaration: IrSymbolOwner): Int {
+ val index = frameMap.getIndex(declaration)
if (index >= 0)
return index
- val dump = if (irSymbol.isBound) irSymbol.owner.dump() else irSymbol.descriptor.toString()
+ val dump = if (declaration.symbol.isBound) declaration.dump() else declaration.symbol.descriptor.toString()
throw AssertionError("Non-mapped local declaration: $dump\n in ${irFunction.dump()}")
}
override fun visitSetVariable(expression: IrSetVariable, data: BlockInfo): PromisedValue {
expression.markLineNumber(startOffset = true)
expression.value.markLineNumber(startOffset = true)
- expression.value.accept(this, data).coerce(expression.symbol.owner.type).materialize()
- mv.store(findLocalIndex(expression.symbol), expression.symbol.owner.asmType)
+ expression.value.accept(this, data).coerce(expression.target.type).materialize()
+ mv.store(findLocalIndex(expression.target), expression.target.asmType)
return defaultValue(expression.type)
}
@@ -536,10 +535,10 @@
}
override fun visitReturn(expression: IrReturn, data: BlockInfo): PromisedValue {
- val returnTarget = expression.returnTargetSymbol.owner
+ val returnTarget = expression.irReturnTarget
val owner =
(returnTarget as? IrFunction
- ?: (returnTarget as? IrReturnableBlock)?.inlineFunctionSymbol?.owner
+ ?: (returnTarget as? IrReturnableBlock)?.inlineFunction
?: error("Unsupported IrReturnTarget: $returnTarget")).getOrCreateSuspendFunctionViewIfNeeded(context)
//TODO: should be owner != irFunction
val isNonLocalReturn =
@@ -946,13 +945,13 @@
private fun getOrCreateCallGenerator(
element: IrFunctionAccessExpression, data: BlockInfo, signature: JvmMethodSignature
): IrCallGenerator {
- if (!element.symbol.owner.isInlineFunctionCall(context) ||
+ if (!element.target.isInlineFunctionCall(context) ||
classCodegen.irClass.fileParent.fileEntry is MultifileFacadeFileEntry
) {
return IrCallGenerator.DefaultCallGenerator
}
- val callee = element.symbol.owner
+ val callee = element.target
val typeArgumentContainer = if (callee is IrConstructor) callee.parentAsClass else callee
val typeArguments =
if (element.typeArgumentsCount == 0) {
@@ -998,9 +997,9 @@
}
override fun consumeReifiedOperationMarker(typeParameter: TypeParameterMarker) {
- require(typeParameter is IrTypeParameterSymbol)
- if (typeParameter.owner.parent != irFunction) {
- classCodegen.reifiedTypeParametersUsages.addUsedReifiedParameter(typeParameter.owner.name.asString())
+ require(typeParameter is IrTypeParameter)
+ if (typeParameter.parent != irFunction) {
+ classCodegen.reifiedTypeParametersUsages.addUsedReifiedParameter(typeParameter.name.asString())
}
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt
index d3a47c5..122db46 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt
@@ -78,8 +78,8 @@
} else {
val frameMap = createFrameMapWithReceivers(signature)
val irClass = context.suspendFunctionContinuations[irFunction]
- val element = (irFunction.symbol.descriptor.psiElement
- ?: context.suspendLambdaToOriginalFunctionMap[irFunction.parent]?.symbol?.descriptor?.psiElement) as? KtElement
+ val element = (irFunction.descriptor.psiElement
+ ?: context.suspendLambdaToOriginalFunctionMap[irFunction.parent]?.descriptor?.psiElement) as? KtElement
val continuationClassBuilder = context.continuationClassBuilders[irClass]
methodVisitor = when {
irFunction.isSuspend &&
@@ -179,7 +179,7 @@
?.backingField
?.initializer.safeAs<IrExpressionBody>()
?.expression?.safeAs<IrGetValue>()
- ?.symbol?.owner?.safeAs<IrValueParameter>()
+ ?.target?.safeAs<IrValueParameter>()
?.defaultValue?.safeAs<IrExpressionBody>()
?.expression
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt
index e07aa6e..5d3e9bf3 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt
@@ -112,7 +112,7 @@
// TODO port inlining cycle detection to IrFunctionAccessExpression & pass it
state.globalInlineContext.enterIntoInlining(null)
try {
- performInline(expression.symbol.owner.typeParameters.map { it.symbol }, false, codegen.typeMapper.typeSystem, codegen)
+ performInline(expression.target.typeParameters, false, codegen.typeMapper.typeSystem, codegen)
} finally {
state.globalInlineContext.exitFromInliningOf(null)
}
@@ -124,7 +124,7 @@
parameter: IrValueParameter,
boundReceiver: IrVariable?
): LambdaInfo {
- val referencedFunction = irReference.symbol.owner
+ val referencedFunction = irReference.target
return IrExpressionLambdaImpl(
irReference, referencedFunction, codegen.typeMapper, codegen.methodSignatureMapper, codegen.context, parameter.isCrossinline,
boundReceiver != null, parameter.type.isExtensionFunctionType
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt
index 0312b3c..ddd85f2 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt
@@ -102,7 +102,7 @@
}
private fun getFunctionToInline(call: IrCall, jvmSignature: JvmMethodSignature, callDefault: Boolean): IrFunction {
- val callee = call.symbol.owner
+ val callee = call.target
val parent = callee.parentAsClass
if (callDefault) {
/*TODO: get rid of hack*/
@@ -115,8 +115,8 @@
}
if (parent.fileParent.fileEntry is MultifileFacadeFileEntry) {
- return (codegen.context.multifileFacadeMemberToPartMember[callee.symbol]
- ?: error("Function from a multi-file facade without the link to the function in the part: ${callee.render()}")).owner
+ return (codegen.context.multifileFacadeMemberToPartMember[callee]
+ ?: error("Function from a multi-file facade without the link to the function in the part: ${callee.render()}"))
}
return callee
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrTypeMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrTypeMapper.kt
index bdc69c3..666bbf5 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrTypeMapper.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrTypeMapper.kt
@@ -19,7 +19,6 @@
import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
import org.jetbrains.kotlin.ir.util.defaultType
@@ -39,9 +38,9 @@
override fun mapClass(classifier: ClassifierDescriptor): Type =
when (classifier) {
is ClassDescriptor ->
- mapClass(context.referenceClass(classifier).owner)
+ mapClass(context.referenceClass(classifier))
is TypeParameterDescriptor ->
- mapType(context.referenceTypeParameter(classifier).owner.defaultType)
+ mapType(context.referenceTypeParameter(classifier).defaultType)
else ->
error("Unknown descriptor: $classifier")
}
@@ -54,7 +53,7 @@
if (sw.skipGenericSignature()) return
with(KotlinTypeMapper) {
for (typeParameter in irParameters) {
- typeSystem.writeFormalTypeParameter(typeParameter.symbol, sw) { type, mode ->
+ typeSystem.writeFormalTypeParameter(typeParameter, sw) { type, mode ->
mapType(type as IrType, mode, sw)
}
}
@@ -243,7 +242,7 @@
private fun writeGenericArguments(
sw: JvmSignatureWriter,
arguments: List<IrTypeArgument>,
- parameters: List<IrTypeParameterSymbol>,
+ parameters: List<IrTypeParameter>,
mode: TypeMappingMode
) = with(KotlinTypeMapper) {
typeSystem.writeGenericArguments(sw, arguments, parameters, mode) { type, sw, mode ->
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt
index 6dcb259..39d38d5 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt
@@ -292,7 +292,7 @@
}
fun mapToCallableMethod(expression: IrFunctionAccessExpression): IrCallableMethod {
- val callee = expression.symbol.owner.getOrCreateSuspendFunctionViewIfNeeded(context)
+ val callee = expression.target.getOrCreateSuspendFunctionViewIfNeeded(context)
val calleeParent = callee.parent
if (calleeParent !is IrClass) {
// Non-class parent is only possible for intrinsics created in IrBuiltIns, such as dataClassArrayMemberHashCode. In that case,
@@ -331,7 +331,7 @@
private fun mapOverriddenSpecialBuiltinIfNeeded(callee: IrFunction, superCall: Boolean): JvmMethodSignature? {
val overriddenSpecialBuiltinFunction = callee.descriptor.original.getOverriddenBuiltinReflectingJvmDescriptor()
if (overriddenSpecialBuiltinFunction != null && !superCall) {
- return mapSignatureSkipGeneric(context.referenceFunction(overriddenSpecialBuiltinFunction.original).owner)
+ return mapSignatureSkipGeneric(context.referenceFunction(overriddenSpecialBuiltinFunction.original))
}
return null
@@ -342,7 +342,7 @@
var current = function
while (current.isFakeOverride) {
// TODO: probably isJvmInterface instead of isInterface, here and in KotlinTypeMapper
- val classCallable = current.overriddenSymbols.firstOrNull { !it.owner.parentAsClass.isInterface }?.owner
+ val classCallable = current.overridden.firstOrNull { !it.parentAsClass.isInterface }
if (classCallable != null) {
current = classCallable
continue
@@ -351,7 +351,7 @@
return current
}
- current = current.overriddenSymbols.firstOrNull()?.owner
+ current = current.overridden.firstOrNull()
?: error("Fake override should have at least one overridden descriptor: ${current.render()}")
}
return current
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/SwitchGenerator.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/SwitchGenerator.kt
index 849c529..10e6321 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/SwitchGenerator.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/SwitchGenerator.kt
@@ -80,12 +80,12 @@
private fun areConstComparisons(conditions: List<IrCall>): Boolean {
// All branches must be CALL 'EQEQ(Any?, Any?)': Boolean
- if (conditions.any { it.symbol != codegen.classCodegen.context.irBuiltIns.eqeqSymbol })
+ if (conditions.any { it.target != codegen.classCodegen.context.irBuiltIns.eqeqSymbol.owner })
return false
// All LHS refer to the same tmp variable.
val lhs = conditions.map { it.getValueArgument(0) as? IrGetValue }
- if (lhs.any { it == null || it.symbol != lhs[0]!!.symbol })
+ if (lhs.any { it == null || it.target != lhs[0]!!.target })
return false
// All RHS are constants
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt
index 9c72f2e..92d8a4d 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt
@@ -26,8 +26,6 @@
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.IrSimpleType
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.util.*
@@ -48,31 +46,31 @@
import org.jetbrains.org.objectweb.asm.Opcodes
import org.jetbrains.org.objectweb.asm.Type
-class IrFrameMap : FrameMapBase<IrSymbol>() {
- private val typeMap = mutableMapOf<IrSymbol, Type>()
+class IrFrameMap : FrameMapBase<IrSymbolOwner>() {
+ private val typeMap = mutableMapOf<IrSymbolOwner, Type>()
- override fun enter(descriptor: IrSymbol, type: Type): Int {
+ override fun enter(descriptor: IrSymbolOwner, type: Type): Int {
typeMap[descriptor] = type
return super.enter(descriptor, type)
}
- override fun leave(descriptor: IrSymbol): Int {
+ override fun leave(descriptor: IrSymbolOwner): Int {
typeMap.remove(descriptor)
return super.leave(descriptor)
}
- fun typeOf(descriptor: IrSymbol): Type = typeMap.getValue(descriptor)
+ fun typeOf(descriptor: IrSymbolOwner): Type = typeMap.getValue(descriptor)
}
internal val IrFunction.isStatic
get() = (this.dispatchReceiverParameter == null && this !is IrConstructor)
fun IrFrameMap.enter(irDeclaration: IrSymbolOwner, type: Type): Int {
- return enter(irDeclaration.symbol, type)
+ return enter(irDeclaration, type)
}
fun IrFrameMap.leave(irDeclaration: IrSymbolOwner): Int {
- return leave(irDeclaration.symbol)
+ return leave(irDeclaration)
}
val IrClass.isJvmInterface get() = isAnnotationClass || isInterface
@@ -375,7 +373,7 @@
val kotlinMarkerInterfaces = LinkedHashSet<String>()
for (superType in irClass.superTypes) {
- val superClass = superType.safeAs<IrSimpleType>()?.classifier?.safeAs<IrClassSymbol>()?.owner ?: continue
+ val superClass = superType.safeAs<IrSimpleType>()?.classifier?.safeAs<IrClass>() ?: continue
if (superClass.isJvmInterface) {
val kotlinInterfaceName = superClass.fqNameWhenAvailable!!
@@ -548,7 +546,7 @@
val IrAnnotationContainer.deprecationFlags: Int
get() {
val annotation = annotations.findAnnotation(FQ_NAMES.deprecated) ?: return 0
- val isHidden = (annotation.getValueArgument(2) as? IrGetEnumValue)?.symbol?.owner
+ val isHidden = (annotation.getValueArgument(2) as? IrGetEnumValue)?.target
?.name?.asString() == DeprecationLevel.HIDDEN.name
return Opcodes.ACC_DEPRECATED or if (isHidden) Opcodes.ACC_SYNTHETIC else 0
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt
index 3f499ea..5f81b0e 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt
@@ -25,8 +25,6 @@
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrExternalPackageFragmentSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl
@@ -162,8 +160,8 @@
else
objectRefProvider
- private fun getElementFieldSymbol(valueType: IrType): IrFieldSymbol {
- return getProvider(valueType).elementField.symbol
+ private fun getElementField(valueType: IrType): IrField {
+ return getProvider(valueType).elementField
}
override fun declareSharedVariable(originalDeclaration: IrVariable): IrVariable {
@@ -174,7 +172,7 @@
val refConstructorCall = IrConstructorCallImpl.fromSymbolOwner(
refType,
- refConstructor.symbol,
+ refConstructor,
SHARED_VARIABLE_CONSTRUCTOR_CALL_ORIGIN
).apply {
List(refConstructor.parentAsClass.typeParameters.size) { i ->
@@ -207,8 +205,8 @@
val sharedVariableInitialization = IrSetFieldImpl(
initializer.startOffset, initializer.endOffset,
- getElementFieldSymbol(valueType),
- IrGetValueImpl(initializer.startOffset, initializer.endOffset, sharedVariableDeclaration.symbol),
+ getElementField(valueType),
+ IrGetValueImpl(initializer.startOffset, initializer.endOffset, sharedVariableDeclaration),
initializer,
valueType
)
@@ -219,7 +217,7 @@
)
}
- override fun getSharedValue(sharedVariableSymbol: IrVariableSymbol, originalGet: IrGetValue): IrExpression =
+ override fun getSharedValue(sharedVariable: IrVariable, originalGet: IrGetValue): IrExpression =
IrTypeOperatorCallImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
originalGet.type,
@@ -227,18 +225,18 @@
originalGet.type,
IrGetFieldImpl(
originalGet.startOffset, originalGet.endOffset,
- getElementFieldSymbol(originalGet.symbol.owner.type),
+ getElementField(originalGet.target.type),
originalGet.type,
- IrGetValueImpl(originalGet.startOffset, originalGet.endOffset, sharedVariableSymbol),
+ IrGetValueImpl(originalGet.startOffset, originalGet.endOffset, sharedVariable),
originalGet.origin
)
)
- override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetVariable): IrExpression =
+ override fun setSharedValue(sharedVariable: IrVariable, originalSet: IrSetVariable): IrExpression =
IrSetFieldImpl(
originalSet.startOffset, originalSet.endOffset,
- getElementFieldSymbol(originalSet.symbol.owner.type),
- IrGetValueImpl(originalSet.startOffset, originalSet.endOffset, sharedVariableSymbol),
+ getElementField(originalSet.target.type),
+ IrGetValueImpl(originalSet.startOffset, originalSet.endOffset, sharedVariable),
originalSet.value,
originalSet.type,
originalSet.origin
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt
index 3ea8e81..f070705 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt
@@ -29,7 +29,7 @@
signature: JvmMethodSignature,
context: JvmBackendContext
): IrIntrinsicFunction {
- val owner = context.typeMapper.mapClass(expression.symbol.owner.parentAsClass)
+ val owner = context.typeMapper.mapClass(expression.target.parentAsClass)
return IrIntrinsicFunction.create(expression, signature, context, owner) {
val methodSignature = "(${owner.descriptor})${signature.returnType.descriptor}"
val intrinsicOwner =
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt
index f3a7cb0..168abb3 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt
@@ -38,7 +38,7 @@
): IrIntrinsicFunction {
val returnType = signature.returnType
val intermediateResultType = numberFunctionOperandType(returnType)
- val argTypes = if (!expression.symbol.owner.parentAsClass.defaultType.isChar()) {
+ val argTypes = if (!expression.target.parentAsClass.defaultType.isChar()) {
listOf(intermediateResultType, if (shift()) Type.INT_TYPE else intermediateResultType)
} else {
listOf(Type.CHAR_TYPE, signature.valueParameters[0].asmType)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt
index 6321074..a3dea80 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt
@@ -25,7 +25,7 @@
open fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
with(codegen) {
- val descriptor = methodSignatureMapper.mapSignatureSkipGeneric(expression.symbol.owner)
+ val descriptor = methodSignatureMapper.mapSignatureSkipGeneric(expression.target)
val stackValue = toCallable(expression, descriptor, context).invoke(mv, codegen, data)
return object : PromisedValue(this, stackValue.type, expression.type) {
override fun materialize() = stackValue.put(mv)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt
index 6648cad..2f5c86d 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt
@@ -74,7 +74,7 @@
var offset = 0
expression.dispatchReceiver?.let { genArg(it, codegen, offset++, data) }
expression.extensionReceiver?.let { genArg(it, codegen, offset++, data) }
- for ((i, valueParameter) in expression.symbol.owner.valueParameters.withIndex()) {
+ for ((i, valueParameter) in expression.target.valueParameters.withIndex()) {
val argument = expression.getValueArgument(i)
when {
argument != null ->
@@ -82,7 +82,7 @@
valueParameter.isVararg -> {
// TODO: is there an easier way to get the substituted type of an empty vararg argument?
val arrayType = codegen.typeMapper.mapType(
- valueParameter.type.substitute(expression.symbol.owner.typeParameters, expression.typeArguments)
+ valueParameter.type.substitute(expression.target.typeParameters, expression.typeArguments)
)
StackValue.operation(arrayType) {
it.aconst(0)
@@ -140,11 +140,10 @@
}
fun IrFunctionAccessExpression.argTypes(context: JvmBackendContext): ArrayList<Type> {
- val callee = symbol.owner
- val signature = context.methodSignatureMapper.mapSignatureSkipGeneric(callee)
+ val signature = context.methodSignatureMapper.mapSignatureSkipGeneric(target)
return arrayListOf<Type>().apply {
if (dispatchReceiver != null) {
- add(context.typeMapper.mapClass(callee.parentAsClass))
+ add(context.typeMapper.mapClass(target.parentAsClass))
}
addAll(signature.asmMethod.argumentTypes)
}
@@ -152,5 +151,5 @@
fun IrFunctionAccessExpression.receiverAndArgs(): List<IrExpression> {
return (arrayListOf(this.dispatchReceiver, this.extensionReceiver) +
- symbol.owner.valueParameters.mapIndexed { i, _ -> getValueArgument(i) }).filterNotNull()
+ target.valueParameters.mapIndexed { i, _ -> getValueArgument(i) }).filterNotNull()
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt
index 52df309..f2debf1 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt
@@ -21,10 +21,6 @@
import org.jetbrains.kotlin.builtins.PrimitiveType
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.types.classOrNull
import org.jetbrains.kotlin.ir.types.classifierOrNull
import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
@@ -138,7 +134,7 @@
private val PrimitiveType.symbol
get() = irBuiltIns.primitiveTypeToIrType[this]!!.classOrNull!!
- fun getIntrinsic(symbol: IrFunctionSymbol): IntrinsicMethod? = intrinsicsMap[symbol.toKey()]
+ fun getIntrinsic(target: IrFunction): IntrinsicMethod? = intrinsicsMap[target.toKey()]
private fun unaryFunForPrimitives(name: String, intrinsic: IntrinsicMethod): List<Pair<Key, IntrinsicMethod>> =
PrimitiveType.values().map { type ->
@@ -154,12 +150,12 @@
private fun binaryFunForPrimitives(
name: String,
intrinsic: IntrinsicMethod,
- parameter: IrClassifierSymbol
+ parameter: IrClassifier
): List<Pair<Key, IntrinsicMethod>> =
PrimitiveType.values().map { type ->
createKeyMapping(
intrinsic,
- type.symbol,
+ type.symbol.owner,
name,
parameter
)
@@ -175,12 +171,12 @@
private fun arrayMethods(): List<Pair<Key, IntrinsicMethod>> =
symbols.primitiveArrays.flatMap { (key, value) ->
arrayMethods(
- key.symbol,
+ key.symbol.owner,
value
)
} + arrayMethods(symbols.array.owner.typeParameters.single().symbol, symbols.array)
- private fun arrayMethods(elementClass: IrClassifierSymbol, arrayClass: IrClassSymbol) =
+ private fun arrayMethods(elementClass: IrClassifier, arrayClass: IrClass) =
listOf(
createKeyMapping(ArraySize, arrayClass, "<get-size>"),
createKeyMapping(NewArray, arrayClass, "<init>", irBuiltIns.intClass),
@@ -200,8 +196,8 @@
private val DEC = Increment(-1)
private val EQUALS = Equals(KtTokens.EQEQ)
- private fun IrFunctionSymbol.toKey(): Key? {
- val parent = owner.parent
+ private fun IrFunction.toKey(): Key? {
+ val parent = this.parent
val ownerFqName = when {
parent is IrClass && parent.origin == IrDeclarationOrigin.FILE_CLASS ->
(parent.parent as IrPackageFragment).fqName
@@ -211,17 +207,17 @@
}
return Key(
ownerFqName,
- getParameterFqName(owner.extensionReceiverParameter),
- owner.name.asString(),
- owner.valueParameters.map(::getParameterFqName)
+ getParameterFqName(extensionReceiverParameter),
+ name.asString(),
+ valueParameters.map(::getParameterFqName)
)
}
private fun getParameterFqName(parameter: IrValueParameter?): FqName? =
getParameterFqName(parameter?.type?.classifierOrNull)
- private fun getParameterFqName(parameter: IrClassifierSymbol?): FqName? =
- parameter?.owner?.let {
+ private fun getParameterFqName(parameter: IrClassifier?): FqName? =
+ parameter?.let {
when (it) {
is IrClass -> it.fqNameWhenAvailable
is IrTypeParameter -> FqName(it.name.asString())
@@ -231,26 +227,26 @@
private fun createKeyMapping(
intrinsic: IntrinsicMethod,
- klass: IrClassSymbol,
+ klass: IrClass,
name: String,
- vararg args: IrClassifierSymbol
+ vararg args: IrClassifier
): Pair<Key, IntrinsicMethod> =
- Key(klass.owner.fqNameWhenAvailable!!, null, name, args.map {
+ Key(klass.fqNameWhenAvailable!!, null, name, args.map {
getParameterFqName(it)
}) to intrinsic
- private fun numberConversionMethods(numberClass: IrClassSymbol) =
+ private fun numberConversionMethods(numberClass: IrClass) =
OperatorConventions.NUMBER_CONVERSIONS.map { method ->
createKeyMapping(NumberCast, numberClass, method.asString())
}
private fun primitiveComparisonIntrinsics(
- typeToIrFun: Map<SimpleType, IrSimpleFunctionSymbol>,
+ typeToIrFun: Map<SimpleType, IrSimpleFunction>,
operator: KtSingleValueToken
): List<Pair<Key, PrimitiveComparison>> =
- typeToIrFun.map { (type, irFunSymbol) ->
- irFunSymbol.toKey()!! to PrimitiveComparison(type, operator)
+ typeToIrFun.map { (type, irFun) ->
+ irFun.toKey()!! to PrimitiveComparison(type, operator)
}
}
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrArrayBuilder.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrArrayBuilder.kt
index 9d46bae..c82d777 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrArrayBuilder.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrArrayBuilder.kt
@@ -65,7 +65,7 @@
val arrayConstructor = if (unwrappedArrayType.isBoxedArray)
builder.irSymbols.arrayOfNulls
else
- unwrappedArrayType.classOrNull!!.constructors.single { it.owner.valueParameters.size == 1 }
+ unwrappedArrayType.classOrNull!!.constructors.single { it.valueParameters.size == 1 }
return builder.irCall(arrayConstructor, unwrappedArrayType).apply {
if (typeArgumentsCount != 0)
@@ -80,7 +80,7 @@
val result = irTemporary(newArray(elements.size))
val set = unwrappedArrayType.classOrNull!!.functions.single {
- it.owner.name.asString() == "set"
+ it.name.asString() == "set"
}
for ((index, element) in elements.withIndex()) {
@@ -97,11 +97,11 @@
// Copy a single spread expression, unless it refers to a newly constructed array.
private fun copyArray(spread: IrExpression): IrExpression {
if (spread is IrConstructorCall ||
- (spread is IrFunctionAccessExpression && spread.symbol == builder.irSymbols.arrayOfNulls))
+ (spread is IrFunctionAccessExpression && spread.target == builder.irSymbols.arrayOfNulls))
return spread
return builder.irBlock {
- val spreadVar = if (spread is IrGetValue) spread.symbol.owner else irTemporary(spread)
+ val spreadVar = if (spread is IrGetValue) spread.target else irTemporary(spread)
val size = unwrappedArrayType.classOrNull!!.getPropertyGetter("size")!!
fun getSize() = irCall(size).apply { dispatchReceiver = irGet(spreadVar) }
val result = irTemporary(newArray(getSize()))
@@ -123,9 +123,9 @@
else
builder.irSymbols.primitiveSpreadBuilders.getValue(elementType)
- val addElement = spreadBuilder.functions.single { it.owner.name.asString() == "add" }
- val addSpread = spreadBuilder.functions.single { it.owner.name.asString() == "addSpread" }
- val toArray = spreadBuilder.functions.single { it.owner.name.asString() == "toArray" }
+ val addElement = spreadBuilder.functions.single { it.name.asString() == "add" }
+ val addSpread = spreadBuilder.functions.single { it.name.asString() == "addSpread" }
+ val toArray = spreadBuilder.functions.single { it.name.asString() == "toArray" }
return builder.irBlock {
val spreadBuilderVar = irTemporary(irCallConstructor(spreadBuilder.constructors.single(), listOf()).apply {
@@ -142,7 +142,7 @@
val toArrayCall = irCall(toArray).apply {
dispatchReceiver = irGet(spreadBuilderVar)
if (unwrappedArrayType.isBoxedArray) {
- val size = spreadBuilder.functions.single { it.owner.name.asString() == "size" }
+ val size = spreadBuilder.functions.single { it.name.asString() == "size" }
putValueArgument(0, irCall(builder.irSymbols.arrayOfNulls, arrayType).apply {
putTypeArgument(0, elementType)
putValueArgument(0, irCall(size).apply {
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrUtils.kt
index c60a9c8b..35a5eb9 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrUtils.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrUtils.kt
@@ -16,7 +16,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
@@ -102,12 +101,12 @@
// An IR builder with a reference to the JvmBackendContext
class JvmIrBuilder(
val backendContext: JvmBackendContext,
- val symbol: IrSymbol,
+ val owner: IrSymbolOwner,
startOffset: Int = UNDEFINED_OFFSET,
endOffset: Int = UNDEFINED_OFFSET
) : IrBuilderWithScope(
IrLoweringContext(backendContext),
- Scope(symbol),
+ Scope(owner),
startOffset,
endOffset
) {
@@ -116,7 +115,7 @@
}
fun JvmBackendContext.createJvmIrBuilder(
- symbol: IrSymbol,
+ owner: IrSymbolOwner,
startOffset: Int = UNDEFINED_OFFSET,
endOffset: Int = UNDEFINED_OFFSET
-) = JvmIrBuilder(this, symbol, startOffset, endOffset)
+) = JvmIrBuilder(this, owner, startOffset, endOffset)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt
index f2fb98d..740d728 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt
@@ -31,7 +31,6 @@
import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection
@@ -85,15 +84,15 @@
if (!expression.isSuspend)
return expression
- val constructor = suspendLambdas.singleOrNull { it.function == expression.symbol.owner }?.constructor
+ val constructor = suspendLambdas.singleOrNull { it.function == expression.target }?.constructor
?: return expression
val expressionArguments = expression.getArguments().map { it.second }
assert(constructor.valueParameters.size == expressionArguments.size) {
"Inconsistency between callable reference to suspend lambda and the corresponding continuation"
}
- val irBuilder = context.createIrBuilder(expression.symbol, expression.startOffset, expression.endOffset)
+ val irBuilder = context.createIrBuilder(expression.target, expression.startOffset, expression.endOffset)
irBuilder.run {
- return irCall(constructor.symbol).apply {
+ return irCall(constructor).apply {
expressionArguments.forEachIndexed { index, argument ->
putValueArgument(index, argument)
}
@@ -104,13 +103,12 @@
}
private fun generateContinuationClassForLambda(info: SuspendLambdaInfo) {
- val suspendLambda = suspendLambda.owner
suspendLambda.createContinuationClassFor(info.function).apply {
copyAttributes(info.reference)
val functionNClass = context.ir.symbols.getJvmFunctionClass(info.arity + 1)
superTypes.add(
IrSimpleTypeImpl(
- functionNClass,
+ functionNClass.symbol,
hasQuestionMark = false,
arguments = (info.function.explicitParameters.subList(0, info.arity).map { it.type }
+ info.function.continuationType() + info.function.returnType)
@@ -130,7 +128,7 @@
val constructor = addPrimaryConstructorForLambda(info.arity, info.function, parametersFields)
val secondaryConstructor = addSecondaryConstructorForLambda(constructor)
val invokeToOverride = functionNClass.functions.single {
- it.owner.valueParameters.size == info.arity + 1 && it.owner.name.asString() == "invoke"
+ it.valueParameters.size == info.arity + 1 && it.name.asString() == "invoke"
}
val invokeSuspend = addInvokeSuspendForLambda(info.function, parametersFields, receiverField)
if (info.arity <= 1) {
@@ -152,38 +150,38 @@
receiverField: IrField?
): IrFunction {
val superMethod = suspendLambda.functions.single {
- it.owner.name.asString() == INVOKE_SUSPEND_METHOD_NAME && it.owner.valueParameters.size == 1 &&
- it.owner.valueParameters[0].type.isKotlinResult()
- }.owner
+ it.name.asString() == INVOKE_SUSPEND_METHOD_NAME && it.valueParameters.size == 1 &&
+ it.valueParameters[0].type.isKotlinResult()
+ }
return addFunctionOverride(superMethod)
.also { function ->
function.copyTypeParametersFrom(irFunction)
function.body = irFunction.body?.deepCopyWithSymbols(function)
function.body?.transformChildrenVoid(object : IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrExpression {
- if (expression.symbol.owner == irFunction.extensionReceiverParameter) {
+ if (expression.target == irFunction.extensionReceiverParameter) {
assert(receiverField != null)
return IrGetFieldImpl(
expression.startOffset,
expression.endOffset,
- receiverField!!.symbol,
+ receiverField!!,
receiverField.type
).also {
it.receiver =
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, function.dispatchReceiverParameter!!.symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, function.dispatchReceiverParameter!!)
}
- } else if (expression.symbol.owner == irFunction.dispatchReceiverParameter) {
- return IrGetValueImpl(expression.startOffset, expression.endOffset, function.dispatchReceiverParameter!!.symbol)
+ } else if (expression.target == irFunction.dispatchReceiverParameter) {
+ return IrGetValueImpl(expression.startOffset, expression.endOffset, function.dispatchReceiverParameter!!)
}
- val field = fields.find { it.name == expression.symbol.owner.name } ?: return expression
- return IrGetFieldImpl(expression.startOffset, expression.endOffset, field.symbol, field.type).also {
- it.receiver = IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, function.dispatchReceiverParameter!!.symbol)
+ val field = fields.find { it.name == expression.target.name } ?: return expression
+ return IrGetFieldImpl(expression.startOffset, expression.endOffset, field, field.type).also {
+ it.receiver = IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, function.dispatchReceiverParameter!!)
}
}
override fun visitReturn(expression: IrReturn): IrExpression {
val ret = super.visitReturn(expression) as IrReturn
- return IrReturnImpl(ret.startOffset, ret.endOffset, context.irBuiltIns.anyType, function.symbol, ret.value)
+ return IrReturnImpl(ret.startOffset, ret.endOffset, context.irBuiltIns.anyType, function, ret.value)
}
})
(irFunction.parent as IrDeclarationContainer).declarations.remove(irFunction)
@@ -195,19 +193,19 @@
modality: Modality = Modality.FINAL
): IrSimpleFunction =
addFunction(function.name.asString(), function.returnType, modality).apply {
- overriddenSymbols.add(function.symbol)
+ overridden.add(function)
function.valueParameters.mapTo(valueParameters) { it.copyTo(this) }
}
private fun IrClass.addInvoke(
create: IrFunction,
invokeSuspend: IrFunction,
- invokeToOverride: IrSimpleFunctionSymbol
+ invokeToOverride: IrSimpleFunction
) {
val unitClass = context.irBuiltIns.unitClass
val unitField = context.declarationFactory.getFieldForObjectInstance(unitClass.owner)
- addFunctionOverride(invokeToOverride.owner).also { function ->
- function.body = context.createIrBuilder(function.symbol).irBlockBody {
+ addFunctionOverride(invokeToOverride).also { function ->
+ function.body = context.createIrBuilder(function).irBlockBody {
+irReturn(irCall(invokeSuspend).also { invokeSuspendCall ->
invokeSuspendCall.dispatchReceiver = irCall(create).also {
it.dispatchReceiver = irGet(function.dispatchReceiverParameter!!)
@@ -234,7 +232,7 @@
if (arity == 1) it.valueParameters.first().type.isNullableAny() else true
}
return addFunctionOverride(create).also { function ->
- function.body = context.createIrBuilder(function.symbol).irBlockBody {
+ function.body = context.createIrBuilder(function).irBlockBody {
val constructorCall = irCall(constructor).also {
for ((i, field) in parametersFields.withIndex()) {
it.putValueArgument(i, irGetField(irGet(function.dispatchReceiverParameter!!), field))
@@ -277,15 +275,15 @@
returnType = defaultType
}.also { constructor ->
irFunction.valueParameters.mapTo(constructor.valueParameters) { it.copyTo(constructor) }
- val completionParameterSymbol = constructor.addCompletionValueParameter()
+ val completionParameter = constructor.addCompletionValueParameter()
- val superClassConstructor = suspendLambda.owner.constructors.single {
+ val superClassConstructor = suspendLambda.constructors.single {
it.valueParameters.size == 2 && it.valueParameters[0].type.isInt() && it.valueParameters[1].type.isNullableContinuation()
}
- constructor.body = context.createIrBuilder(constructor.symbol).irBlockBody {
+ constructor.body = context.createIrBuilder(constructor).irBlockBody {
+irDelegatingConstructorCall(superClassConstructor).also {
it.putValueArgument(0, irInt(arity + 1))
- it.putValueArgument(1, irGet(completionParameterSymbol))
+ it.putValueArgument(1, irGet(completionParameter))
}
for ((index, param) in constructor.valueParameters.dropLast(1).withIndex()) {
@@ -301,7 +299,7 @@
}.also { constructor ->
constructor.valueParameters.addAll(primary.valueParameters.dropLast(1).map { it.copyTo(constructor) })
- constructor.body = context.createIrBuilder(constructor.symbol).irBlockBody {
+ constructor.body = context.createIrBuilder(constructor).irBlockBody {
+irDelegatingConstructorCall(primary).also {
for ((index, param) in constructor.valueParameters.withIndex()) {
it.putValueArgument(index, irGet(param))
@@ -318,7 +316,7 @@
continuation.createType(true, listOf(makeTypeProjection(returnType, Variance.INVARIANT)))
private fun generateContinuationClassForNamedFunction(irFunction: IrFunction) {
- continuationImpl.owner.createContinuationClassFor(irFunction).apply {
+ continuationImpl.createContinuationClassFor(irFunction).apply {
val resultField = addField(
context.state.languageVersionSettings.dataFieldName(),
context.irBuiltIns.anyType,
@@ -338,15 +336,15 @@
returnType = defaultType
}.also { constructor ->
val capturedThisParameter = capturedThisField?.let { constructor.addValueParameter(it.name.asString(), it.type) }
- val completionParameterSymbol = constructor.addCompletionValueParameter()
+ val completionParameter = constructor.addCompletionValueParameter()
- val superClassConstructor = continuationImpl.owner.constructors.single { it.valueParameters.size == 1 }
- constructor.body = context.createIrBuilder(constructor.symbol).irBlockBody {
+ val superClassConstructor = continuationImpl.constructors.single { it.valueParameters.size == 1 }
+ constructor.body = context.createIrBuilder(constructor).irBlockBody {
if (capturedThisField != null) {
+irSetField(irGet(thisReceiver!!), capturedThisField, irGet(capturedThisParameter!!))
}
+irDelegatingConstructorCall(superClassConstructor).also {
- it.putValueArgument(0, irGet(completionParameterSymbol))
+ it.putValueArgument(0, irGet(completionParameter))
}
}
}
@@ -357,9 +355,9 @@
labelField: IrField,
capturedThisField: IrField?
) {
- val invokeSuspend = continuationImpl.owner.functions.single { it.name == Name.identifier(INVOKE_SUSPEND_METHOD_NAME) }
+ val invokeSuspend = continuationImpl.functions.single { it.name == Name.identifier(INVOKE_SUSPEND_METHOD_NAME) }
addFunctionOverride(invokeSuspend).also { function ->
- function.body = context.createIrBuilder(function.symbol).irBlockBody {
+ function.body = context.createIrBuilder(function).irBlockBody {
+irSetField(irGet(function.dispatchReceiverParameter!!), resultField, irGet(function.valueParameters[0]))
// There can be three kinds of suspend function call:
// 1) direct call from another suspend function/lambda
@@ -373,7 +371,7 @@
+irSetField(
irGet(function.dispatchReceiverParameter!!), labelField,
irCallOp(
- context.irBuiltIns.intClass.functions.single { it.owner.name == OperatorNameConventions.OR },
+ context.irBuiltIns.intClass.functions.single { it.name == OperatorNameConventions.OR },
context.irBuiltIns.intType,
irGetField(irGet(function.dispatchReceiverParameter!!), labelField),
irInt(signBit)
@@ -427,7 +425,7 @@
}
override fun visitCall(expression: IrCall) {
- val owner = expression.symbol.owner
+ val owner = expression.target
if (owner.isInline) {
for (i in 0 until expression.valueArgumentsCount) {
if (owner.valueParameters[i].isNoinline) continue
@@ -449,7 +447,7 @@
if (expression.isSuspend && expression !in inlineLambdas) {
suspendLambdas += SuspendLambdaInfo(
- expression.symbol.owner,
+ expression.target,
(expression.type as IrSimpleType).arguments.size - 1,
expression
)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt
index 88ceff8..ab0805e 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt
@@ -141,7 +141,7 @@
irClass.annotations.add(
IrConstructorCallImpl.fromSymbolOwner(
- UNDEFINED_OFFSET, UNDEFINED_OFFSET, documentedConstructor.returnType, documentedConstructor.symbol
+ UNDEFINED_OFFSET, UNDEFINED_OFFSET, documentedConstructor.returnType, documentedConstructor
)
)
}
@@ -156,18 +156,18 @@
if (irClass.hasAnnotation(FqName("java.lang.annotation.Retention"))) return
val kotlinRetentionPolicyCall = irClass.getAnnotation(FqName("kotlin.annotation.Retention"))
val kotlinRetentionPolicyName =
- kotlinRetentionPolicyCall?.getValueArgument(0)?.safeAs<IrGetEnumValue>()?.symbol?.owner?.name?.asString()
+ kotlinRetentionPolicyCall?.getValueArgument(0)?.safeAs<IrGetEnumValue>()?.target?.name?.asString()
val kotlinRetentionPolicy = kotlinRetentionPolicyName?.let { KotlinRetention.valueOf(it) }
val javaRetentionPolicy = kotlinRetentionPolicy?.let { annotationRetentionMap[it] } ?: rpRuntime
irClass.annotations.add(
IrConstructorCallImpl.fromSymbolOwner(
- UNDEFINED_OFFSET, UNDEFINED_OFFSET, retentionConstructor.returnType, retentionConstructor.symbol
+ UNDEFINED_OFFSET, UNDEFINED_OFFSET, retentionConstructor.returnType, retentionConstructor
).apply {
putValueArgument(
0,
IrGetEnumValueImpl(
- UNDEFINED_OFFSET, UNDEFINED_OFFSET, retentionPolicyEnum.defaultType, javaRetentionPolicy.symbol
+ UNDEFINED_OFFSET, UNDEFINED_OFFSET, retentionPolicyEnum.defaultType, javaRetentionPolicy
)
)
}
@@ -223,14 +223,14 @@
for (target in javaTargets) {
vararg.elements.add(
IrGetEnumValueImpl(
- UNDEFINED_OFFSET, UNDEFINED_OFFSET, elementTypeEnum.defaultType, target.symbol
+ UNDEFINED_OFFSET, UNDEFINED_OFFSET, elementTypeEnum.defaultType, target
)
)
}
irClass.annotations.add(
IrConstructorCallImpl.fromSymbolOwner(
- UNDEFINED_OFFSET, UNDEFINED_OFFSET, targetConstructor.returnType, targetConstructor.symbol
+ UNDEFINED_OFFSET, UNDEFINED_OFFSET, targetConstructor.returnType, targetConstructor
).apply {
putValueArgument(0, vararg)
}
@@ -241,7 +241,7 @@
// To be generalized to IrMemberAccessExpression as soon as properties get symbols.
private fun IrConstructorCall.getValueArgument(name: Name): IrExpression? {
- val index = symbol.owner.valueParameters.find { it.name == name }?.index ?: return null
+ val index = target.valueParameters.find { it.name == name }?.index ?: return null
return getValueArgument(index)
}
@@ -258,6 +258,6 @@
val valueArgument = targetEntry.getValueArgument(TARGET_ALLOWED_TARGETS)
as? IrVararg ?: return null
return valueArgument.elements.filterIsInstance<IrGetEnumValue>().mapNotNull {
- KotlinTarget.valueOrNull(it.symbol.owner.name.asString())
+ KotlinTarget.valueOrNull(it.target.name.asString())
}.toSet()
}
\ No newline at end of file
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt
index f609cea..fc3a0e3 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AssertionLowering.kt
@@ -77,7 +77,7 @@
}
override fun visitCall(expression: IrCall, data: ClassInfo?): IrElement {
- val function = expression.symbol.owner
+ val function = expression.target
if (!function.isAssert)
return super.visitCall(expression, data)
@@ -85,7 +85,7 @@
if (mode == JVMAssertionsMode.ALWAYS_DISABLE)
return IrCompositeImpl(expression.startOffset, expression.endOffset, context.irBuiltIns.unitType)
- context.createIrBuilder(expression.symbol).run {
+ context.createIrBuilder(expression.target).run {
at(expression)
val assertCondition = expression.getValueArgument(0)!!
val lambdaArgument = if (function.valueParameters.size == 2) expression.getValueArgument(1) else null
@@ -116,7 +116,7 @@
lambdaArgument != null -> {
val invoke =
lambdaArgument.type.getClass()!!.functions.single { it.name == OperatorNameConventions.INVOKE }
- irCallOp(invoke.symbol, invoke.returnType, irGet(invokeVar!!))
+ irCallOp(invoke, invoke.returnType, irGet(invokeVar!!))
}
else -> irString("Assertion failed")
}
@@ -140,7 +140,7 @@
isStatic = true
}.apply {
parent = irClass
- initializer = context.createIrBuilder(irClass.symbol).run {
+ initializer = context.createIrBuilder(irClass).run {
at(this@apply)
irExprBody(irNot(irCall(this@AssertionLowering.context.ir.symbols.desiredAssertionStatus).apply {
dispatchReceiver = getJavaClass(topLevelClass)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt
index 12d35af..523d128 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt
@@ -73,12 +73,12 @@
if (irFunction.isMethodOfAny()) return
if (irFunction.origin === IrDeclarationOrigin.FAKE_OVERRIDE &&
- irFunction.overriddenSymbols.all {
- !it.owner.comesFromJava() &&
- if ((it.owner.parent as? IrClass)?.isInterface == true)
- it.owner.hasJvmDefault() // TODO: Remove this after modality is corrected in InterfaceLowering.
+ irFunction.overridden.all {
+ !it.comesFromJava() &&
+ if ((it.parent as? IrClass)?.isInterface == true)
+ it.hasJvmDefault() // TODO: Remove this after modality is corrected in InterfaceLowering.
else
- it.owner.modality !== Modality.ABSTRACT
+ it.modality !== Modality.ABSTRACT
}
) {
// All needed bridges will be generated where functions are implemented.
@@ -118,7 +118,7 @@
}
} else if (irFunction.origin == IrDeclarationOrigin.FAKE_OVERRIDE &&
irFunction.modality == Modality.ABSTRACT &&
- irFunction.overriddenSymbols.all { it.owner.getJvmName() != ourMethodName }
+ irFunction.overridden.all { it.getJvmName() != ourMethodName }
) {
// Bridges for abstract fake overrides whose JVM names differ from overridden functions.
val bridge = irFunction.orphanedCopy()
@@ -191,8 +191,8 @@
// For lambda classes, we move override from the `invoke` function to its bridge. This will allow us to avoid boxing
// the return type of `invoke` in codegen, in case lambda's return type is primitive.
if (method.name == OperatorNameConventions.INVOKE && irClass.origin == JvmLoweredDeclarationOrigin.LAMBDA_IMPL) {
- target.overriddenSymbols.remove(method.symbol)
- bridge.overriddenSymbols.add(method.symbol)
+ target.overridden.remove(method)
+ bridge.overridden.add(method)
}
signaturesToSkip.add(signature)
@@ -281,9 +281,9 @@
IrCallImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
maybeOrphanedTarget.returnType,
- maybeOrphanedTarget.symbol, maybeOrphanedTarget.descriptor,
+ maybeOrphanedTarget, maybeOrphanedTarget.descriptor,
origin = IrStatementOrigin.BRIDGE_DELEGATION,
- superQualifierSymbol = if (invokeStatically) maybeOrphanedTarget.parentAsClass.symbol else null
+ irSuperQualifier = if (invokeStatically) maybeOrphanedTarget.parentAsClass else null
).apply {
passTypeArgumentsFrom(this@createBridgeBody)
dispatchReceiver = irGet(dispatchReceiverParameter!!)
@@ -303,7 +303,7 @@
/* A hacky way to make sure the code generator calls the right function, and not some standard interface it implements. */
private fun IrSimpleFunction.orphanedCopy() =
- if (overriddenSymbols.size == 0)
+ if (overridden.size == 0)
this
else
WrappedSimpleFunctionDescriptor(descriptor.annotations).let { wrappedDescriptor ->
@@ -373,7 +373,7 @@
override val isAbstract get() = irFunction.modality == Modality.ABSTRACT
override val mayBeUsedAsSuperImplementation get() = !irFunction.parentAsClass.isInterface || irFunction.hasJvmDefault()
- override fun getOverridden() = irFunction.overriddenSymbols.map { FunctionHandleForIrFunction(it.owner) }
+ override fun getOverridden() = irFunction.overridden.map { FunctionHandleForIrFunction(it) }
override fun hashCode(): Int =
irFunction.parent.safeAs<IrClass>()?.fqNameWhenAvailable.hashCode() + 31 * irFunction.getJvmSignature().hashCode()
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt
index 93528b0..2daecd8 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CallableReferenceLowering.kt
@@ -56,7 +56,7 @@
// Mark function references appearing as inlined arguments to inline functions.
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
- val function = expression.symbol.owner
+ val function = expression.target
if (function.isInlineFunctionCall(context)) {
for (parameter in function.valueParameters) {
if (!parameter.isInlineParameter())
@@ -120,7 +120,7 @@
private inner class FunctionReferenceBuilder(val irFunctionReference: IrFunctionReference, val samSuperType: IrType? = null) {
private val isLambda = irFunctionReference.origin.isLambda
- private val callee = irFunctionReference.symbol.owner
+ private val callee = irFunctionReference.target
// Only function references can bind a receiver and even then we can only bind either an extension or a dispatch receiver.
// However, when we bind a value of an inline class type as a receiver, the receiver will turn into an argument of
@@ -137,9 +137,9 @@
private val functionSuperClass =
samSuperType?.classOrNull ?: context.ir.symbols.getJvmFunctionClass(argumentTypes.size)
private val superMethod =
- functionSuperClass.functions.single { it.owner.modality == Modality.ABSTRACT }
+ functionSuperClass.functions.single { it.modality == Modality.ABSTRACT }
private val superType =
- samSuperType ?: (if (isLambda) context.ir.symbols.lambdaClass else context.ir.symbols.functionReference).owner.typeWith()
+ samSuperType ?: (if (isLambda) context.ir.symbols.lambdaClass else context.ir.symbols.functionReference).typeWith()
private val functionReferenceClass = buildClass {
setSourceRange(irFunctionReference)
@@ -157,7 +157,7 @@
copyAttributes(irFunctionReference)
}
- fun build(): IrExpression = context.createJvmIrBuilder(currentScope!!.scope.scopeOwnerSymbol).run {
+ fun build(): IrExpression = context.createJvmIrBuilder(currentScope!!.scope.irScopeOwner).run {
irBlock {
val constructor = createConstructor()
createInvokeMethod(
@@ -167,13 +167,13 @@
)
if (!isLambda && samSuperType == null) {
- createGetSignatureMethod(this@run.irSymbols.functionReferenceGetSignature.owner)
- createGetNameMethod(this@run.irSymbols.functionReferenceGetName.owner)
- createGetOwnerMethod(this@run.irSymbols.functionReferenceGetOwner.owner)
+ createGetSignatureMethod(this@run.irSymbols.functionReferenceGetSignature)
+ createGetNameMethod(this@run.irSymbols.functionReferenceGetName)
+ createGetOwnerMethod(this@run.irSymbols.functionReferenceGetOwner)
}
+functionReferenceClass
- +irCall(constructor.symbol).apply {
+ +irCall(constructor).apply {
if (valueArgumentsCount > 0) putValueArgument(0, boundReceiver!!.second)
}
}
@@ -217,17 +217,17 @@
putValueArgument(1, irGet(valueParameters.first()))
}
}
- +IrInstanceInitializerCallImpl(startOffset, endOffset, functionReferenceClass.symbol, context.irBuiltIns.unitType)
+ +IrInstanceInitializerCallImpl(startOffset, endOffset, functionReferenceClass, context.irBuiltIns.unitType)
}
}
private fun createInvokeMethod(receiverVar: IrValueDeclaration?): IrSimpleFunction =
functionReferenceClass.addFunction {
- name = superMethod.owner.name
+ name = superMethod.name
returnType = callee.returnType
isSuspend = callee.isSuspend
}.apply {
- overriddenSymbols += superMethod
+ overridden += superMethod
dispatchReceiverParameter = parentAsClass.thisReceiver!!.copyTo(this)
if (isLambda) createLambdaInvokeMethod() else createFunctionReferenceInvokeMethod(receiverVar)
}
@@ -244,7 +244,7 @@
callee.body?.statements?.forEach { statement ->
+statement.transform(object : IrElementTransformerVoid() {
override fun visitGetValue(expression: IrGetValue): IrExpression {
- val replacement = valueParameterMap[expression.symbol.owner]
+ val replacement = valueParameterMap[expression.target]
?: return super.visitGetValue(expression)
at(expression.startOffset, expression.endOffset)
@@ -252,7 +252,7 @@
}
override fun visitReturn(expression: IrReturn): IrExpression =
- if (expression.returnTargetSymbol != callee.symbol) {
+ if (expression.irReturnTarget != callee) {
super.visitReturn(expression)
} else {
at(expression.startOffset, expression.endOffset)
@@ -281,7 +281,7 @@
var unboundIndex = 0
irExprBody(irCall(callee).apply {
for ((typeParameter, typeArgument) in typeArgumentsMap) {
- putTypeArgument(typeParameter.owner.index, typeArgument)
+ putTypeArgument(typeParameter.index, typeArgument)
}
for (parameter in callee.explicitParameters) {
@@ -292,7 +292,7 @@
// will put it into a field.
if (samSuperType == null)
irImplicitCast(
- irGetField(irGet(dispatchReceiverParameter!!), irSymbols.functionReferenceReceiverField.owner),
+ irGetField(irGet(dispatchReceiverParameter!!), irSymbols.functionReferenceReceiverField),
boundReceiver.second.type
)
else
@@ -339,7 +339,7 @@
visibility = superFunction.visibility
isSuspend = superFunction.isSuspend
}.apply {
- overriddenSymbols += superFunction.symbol
+ overridden += superFunction
dispatchReceiverParameter = functionReferenceClass.thisReceiver?.copyTo(this)
}
@@ -351,8 +351,8 @@
body = context.createIrBuilder(symbol, startOffset, endOffset).run {
// TODO do not use descriptors
val declaration = codegenContext.referenceFunction(
- DescriptorUtils.unwrapFakeOverride(irFunctionReference.symbol.descriptor).original
- ).owner
+ DescriptorUtils.unwrapFakeOverride(irFunctionReference.target.descriptor).original
+ )
val method = codegenContext.methodSignatureMapper.mapAsmMethod(declaration)
irExprBody(irString(method.name + method.descriptor))
}
@@ -378,7 +378,7 @@
)
private fun IrBuilderWithScope.kClassToJavaClass(kClassReference: IrExpression, context: JvmBackendContext) =
- irGet(context.ir.symbols.javaLangClass.typeWith(), null, context.ir.symbols.kClassJava.owner.getter!!.symbol).apply {
+ irGet(context.ir.symbols.javaLangClass.typeWith(), null, context.ir.symbols.kClassJava.getter!!).apply {
extensionReceiver = kClassReference
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CheckLocalNamesWithOldBackend.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CheckLocalNamesWithOldBackend.kt
index a28d1d1..1684b699 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CheckLocalNamesWithOldBackend.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CheckLocalNamesWithOldBackend.kt
@@ -37,7 +37,7 @@
override fun visitClass(declaration: IrClass) {
val actualName = context.getLocalClassInfo(declaration)?.internalName
if (actualName != null) {
- val expectedName = context.state.bindingTrace.get(CodegenBinding.ASM_TYPE, declaration.symbol.descriptor)?.internalName
+ val expectedName = context.state.bindingTrace.get(CodegenBinding.ASM_TYPE, declaration.descriptor)?.internalName
if (expectedName != null && expectedName != actualName) {
throw AssertionError(
"Incorrect name for the class.\n" +
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt
index 30757c4..068022d 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt
@@ -17,13 +17,8 @@
import org.jetbrains.kotlin.ir.builders.irBlockBody
import org.jetbrains.kotlin.ir.builders.irCall
import org.jetbrains.kotlin.ir.builders.irString
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.*
@@ -58,7 +53,7 @@
if (existingMethod != null) {
// In the case that we find a defined method that matches the stub signature, we add the overridden symbols to that
// defined method, so that bridge lowering can still generate correct bridge for that method
- existingMethod.overriddenSymbols.addAll(member.overriddenSymbols)
+ existingMethod.overridden.addAll(member.overridden)
} else {
irClass.declarations.add(member)
}
@@ -68,7 +63,7 @@
private fun IrSimpleFunction.toSignature(): String = methodSignatureMapper.mapAsmMethod(this).toString()
private fun createStubMethod(
- function: IrSimpleFunction, irClass: IrClass, substitutionMap: Map<IrTypeParameterSymbol, IrType>
+ function: IrSimpleFunction, irClass: IrClass, substitutionMap: Map<IrTypeParameter, IrType>
): IrSimpleFunction {
return buildFun {
name = function.name
@@ -79,7 +74,7 @@
}.apply {
// Replace Function metadata with the data from class
// Add the abstract function symbol to stub function for bridge lowering
- overriddenSymbols.add(function.symbol)
+ overridden.add(function)
parent = irClass
dispatchReceiverParameter = function.dispatchReceiverParameter?.copyWithSubstitution(this, substitutionMap)
extensionReceiverParameter = function.extensionReceiverParameter?.copyWithSubstitution(this, substitutionMap)
@@ -88,10 +83,10 @@
}
val exception = context.getTopLevelClass(FqName("java.lang.UnsupportedOperationException"))
// Function body consist only of throwing UnsupportedOperationException statement
- body = context.createIrBuilder(function.symbol).irBlockBody {
+ body = context.createIrBuilder(function).irBlockBody {
+irThrow(
irCall(
- exception.owner.constructors.single {
+ exception.constructors.single {
it.valueParameters.size == 1 && it.valueParameters.single().type.isNullableString()
}
).apply {
@@ -103,7 +98,7 @@
}
// Copy value parameter with type substitution
- private fun IrValueParameter.copyWithSubstitution(target: IrSimpleFunction, substitutionMap: Map<IrTypeParameterSymbol, IrType>)
+ private fun IrValueParameter.copyWithSubstitution(target: IrSimpleFunction, substitutionMap: Map<IrTypeParameter, IrType>)
: IrValueParameter {
val descriptor = WrappedValueParameterDescriptor(this.descriptor.annotations)
return IrValueParameterImpl(
@@ -125,11 +120,11 @@
// Compute a substitution map for type parameters between source class (Mutable Collection classes) to
// target class (class currently in lowering phase), this map is later used for substituting type parameters in generated functions
private fun computeSubstitutionMap(readOnlyClass: IrClass, mutableClass: IrClass, targetClass: IrClass)
- : Map<IrTypeParameterSymbol, IrType> {
+ : Map<IrTypeParameter, IrType> {
// We find the most specific type for the immutable collection class from the inheritance chain of target class
// Perform type substitution along searching, then use the type arguments obtained from the most specific type
// for type substitution.
- val readOnlyClassType = getAllSupertypes(targetClass).findMostSpecificTypeForClass(readOnlyClass.symbol)
+ val readOnlyClassType = getAllSupertypes(targetClass).findMostSpecificTypeForClass(readOnlyClass)
val readOnlyClassTypeArguments = (readOnlyClassType as IrSimpleType).arguments.mapNotNull { (it as? IrTypeProjection)?.type }
if (readOnlyClassTypeArguments.isEmpty() || readOnlyClassTypeArguments.size != mutableClass.typeParameters.size) {
@@ -139,17 +134,16 @@
"class ${targetClass.fqNameWhenAvailable}"
)
}
- return mutableClass.typeParameters.map { it.symbol }.zip(readOnlyClassTypeArguments).toMap()
+ return mutableClass.typeParameters.zip(readOnlyClassTypeArguments).toMap()
}
private inner class StubsForCollectionClass(
- val readOnlyClass: IrClassSymbol,
- val mutableClass: IrClassSymbol
+ val readOnlyClass: IrClass,
+ val mutableClass: IrClass
) {
val mutableOnlyMethods: Collection<IrSimpleFunction> by lazy {
- val readOnlyMethodSignatures = readOnlyClass.functions.map { it.owner.toSignature() }.toHashSet()
+ val readOnlyMethodSignatures = readOnlyClass.functions.map { it.toSignature() }.toHashSet()
mutableClass.functions
- .map { it.owner }
.filter { it.toSignature() !in readOnlyMethodSignatures }
.toHashSet()
}
@@ -179,14 +173,14 @@
// Compute stubs that should be generated, compare based on signature
private fun generateRelevantStubMethods(irClass: IrClass): Set<IrSimpleFunction> {
val ourStubsForCollectionClasses = preComputedStubs.filter { (readOnlyClass, mutableClass) ->
- irClass.superTypes.any { supertypeSymbol ->
- val supertype = supertypeSymbol.classOrNull?.owner
+ irClass.superTypes.any { supertype ->
+ val supertypeCLass = supertype.classOrNull?.owner
// We need to generate stub methods for following 2 cases:
// current class's direct super type is a java class or kotlin interface, and is an subtype of an immutable collection
- supertype != null
- && (supertype.comesFromJava() || supertype.isInterface)
- && supertypeSymbol.isSubtypeOfClass(readOnlyClass)
- && !irClass.symbol.isSubtypeOfClass(mutableClass)
+ supertypeCLass != null
+ && (supertypeCLass.comesFromJava() || supertypeCLass.isInterface)
+ && supertype.isSubtypeOfClass(readOnlyClass)
+ && !irClass.isSubtypeOfClass(mutableClass)
}
}
@@ -199,7 +193,7 @@
return ourStubsForCollectionClasses.filter { (readOnlyClass) ->
readOnlyClass !in redundantClasses
}.flatMap { (readOnlyClass, mutableClass, mutableOnlyMethods) ->
- val substitutionMap = computeSubstitutionMap(readOnlyClass.owner, mutableClass.owner, irClass)
+ val substitutionMap = computeSubstitutionMap(readOnlyClass, mutableClass, irClass)
mutableOnlyMethods.map { function ->
createStubMethod(function, irClass, substitutionMap)
}
@@ -208,9 +202,9 @@
fun IrClass.comesFromJava() = origin in ORIGINS_FROM_JAVA
- private fun Collection<IrType>.findMostSpecificTypeForClass(classifier: IrClassSymbol): IrType {
- val types = this.filter { it.classifierOrNull == classifier }
- if (types.isEmpty()) error("No supertype of $classifier in $this")
+ private fun Collection<IrType>.findMostSpecificTypeForClass(clazz: IrClass): IrType {
+ val types = this.filter { it.classifierOrNull == clazz.symbol }
+ if (types.isEmpty()) error("No supertype of $clazz in $this")
if (types.size == 1) return types.first()
// Find the first type in the list such that it's a subtype of every other type in that list
return types.first { type ->
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstLowering.kt
index 926af82..6451b54 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ConstLowering.kt
@@ -39,7 +39,7 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- val function = (expression.symbol.owner as? IrSimpleFunction) ?: return super.visitCall(expression)
+ val function = (expression.target as? IrSimpleFunction) ?: return super.visitCall(expression)
val property = function.correspondingPropertySymbol?.owner ?: return super.visitCall(expression)
if (function != property.getter)
return super.visitCall(expression)
@@ -47,5 +47,5 @@
}
override fun visitGetField(expression: IrGetField): IrExpression =
- expression.symbol.owner.constantValue() ?: super.visitGetField(expression)
+ expression.target.constantValue() ?: super.visitGetField(expression)
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt
index ec21a6e..e5ba7de 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt
@@ -25,8 +25,6 @@
import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
@@ -60,8 +58,8 @@
private inner class EnumClassTransformer(val irClass: IrClass) {
private val enumEntryOrdinals = TObjectIntHashMap<IrEnumEntry>()
private val enumEntryClassToEntry = HashMap<IrClass, IrEnumEntry>()
- private val loweredEnumConstructors = HashMap<IrConstructorSymbol, IrConstructorImpl>()
- private val loweredEnumConstructorParameters = HashMap<IrValueParameterSymbol, IrValueParameter>()
+ private val loweredEnumConstructors = HashMap<IrConstructor, IrConstructorImpl>()
+ private val loweredEnumConstructorParameters = HashMap<IrValueParameter, IrValueParameter>()
private val enumEntriesByField = HashMap<IrField, IrEnumEntry>()
private val enumEntryFields = ArrayList<IrField>()
@@ -125,13 +123,13 @@
valueParameters.add(1, ordinalParameter)
valueParameters.addAll(enumConstructor.valueParameters.map { param ->
param.copyTo(newConstructor, index = param.index + 2).also { newParam ->
- loweredEnumConstructorParameters[param.symbol] = newParam
+ loweredEnumConstructorParameters[param] = newParam
}
})
body = enumConstructor.body?.patchDeclarationParents(this)
- loweredEnumConstructors[enumConstructor.symbol] = this
+ loweredEnumConstructors[enumConstructor] = this
metadata = enumConstructor.metadata
}
}
@@ -247,9 +245,9 @@
}
private fun createSyntheticValuesFieldInitializerExpression(): IrExpression =
- context.createJvmIrBuilder(irClass.symbol).irArray(context.irBuiltIns.arrayClass.typeWith(irClass.defaultType)) {
+ context.createJvmIrBuilder(irClass).irArray(context.irBuiltIns.arrayClass.typeWith(irClass.defaultType)) {
enumEntryFields.forEach { irField ->
- +IrGetFieldImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irField.symbol, irField.type)
+ +IrGetFieldImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irField, irField.type)
}
}
@@ -268,7 +266,7 @@
startOffset,
endOffset,
context.irBuiltIns.unitType,
- enumConstructorCall.symbol,
+ enumConstructorCall.target,
enumConstructorCall.descriptor,
enumConstructorCall.typeArgumentsCount
)
@@ -276,7 +274,7 @@
assert(enumConstructorCall.typeArgumentsCount == 1) { "Enum<T> call expected:\n${result.dump()}" }
result.putTypeArgument(0, enumConstructorCall.getTypeArgument(0))
- assert(result.symbol.owner.valueParameters.size == 2) {
+ assert(result.target.valueParameters.size == 2) {
"Enum(String, Int) constructor call expected:\n${result.dump()}"
}
@@ -288,8 +286,8 @@
throw AssertionError("No 'ordinal' parameter in enum constructor: ${irEnumConstructor.dump()}")
}
- result.putValueArgument(0, IrGetValueImpl(startOffset, endOffset, nameParameter.symbol, origin))
- result.putValueArgument(1, IrGetValueImpl(startOffset, endOffset, ordinalParameter.symbol, origin))
+ result.putValueArgument(0, IrGetValueImpl(startOffset, endOffset, nameParameter, origin))
+ result.putValueArgument(1, IrGetValueImpl(startOffset, endOffset, ordinalParameter, origin))
return result
}
@@ -298,25 +296,25 @@
val startOffset = delegatingConstructorCall.startOffset
val endOffset = delegatingConstructorCall.endOffset
- val loweredDelegatedConstructor = loweredEnumConstructors.getOrElse(delegatingConstructorCall.symbol) {
- throw AssertionError("Constructor called in enum entry initializer should've been lowered: ${delegatingConstructorCall.symbol}")
+ val loweredDelegatedConstructor = loweredEnumConstructors.getOrElse(delegatingConstructorCall.target) {
+ throw AssertionError("Constructor called in enum entry initializer should've been lowered: ${delegatingConstructorCall.target}")
}
val result = IrDelegatingConstructorCallImpl(
startOffset,
endOffset,
context.irBuiltIns.unitType,
- loweredDelegatedConstructor.symbol,
+ loweredDelegatedConstructor,
loweredDelegatedConstructor.descriptor,
loweredDelegatedConstructor.typeParameters.size
)
assert(loweredDelegatedConstructor.typeParameters.size == 0) { "Enum delegating call expected:\n${result.dump()}" }
- result.putValueArgument(0, IrGetValueImpl(startOffset, endOffset, irEnumConstructor.valueParameters[0].symbol))
- result.putValueArgument(1, IrGetValueImpl(startOffset, endOffset, irEnumConstructor.valueParameters[1].symbol))
+ result.putValueArgument(0, IrGetValueImpl(startOffset, endOffset, irEnumConstructor.valueParameters[0]))
+ result.putValueArgument(1, IrGetValueImpl(startOffset, endOffset, irEnumConstructor.valueParameters[1]))
- delegatingConstructorCall.symbol.owner.valueParameters.forEach { valueParameter ->
+ delegatingConstructorCall.target.valueParameters.forEach { valueParameter ->
val i = valueParameter.index
result.putValueArgument(i + 2, delegatingConstructorCall.getValueArgument(i))
}
@@ -333,7 +331,7 @@
val startOffset = enumConstructorCall.startOffset
val endOffset = enumConstructorCall.endOffset
- val loweredConstructor = loweredEnumConstructors.getOrElse(enumConstructorCall.symbol) {
+ val loweredConstructor = loweredEnumConstructors.getOrElse(enumConstructorCall.target) {
throw AssertionError("Constructor called in enum entry initializer should've been lowered:\n${enumConstructorCall.dump()}")
}
@@ -342,7 +340,7 @@
result.putValueArgument(0, IrConstImpl.string(startOffset, endOffset, context.irBuiltIns.stringType, name))
result.putValueArgument(1, IrConstImpl.int(startOffset, endOffset, context.irBuiltIns.intType, ordinal))
- enumConstructorCall.symbol.owner.valueParameters.forEach { valueParameter ->
+ enumConstructorCall.target.valueParameters.forEach { valueParameter ->
val i = valueParameter.index
result.putValueArgument(i + 2, enumConstructorCall.getValueArgument(i))
}
@@ -367,7 +365,7 @@
startOffset,
endOffset,
context.irBuiltIns.unitType,
- loweredConstructor.symbol,
+ loweredConstructor,
loweredConstructor.descriptor,
loweredConstructor.typeParameters.size
)
@@ -378,8 +376,8 @@
IrConstructorCallImpl.fromSymbolDescriptor(
startOffset,
endOffset,
- loweredConstructor.symbol.owner.parentAsClass.defaultType,
- loweredConstructor.symbol
+ loweredConstructor.parentAsClass.defaultType,
+ loweredConstructor
)
}
@@ -439,7 +437,7 @@
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
expression.transformChildrenVoid(this)
- if (expression.symbol.owner.parentAsClass.kind == ClassKind.ENUM_CLASS) {
+ if (expression.target.parentAsClass.kind == ClassKind.ENUM_CLASS) {
val callTransformer = enumConstructorCallTransformer ?: throw AssertionError(
"Enum constructor call outside of enum entry initialization or enum class constructor:\n" +
irClass.dump()
@@ -452,9 +450,9 @@
}
override fun visitGetValue(expression: IrGetValue): IrExpression {
- val loweredParameter = loweredEnumConstructorParameters[expression.symbol]
+ val loweredParameter = loweredEnumConstructorParameters[expression.target]
return if (loweredParameter != null) {
- IrGetValueImpl(expression.startOffset, expression.endOffset, loweredParameter.symbol, expression.origin)
+ IrGetValueImpl(expression.startOffset, expression.endOffset, loweredParameter, expression.origin)
} else {
expression
}
@@ -492,7 +490,7 @@
)
irValueOfCall.putTypeArgument(0, irClass.defaultType)
irValueOfCall.putValueArgument(
- 0, IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, valueOfFunction.valueParameters[0].symbol)
+ 0, IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, valueOfFunction.valueParameters[0])
)
return IrBlockBodyImpl(
@@ -502,7 +500,7 @@
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
returnType,
- valueOfFunction.symbol,
+ valueOfFunction,
irValueOfCall
)
)
@@ -511,11 +509,11 @@
private fun createEnumValuesBody(valuesField: IrField): IrBody {
val cloneFun = context.irBuiltIns.arrayClass.owner.functions.find { it.name.asString() == "clone" }!!
- val returnType = valuesFunction.symbol.owner.returnType
+ val returnType = valuesFunction.returnType
val irCloneValues =
- IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, returnType, cloneFun.symbol, cloneFun.descriptor, 0).apply {
+ IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, returnType, cloneFun, cloneFun.descriptor, 0).apply {
dispatchReceiver =
- IrGetFieldImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, valuesField.symbol, valuesField.symbol.owner.type)
+ IrGetFieldImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, valuesField, valuesField.type)
}
return IrBlockBodyImpl(
@@ -525,7 +523,7 @@
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
returnType,
- valuesFunction.symbol,
+ valuesFunction,
irCloneValues
)
)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FoldConstantLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FoldConstantLowering.kt
index cdc6ac2..6d61dfb 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FoldConstantLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FoldConstantLowering.kt
@@ -110,7 +110,7 @@
private fun tryFoldingUnaryOps(call: IrCall): IrExpression {
val operand = call.dispatchReceiver as? IrConst<*> ?: return call
val evaluated = evaluateUnary(
- call.symbol.owner.name.toString(),
+ call.target.name.toString(),
operand.kind.toString(),
operand.value!!
) ?: return call
@@ -124,14 +124,14 @@
val evaluated = try {
fun String.toNonNullable() = if (this.endsWith('?')) this.dropLast(1) else this
evaluateBinary(
- call.symbol.owner.name.toString(),
+ call.target.name.toString(),
lhs.kind.toString(),
lhs.value!!,
// 1. Although some operators have nullable parameters, evaluators deals with non-nullable types only.
// The passed parameters are guaranteed to be non-null, since they are from IrConst.
// 2. The operators are registered with prototype as if virtual member functions. They are identified by
// actual_receiver_type.operator_name(parameter_type_in_prototype).
- call.symbol.owner.valueParameters[0].type.toKotlinType().toString().toNonNullable(),
+ call.target.valueParameters[0].type.toKotlinType().toString().toNonNullable(),
rhs.value!!
) ?: return call
} catch (e: Exception) {
@@ -144,7 +144,7 @@
private fun tryFoldingBuiltinBinaryOps(call: IrCall): IrExpression {
// Make sure that this is a IrBuiltIn
- if (call.symbol.owner.fqNameWhenAvailable?.parent() != IrBuiltIns.KOTLIN_INTERNAL_IR_FQN)
+ if (call.target.fqNameWhenAvailable?.parent() != IrBuiltIns.KOTLIN_INTERNAL_IR_FQN)
return call
val lhs = call.getValueArgument(0) as? IrConst<*> ?: return call
@@ -152,7 +152,7 @@
val evaluated = try {
val evaluator =
- BINARY_OP_TO_EVALUATOR[BinaryOp(lhs.kind.toString(), rhs.kind.toString(), call.symbol.owner.name.toString())] ?: return call
+ BINARY_OP_TO_EVALUATOR[BinaryOp(lhs.kind.toString(), rhs.kind.toString(), call.target.name.toString())] ?: return call
evaluator(lhs.value!!, rhs.value!!)
} catch (e: Exception) {
return call
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt
index 41d07c4..4bfcbc8 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt
@@ -48,11 +48,11 @@
// Change calls to big arity invoke functions to vararg calls.
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
if (expression.valueArgumentsCount < FunctionInvokeDescriptor.BIG_ARITY ||
- !expression.symbol.owner.parentAsClass.defaultType.isFunctionOrKFunction() ||
- expression.symbol.owner.name.asString() != "invoke")
+ !expression.target.parentAsClass.defaultType.isFunctionOrKFunction() ||
+ expression.target.name.asString() != "invoke")
return super.visitFunctionAccess(expression)
- return context.createJvmIrBuilder(currentScope!!.scope.scopeOwnerSymbol).run {
+ return context.createJvmIrBuilder(currentScope!!.scope.irScopeOwner).run {
at(expression)
irCall(functionNInvokeFun).apply {
dispatchReceiver = expression.dispatchReceiver
@@ -90,8 +90,8 @@
val invokeFunction = declaration.functions.single {
it.name.asString() == "invoke" && it.valueParameters.size == superType.arguments.size - 1
}
- invokeFunction.overriddenSymbols.clear()
- declaration.addBridge(invokeFunction, functionNInvokeFun.owner)
+ invokeFunction.overridden.clear()
+ declaration.addBridge(invokeFunction, functionNInvokeFun)
return declaration
}
@@ -104,7 +104,7 @@
visibility = Visibilities.PUBLIC
origin = IrDeclarationOrigin.BRIDGE
}.apply {
- overriddenSymbols += superFunction.symbol
+ overridden += superFunction
dispatchReceiverParameter = thisReceiver!!.copyTo(this)
valueParameters += superFunction.valueParameters.single().copyTo(this)
@@ -154,14 +154,14 @@
}
private val functionNInvokeFun =
- context.ir.symbols.functionN.functions.single { it.owner.name.toString() == "invoke" }
+ context.ir.symbols.functionN.functions.single { it.name.toString() == "invoke" }
private val arraySizePropertyGetter by lazy {
context.irBuiltIns.arrayClass.owner.properties.single { it.name.toString() == "size" }.getter!!
}
private val arrayGetFun by lazy {
- context.irBuiltIns.arrayClass.functions.single { it.owner.name.toString() == "get" }
+ context.irBuiltIns.arrayClass.functions.single { it.name.toString() == "get" }
}
private val FUNCTIONS_PACKAGE_FQ_NAME =
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt
index d9324d1..cf23c99 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt
@@ -39,8 +39,6 @@
import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
import org.jetbrains.kotlin.ir.util.dump
import org.jetbrains.kotlin.ir.util.transformFlat
@@ -59,8 +57,8 @@
context: JvmBackendContext,
input: IrModuleFragment
): IrModuleFragment {
- val movedFields = mutableMapOf<IrFieldSymbol, IrFieldSymbol>()
- val functionDelegates = mutableMapOf<IrFunctionSymbol, IrFunctionSymbol>()
+ val movedFields = mutableMapOf<IrField, IrField>()
+ val functionDelegates = mutableMapOf<IrFunction, IrFunction>()
input.files.addAll(generateMultifileFacades(input.descriptor, context, movedFields, functionDelegates))
@@ -99,8 +97,8 @@
private fun generateMultifileFacades(
module: ModuleDescriptor,
context: JvmBackendContext,
- movedFields: MutableMap<IrFieldSymbol, IrFieldSymbol>,
- functionDelegates: MutableMap<IrFunctionSymbol, IrFunctionSymbol>
+ movedFields: MutableMap<IrField, IrField>,
+ functionDelegates: MutableMap<IrFunction, IrFunction>
): List<IrFile> =
context.multifileFacadesToAdd.map { (jvmClassName, partClasses) ->
val fileEntry = MultifileFacadeFileEntry(jvmClassName, partClasses.map(IrClass::fileParent))
@@ -123,7 +121,7 @@
if (member is IrFunction) {
val newMember = member.createMultifileDelegateIfNeeded(context, facadeClass)
if (newMember != null) {
- functionDelegates[member.symbol] = newMember.symbol
+ functionDelegates[member] = newMember
}
}
}
@@ -135,7 +133,7 @@
private fun moveFieldsOfConstProperties(
partClass: IrClass,
facadeClass: IrClass,
- movedFields: MutableMap<IrFieldSymbol, IrFieldSymbol>
+ movedFields: MutableMap<IrField, IrField>
) {
partClass.declarations.transformFlat { member ->
if (member is IrField && member.shouldMoveToFacade()) {
@@ -143,7 +141,7 @@
(it as IrFieldImpl).metadata = member.metadata
}
facadeClass.declarations.add(field)
- movedFields[member.symbol] = field.symbol
+ movedFields[member] = field
emptyList()
} else null
}
@@ -198,29 +196,29 @@
}
private class UpdateFieldCallSites(
- private val movedFields: Map<IrFieldSymbol, IrFieldSymbol>
+ private val movedFields: Map<IrField, IrField>
) : FileLoweringPass, IrElementTransformerVoid() {
override fun lower(irFile: IrFile) {
irFile.transformChildrenVoid(this)
}
override fun visitGetField(expression: IrGetField): IrExpression {
- val newField = movedFields[expression.symbol] ?: return super.visitGetField(expression)
+ val newField = movedFields[expression.target] ?: return super.visitGetField(expression)
return expression.run {
- IrGetFieldImpl(startOffset, endOffset, newField, type, receiver, origin, superQualifierSymbol)
+ IrGetFieldImpl(startOffset, endOffset, newField, type, receiver, origin, irSuperQualifier)
}
}
}
private class UpdateFunctionCallSites(
- private val functionDelegates: MutableMap<IrFunctionSymbol, IrFunctionSymbol>
+ private val functionDelegates: MutableMap<IrFunction, IrFunction>
) : FileLoweringPass, IrElementTransformerVoid() {
override fun lower(irFile: IrFile) {
irFile.transformChildrenVoid(this)
}
override fun visitCall(expression: IrCall): IrExpression {
- val newFunction = functionDelegates[expression.symbol] ?: return super.visitCall(expression)
+ val newFunction = functionDelegates[expression.target] ?: return super.visitCall(expression)
return expression.run {
// TODO: deduplicate this with ReplaceKFunctionInvokeWithFunctionInvoke
IrCallImpl(startOffset, endOffset, type, newFunction).apply {
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableRefereceToLambda.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableRefereceToLambda.kt
index a17fe24..3002644 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableRefereceToLambda.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableRefereceToLambda.kt
@@ -11,7 +11,6 @@
import org.jetbrains.kotlin.backend.common.ir.copyTo
import org.jetbrains.kotlin.backend.common.ir.copyTypeParametersFrom
import org.jetbrains.kotlin.backend.common.ir.copyValueParametersToStatic
-import org.jetbrains.kotlin.backend.jvm.ir.isInlineParameter
import org.jetbrains.kotlin.backend.common.lower.createIrBuilder
import org.jetbrains.kotlin.backend.common.lower.irBlock
import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
@@ -19,6 +18,7 @@
import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
import org.jetbrains.kotlin.backend.jvm.codegen.isInlineFunctionCall
import org.jetbrains.kotlin.backend.jvm.codegen.isInlineIrExpression
+import org.jetbrains.kotlin.backend.jvm.ir.isInlineParameter
import org.jetbrains.kotlin.codegen.AsmUtil.BOUND_REFERENCE_RECEIVER
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.ir.builders.*
@@ -55,7 +55,7 @@
irFile.transformChildrenVoid(object : IrElementTransformerVoidWithContext() {
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
- val callee = expression.symbol.owner
+ val callee = expression.target
if (callee.isInlineFunctionCall(context)) {
for (valueParameter in callee.valueParameters) {
if (valueParameter.isInlineParameter()) {
@@ -79,11 +79,11 @@
//Use getter if field is absent...
val field =
- expression.field?.owner ?: return functionReferenceToLambda(currentScope!!, expression, expression.getter!!.owner)
+ expression.field ?: return functionReferenceToLambda(currentScope!!, expression, expression.getter!!)
//..else use field itself
val irBuilder =
- context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset)
+ context.createIrBuilder(currentScope!!.scope.irScopeOwner, expression.startOffset, expression.endOffset)
val boundReceiver = expression.dispatchReceiver ?: expression.extensionReceiver
return irBuilder.irBlock(expression, IrStatementOrigin.LAMBDA) {
lateinit var variableForBoundReceiver: IrVariable
@@ -107,7 +107,7 @@
else -> addValueParameter("receiver", field.parentAsClass.defaultType)
}
- val lambdaBodyBuilder = this@InlineCallableReferenceToLambdaPhase.context.createIrBuilder(this.symbol)
+ val lambdaBodyBuilder = this@InlineCallableReferenceToLambdaPhase.context.createIrBuilder(this)
body = lambdaBodyBuilder.irBlockBody(startOffset, endOffset) {
+irReturn(irGetField(if (receiver != null) irGet(receiver) else null, field))
}
@@ -116,7 +116,7 @@
+IrFunctionReferenceImpl(
expression.startOffset, expression.endOffset, field.type,
- newLambda.symbol, newLambda.symbol.descriptor, 0,
+ newLambda, newLambda.descriptor, 0,
IrStatementOrigin.LAMBDA
)
}
@@ -124,7 +124,7 @@
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
if (inlinableCR.contains(expression)) {
- val referencedFunction = expression.symbol.owner
+ val referencedFunction = expression.target
return functionReferenceToLambda(currentScope!!, expression, referencedFunction)
}
@@ -139,7 +139,7 @@
referencedFunction: IrFunction
): IrExpression {
val irBuilder =
- context.createIrBuilder(scope.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset)
+ context.createIrBuilder(scope.scope.irScopeOwner, expression.startOffset, expression.endOffset)
val boundReceiver = expression.dispatchReceiver ?: expression.extensionReceiver
return irBuilder.irBlock(expression, IrStatementOrigin.LAMBDA) {
@@ -173,13 +173,13 @@
)
}
}
- val lambdaBodyBuilder = this@InlineCallableReferenceToLambdaPhase.context.createIrBuilder(this.symbol)
+ val lambdaBodyBuilder = this@InlineCallableReferenceToLambdaPhase.context.createIrBuilder(this)
body = lambdaBodyBuilder.irBlockBody(startOffset, endOffset) {
var shift = 0
val irCall =
if (expression is IrPropertyReference)
- irGet(referencedFunction.returnType, null, referencedFunction.symbol)
- else irCall(referencedFunction.symbol)
+ irGet(referencedFunction.returnType, null, referencedFunction)
+ else irCall(referencedFunction)
+irReturn(
irCall.also { call ->
@@ -207,7 +207,7 @@
+IrFunctionReferenceImpl(
expression.startOffset, expression.endOffset, referencedFunction.returnType,
- newLambda.symbol, newLambda.symbol.descriptor, referencedFunction.typeParameters.size,
+ newLambda, newLambda.descriptor, referencedFunction.typeParameters.size,
IrStatementOrigin.LAMBDA
)
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt
index 4b79211..e44793e 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceDelegationLowering.kt
@@ -33,7 +33,6 @@
import org.jetbrains.kotlin.ir.declarations.impl.IrPropertyImpl
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
import org.jetbrains.kotlin.ir.util.*
@@ -48,12 +47,12 @@
)
private class InterfaceDelegationLowering(val context: JvmBackendContext) : IrElementVisitorVoid, FileLoweringPass {
- val replacementMap = mutableMapOf<IrSimpleFunctionSymbol, IrSimpleFunctionSymbol>()
+ val replacementMap = mutableMapOf<IrSimpleFunction, IrSimpleFunction>()
override fun lower(irFile: IrFile) {
irFile.acceptChildrenVoid(this)
// TODO: Replacer should be run on whole module, not on a single file.
- irFile.acceptVoid(OverriddenSymbolsReplacer(replacementMap))
+ irFile.acceptVoid(OverriddenReplacer(replacementMap))
}
override fun visitElement(element: IrElement) {
@@ -81,9 +80,9 @@
// In classes, only generate interface delegation for functions immediately inherited from am interface.
// (Otherwise, delegation will be present in the parent class)
if (!isDefaultImplsGeneration &&
- function.overriddenSymbols.any {
- (!it.owner.parentAsClass.isInterface || it.owner.hasJvmDefault()) &&
- it.owner.modality != Modality.ABSTRACT
+ function.overridden.any {
+ (!it.parentAsClass.isInterface || it.hasJvmDefault()) &&
+ it.modality != Modality.ABSTRACT
}
) {
continue
@@ -100,7 +99,7 @@
val delegation = generateDelegationToDefaultImpl(irClass, implementation, function, isDefaultImplsGeneration)
if (!isDefaultImplsGeneration) {
toRemove.add(function)
- replacementMap[function.symbol] = delegation.symbol
+ replacementMap[function] = delegation
}
}
irClass.declarations.removeAll(toRemove)
@@ -134,7 +133,7 @@
).apply {
descriptor.bind(this)
parent = irClass
- overriddenSymbols.addAll(inheritedFun.overriddenSymbols)
+ overridden.addAll(inheritedFun.overridden)
copyParameterDeclarationsFrom(inheritedFun)
annotations.addAll(inheritedFun.annotations)
@@ -155,10 +154,10 @@
irClass.declarations.add(irFunction)
- context.createIrBuilder(irFunction.symbol, UNDEFINED_OFFSET, UNDEFINED_OFFSET).apply {
+ context.createIrBuilder(irFunction, UNDEFINED_OFFSET, UNDEFINED_OFFSET).apply {
irFunction.body = irBlockBody {
+irReturn(
- irCall(defaultImplFun.symbol, irFunction.returnType).apply {
+ irCall(defaultImplFun, irFunction.returnType).apply {
var offset = 0
passTypeArgumentsFrom(irFunction)
irFunction.dispatchReceiverParameter?.let { putValueArgument(offset++, irGet(it)) }
@@ -172,7 +171,7 @@
return irFunction
}
- private class OverriddenSymbolsReplacer(val replacementMap: Map<IrSimpleFunctionSymbol, IrSimpleFunctionSymbol>) :
+ private class OverriddenReplacer(val replacementMap: Map<IrSimpleFunction, IrSimpleFunction>) :
IrElementVisitorVoid {
override fun visitElement(element: IrElement) {
@@ -180,7 +179,7 @@
}
override fun visitSimpleFunction(declaration: IrSimpleFunction) {
- declaration.overriddenSymbols.replaceAll(UnaryOperator { symbol -> replacementMap[symbol] ?: symbol })
+ declaration.overridden.replaceAll(UnaryOperator { function -> replacementMap[function] ?: function })
super.visitSimpleFunction(declaration)
}
}
@@ -202,10 +201,10 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- if (expression.superQualifierSymbol?.owner?.isInterface != true) {
+ if (expression.irSuperQualifier?.isInterface != true) {
return super.visitCall(expression)
}
- val superCallee = (expression.symbol.owner as IrSimpleFunction).resolveFakeOverride()!!
+ val superCallee = (expression.target as IrSimpleFunction).resolveFakeOverride()!!
if (superCallee.isDefinitelyNotDefaultImplsMethod()) return super.visitCall(expression)
val redirectTarget = context.declarationFactory.getDefaultImplsFunction(superCallee)
@@ -228,7 +227,7 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- val callee = expression.symbol.owner
+ val callee = expression.target
if (callee.parent.safeAs<IrClass>()?.isInterface != true ||
callee.origin != IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt
index 5462071..ce9ecc3 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt
@@ -20,8 +20,6 @@
import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrReturn
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrLocalDelegatedPropertySymbol
import org.jetbrains.kotlin.ir.util.copyTypeAndValueArgumentsFrom
import org.jetbrains.kotlin.ir.util.irCall
import org.jetbrains.kotlin.ir.util.isInterface
@@ -38,7 +36,7 @@
private class InterfaceLowering(val context: JvmBackendContext) : IrElementTransformerVoid(), ClassLoweringPass {
val state = context.state
- val removedFunctions = hashMapOf<IrFunctionSymbol, IrFunctionSymbol>()
+ val removedFunctions = hashMapOf<IrFunction, IrFunction>()
override fun lower(irClass: IrClass) {
if (!irClass.isInterface) return
@@ -53,7 +51,7 @@
if (function.modality != Modality.ABSTRACT && function.origin != IrDeclarationOrigin.FAKE_OVERRIDE) {
val element = context.declarationFactory.getDefaultImplsFunction(function).also {
if (shouldRemoveFunction(function))
- removedFunctions[function.symbol] = it.symbol
+ removedFunctions[function] = it
}
members.add(element)
element.body = function.body?.patchDeclarationParents(element)
@@ -73,14 +71,14 @@
irClass.transformChildrenVoid(this)
irClass.declarations.removeAll {
- it is IrFunction && removedFunctions.containsKey(it.symbol)
+ it is IrFunction && removedFunctions.containsKey(it)
}
// Move metadata for local delegated properties from the interface to DefaultImpls, since this is where kotlin-reflect looks for it.
val localDelegatedProperties = context.localDelegatedProperties[irClass.attributeOwnerId as IrClass]
if (localDelegatedProperties != null) {
context.localDelegatedProperties[defaultImplsIrClass.attributeOwnerId as IrClass] = localDelegatedProperties
- context.localDelegatedProperties[irClass.attributeOwnerId as IrClass] = emptyList<IrLocalDelegatedPropertySymbol>()
+ context.localDelegatedProperties[irClass.attributeOwnerId as IrClass] = emptyList<IrLocalDelegatedProperty>()
}
// Move $$delegatedProperties array
@@ -103,28 +101,28 @@
val startOffset = interfaceMethod.startOffset
val endOffset = interfaceMethod.endOffset
- return IrCallImpl(startOffset, endOffset, interfaceMethod.returnType, defaultImpls.symbol).apply {
+ return IrCallImpl(startOffset, endOffset, interfaceMethod.returnType, defaultImpls).apply {
passTypeArgumentsFrom(interfaceMethod)
var offset = 0
interfaceMethod.dispatchReceiverParameter?.let {
- putValueArgument(offset++, IrGetValueImpl(startOffset, endOffset, it.symbol))
+ putValueArgument(offset++, IrGetValueImpl(startOffset, endOffset, it))
}
interfaceMethod.extensionReceiverParameter?.let {
- putValueArgument(offset++, IrGetValueImpl(startOffset, endOffset, it.symbol))
+ putValueArgument(offset++, IrGetValueImpl(startOffset, endOffset, it))
}
interfaceMethod.valueParameters.forEachIndexed { i, it ->
- putValueArgument(i + offset, IrGetValueImpl(startOffset, endOffset, it.symbol))
+ putValueArgument(i + offset, IrGetValueImpl(startOffset, endOffset, it))
}
}
}
override fun visitReturn(expression: IrReturn): IrExpression {
- val newFunction = removedFunctions[expression.returnTargetSymbol]?.owner
+ val newFunction = removedFunctions[expression.irReturnTarget]
return super.visitReturn(
if (newFunction != null) {
with(expression) {
- IrReturnImpl(startOffset, endOffset, type, newFunction.symbol, value)
+ IrReturnImpl(startOffset, endOffset, type, newFunction, value)
}
} else {
expression
@@ -133,7 +131,7 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- val newFunction = removedFunctions[expression.symbol]?.owner
+ val newFunction = removedFunctions[expression.target]
return super.visitCall(
if (newFunction != null) {
irCall(expression, newFunction, receiversAsArguments = true)
@@ -144,7 +142,7 @@
}
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
- val newFunction = removedFunctions[expression.symbol]?.owner
+ val newFunction = removedFunctions[expression.target]
return super.visitFunctionReference(
if (newFunction != null) {
with(expression) {
@@ -152,7 +150,7 @@
startOffset,
endOffset,
type,
- newFunction.symbol,
+ newFunction,
newFunction.descriptor,
typeArgumentsCount,
origin
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InventNamesForLocalClasses.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InventNamesForLocalClasses.kt
index f452ab4..e097cf5 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InventNamesForLocalClasses.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InventNamesForLocalClasses.kt
@@ -12,8 +12,6 @@
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
import org.jetbrains.kotlin.ir.util.isAnonymousObject
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
import org.jetbrains.kotlin.name.Name
@@ -44,7 +42,7 @@
private inner class NameInventor : IrElementVisitor<Unit, Data> {
private val anonymousClassesCount = mutableMapOf<String, Int>()
- private val localFunctionNames = mutableMapOf<IrFunctionSymbol, String>()
+ private val localFunctionNames = mutableMapOf<IrFunction, String>()
override fun visitClass(declaration: IrClass, data: Data) {
if (!data.isLocal) {
@@ -104,7 +102,7 @@
declaration.origin == IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA -> {
inventName(null, data).also { name ->
// We save the name of the lambda to reuse it in the reference to it (produced by the closure conversion) later.
- localFunctionNames[(declaration as IrFunction).symbol] = name
+ localFunctionNames[declaration as IrFunction] = name
}
}
declaration is IrFunction && declaration.parent !is IrClass -> {
@@ -129,7 +127,7 @@
}
override fun visitFunctionReference(expression: IrFunctionReference, data: Data) {
- val internalName = localFunctionNames[expression.symbol] ?: inventName(null, data)
+ val internalName = localFunctionNames[expression.target] ?: inventName(null, data)
context.putLocalClassInfo(expression, JvmBackendContext.LocalClassInfo(internalName))
expression.acceptChildren(this, data)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltinOptimizationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltinOptimizationLowering.kt
index 0e0d74f..ff06443 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltinOptimizationLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltinOptimizationLowering.kt
@@ -38,7 +38,7 @@
companion object {
fun isNegation(expression: IrExpression, context: JvmBackendContext): Boolean =
expression is IrCall &&
- context.state.intrinsics.getIntrinsic(expression.symbol.descriptor) is Not
+ context.state.intrinsics.getIntrinsic(expression.target.descriptor) is Not
}
private fun hasNoSideEffectsForNullCompare(expression: IrExpression): Boolean {
@@ -54,11 +54,11 @@
private fun getOperandsIfCallToEqeqOrEquals(call: IrCall): Pair<IrExpression, IrExpression>? {
- if (call.symbol == context.irBuiltIns.eqeqSymbol) {
+ if (call.target == context.irBuiltIns.eqeqSymbol.owner) {
val left = call.getValueArgument(0)!!
val right = call.getValueArgument(1)!!
return left to right
- } else if (call.symbol.owner.isObjectEquals) {
+ } else if (call.target.isObjectEquals) {
val left = call.dispatchReceiver!!
val right = call.getValueArgument(0)!!
return left to right
@@ -134,7 +134,7 @@
expression.startOffset,
expression.endOffset,
context.irBuiltIns.booleanType,
- context.irBuiltIns.andandSymbol
+ context.irBuiltIns.andandSymbol.owner
).apply {
putValueArgument(0, expression.branches[0].condition)
putValueArgument(1, expression.branches[0].result)
@@ -155,7 +155,7 @@
expression.startOffset,
expression.endOffset,
context.irBuiltIns.booleanType,
- context.irBuiltIns.ororSymbol
+ context.irBuiltIns.ororSymbol.owner
).apply {
putValueArgument(0, expression.branches[0].condition)
putValueArgument(1, expression.branches[1].result)
@@ -248,7 +248,7 @@
if (first is IrVariable
&& first.origin == IrDeclarationOrigin.IR_TEMPORARY_VARIABLE
&& second is IrGetValue
- && first.symbol == second.symbol) {
+ && first == second.target) {
statements.clear()
first.initializer?.let { statements.add(it) }
}
@@ -270,7 +270,7 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
// Replace IrGetValue of an immutable temporary variable with a constant
// initializer with the constant initializer.
- val variable = expression.symbol.owner
+ val variable = expression.target
return if (isImmutableTemporaryVariableWithConstantValue(variable))
(variable as IrVariable).initializer!!
else
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt
index 957bf7d..3f80844 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt
@@ -42,7 +42,7 @@
return
irClass.addConstructor().apply {
- val irBuilder = context.createIrBuilder(this.symbol, startOffset, endOffset)
+ val irBuilder = context.createIrBuilder(this, startOffset, endOffset)
body = irBuilder.irBlockBody {
+irDelegatingConstructorCall(primaryConstructor).apply {
passTypeArgumentsFrom(irClass)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
index 37052c3..9a75b80 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
@@ -27,8 +27,6 @@
import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSetVariableImpl
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.classOrNull
import org.jetbrains.kotlin.ir.types.isNullable
@@ -54,7 +52,7 @@
*/
private class JvmInlineClassLowering(private val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoidWithContext() {
private val manager = MemoizedInlineClassReplacements()
- private val valueMap = mutableMapOf<IrValueSymbol, IrValueDeclaration>()
+ private val valueMap = mutableMapOf<IrValueDeclaration, IrValueDeclaration>()
override fun lower(irFile: IrFile) {
irFile.transformChildrenVoid()
@@ -114,15 +112,15 @@
worker.body = function.body?.transform(this, null)?.patchDeclarationParents(worker)
// Don't create a wrapper for functions which are only used in an unboxed context
- if (function.overriddenSymbols.isEmpty() || worker.dispatchReceiverParameter != null)
+ if (function.overridden.isEmpty() || worker.dispatchReceiverParameter != null)
return listOf(worker)
// Replace the function body with a wrapper
- context.createIrBuilder(function.symbol).run {
+ context.createIrBuilder(function).run {
val call = irCall(worker).apply {
passTypeArgumentsFrom(function)
for (parameter in function.explicitParameters) {
- val newParameter = replacement.valueParameterMap[parameter.symbol] ?: continue
+ val newParameter = replacement.valueParameterMap[parameter] ?: continue
putArgument(newParameter, irGet(parameter))
}
}
@@ -140,11 +138,11 @@
valueMap.putAll(replacement.valueParameterMap)
worker.valueParameters.forEach { it.transformChildrenVoid() }
- worker.body = context.createIrBuilder(worker.symbol).irBlockBody(worker) {
+ worker.body = context.createIrBuilder(worker).irBlockBody(worker) {
val thisVar = irTemporaryVarDeclaration(
worker.returnType, nameHint = "\$this", isMutable = false
)
- valueMap[constructor.constructedClass.thisReceiver!!.symbol] = thisVar
+ valueMap[constructor.constructedClass.thisReceiver!!] = thisVar
constructor.body?.statements?.forEach { statement ->
+statement
@@ -160,7 +158,7 @@
// This is safe, since the delegating constructor call precedes all references to "this".
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
expression.transformChildrenVoid()
- return irSetVar(thisVar.symbol, expression)
+ return irSetVar(thisVar, expression)
}
// A constructor body has type unit and may contain explicit return statements.
@@ -177,7 +175,7 @@
// }
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid()
- if (expression.returnTargetSymbol != constructor.symbol)
+ if (expression.irReturnTarget != constructor)
return expression
return irReturn(irBlock(expression.startOffset, expression.endOffset) {
@@ -210,7 +208,7 @@
copyTypeArgumentsFrom(original)
for ((parameter, argument) in typedArgumentList(originalFunction, original)) {
if (argument == null) continue
- val newParameter = replacement.valueParameterMap[parameter.symbol] ?: continue
+ val newParameter = replacement.valueParameterMap[parameter] ?: continue
putArgument(
replacement.function,
newParameter,
@@ -220,25 +218,25 @@
}
override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
- val replacement = manager.getReplacementFunction(expression.symbol.owner)
+ val replacement = manager.getReplacementFunction(expression.target)
?: return super.visitFunctionReference(expression)
val function = replacement.function
return IrFunctionReferenceImpl(
expression.startOffset, expression.endOffset, expression.type,
- function.symbol, function.descriptor,
+ function, function.descriptor,
function.typeParameters.size, function.valueParameters.size,
expression.origin
).apply {
- buildReplacement(expression.symbol.owner, expression, replacement)
+ buildReplacement(expression.target, expression, replacement)
}.copyAttributes(expression)
}
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
- val function = expression.symbol.owner
+ val function = expression.target
val replacement = manager.getReplacementFunction(function)
?: return super.visitFunctionAccess(expression)
- return context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset)
+ return context.createIrBuilder(currentScope!!.scope.irScopeOwner, expression.startOffset, expression.endOffset)
.irCall(replacement.function).apply {
buildReplacement(function, expression, replacement)
}
@@ -276,7 +274,7 @@
val equalsMethod = if (rightIsUnboxed) {
manager.getSpecializedEqualsMethod(klass, context.irBuiltIns)
} else {
- val equals = klass.functions.single { it.name.asString() == "equals" && it.overriddenSymbols.isNotEmpty() }
+ val equals = klass.functions.single { it.name.asString() == "equals" && it.overridden.isNotEmpty() }
manager.getReplacementFunction(equals)!!.function
}
@@ -290,8 +288,8 @@
val rightNullCheck = rightIsUnboxed && right.type.isNullable() // equals-impl has a nullable second argument
return if (leftNullCheck || rightNullCheck) {
irBlock {
- val leftVal = if (left is IrGetValue) left.symbol.owner else irTemporary(left)
- val rightVal = if (right is IrGetValue) right.symbol.owner else irTemporary(right)
+ val leftVal = if (left is IrGetValue) left.target else irTemporary(left)
+ val rightVal = if (right is IrGetValue) right.target else irTemporary(right)
val equalsCall = equals(
if (leftNullCheck) irImplicitCast(irGet(leftVal), left.type.makeNotNull()) else irGet(leftVal),
@@ -319,14 +317,14 @@
when {
// Getting the underlying field of an inline class merely changes the IR type,
// since the underlying representations are the same.
- expression.symbol.owner.isInlineClassFieldGetter -> {
+ expression.target.isInlineClassFieldGetter -> {
val arg = expression.dispatchReceiver!!.transform(this, null)
- coerceInlineClasses(arg, expression.symbol.owner.dispatchReceiverParameter!!.type, expression.type)
+ coerceInlineClasses(arg, expression.target.dispatchReceiverParameter!!.type, expression.type)
}
// Specialize calls to equals when the left argument is a value of inline class type.
expression.isSpecializedInlineClassEqEq -> {
expression.transformChildrenVoid()
- context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset)
+ context.createIrBuilder(currentScope!!.scope.irScopeOwner, expression.startOffset, expression.endOffset)
.specializeEqualsCall(expression.getValueArgument(0)!!, expression.getValueArgument(1)!!)
?: expression
}
@@ -338,7 +336,7 @@
get() {
// Note that reference equality (x === y) is not allowed on values of inline class type,
// so it is enough to check for eqeq.
- if (symbol != context.irBuiltIns.eqeqSymbol)
+ if (target != context.irBuiltIns.eqeqSymbol.owner)
return false
val leftClass = getValueArgument(0)?.type?.classOrNull?.owner?.takeIf { it.isInline }
@@ -350,7 +348,7 @@
}
override fun visitGetField(expression: IrGetField): IrExpression {
- val field = expression.symbol.owner
+ val field = expression.target
val parent = field.parent
if (parent is IrClass && parent.isInline && field.name == parent.inlineClassFieldName) {
val receiver = expression.receiver!!.transform(this, null)
@@ -360,9 +358,9 @@
}
override fun visitReturn(expression: IrReturn): IrExpression {
- expression.returnTargetSymbol.owner.safeAs<IrFunction>()?.let { target ->
+ expression.irReturnTarget.safeAs<IrFunction>()?.let { target ->
manager.getReplacementFunction(target)?.let {
- return context.createIrBuilder(it.function.symbol, expression.startOffset, expression.endOffset).irReturn(
+ return context.createIrBuilder(it.function, expression.startOffset, expression.endOffset).irReturn(
expression.value.transform(this, null)
)
}
@@ -390,20 +388,20 @@
}
override fun visitGetValue(expression: IrGetValue): IrExpression {
- valueMap[expression.symbol]?.let {
+ valueMap[expression.target]?.let {
return IrGetValueImpl(
expression.startOffset, expression.endOffset,
- it.type, it.symbol, expression.origin
+ it.type, it, expression.origin
)
}
return super.visitGetValue(expression)
}
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
- valueMap[expression.symbol]?.let {
+ valueMap[expression.target]?.let {
return IrSetVariableImpl(
expression.startOffset, expression.endOffset,
- it.type, it.symbol as IrVariableSymbol, expression.origin
+ it.type, it as IrVariable, expression.origin
).apply {
value = expression.value.transform(this@JvmInlineClassLowering, null)
}
@@ -420,7 +418,7 @@
returnType = irConstructor.returnType
}.apply {
copyParameterDeclarationsFrom(irConstructor)
- body = context.createIrBuilder(this.symbol).irBlockBody(this) {
+ body = context.createIrBuilder(this).irBlockBody(this) {
+irDelegatingConstructorCall(context.irBuiltIns.anyClass.owner.constructors.single())
+irSetField(
irGet(irClass.thisReceiver!!),
@@ -433,7 +431,7 @@
// Add a static bridge method to the primary constructor.
// This is a placeholder for null-checks and default arguments.
val function = manager.getReplacementFunction(irConstructor)!!.function
- with(context.createIrBuilder(function.symbol)) {
+ with(context.createIrBuilder(function)) {
val argument = function.valueParameters[0]
function.body = irExprBody(
coerceInlineClasses(irGet(argument), argument.type, function.returnType)
@@ -444,9 +442,9 @@
private fun buildBoxFunction(irClass: IrClass) {
val function = manager.getBoxFunction(irClass)
- with(context.createIrBuilder(function.symbol)) {
+ with(context.createIrBuilder(function)) {
function.body = irExprBody(
- irCall(irClass.primaryConstructor!!.symbol).apply {
+ irCall(irClass.primaryConstructor!!).apply {
passTypeArgumentsFrom(function)
putValueArgument(0, irGet(function.valueParameters[0]))
}
@@ -457,7 +455,7 @@
private fun buildUnboxFunction(irClass: IrClass) {
val function = manager.getUnboxFunction(irClass)
- val builder = context.createIrBuilder(function.symbol)
+ val builder = context.createIrBuilder(function)
val field = getInlineClassBackingField(irClass)
function.body = builder.irBlockBody {
@@ -474,7 +472,7 @@
val right = function.valueParameters[1]
val type = left.type.unboxInlineClass()
- function.body = context.createIrBuilder(irClass.symbol).run {
+ function.body = context.createIrBuilder(irClass).run {
irExprBody(
irEquals(
coerceInlineClasses(irGet(left), left.type, type),
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt
index 3df3854..874b044 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt
@@ -56,19 +56,19 @@
val wrapperIrFunction = generateWrapperHeader(target, numDefaultParametersToExpect)
val call = if (target is IrConstructor)
- IrDelegatingConstructorCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, context.irBuiltIns.unitType, target.symbol, target.descriptor)
+ IrDelegatingConstructorCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, context.irBuiltIns.unitType, target, target.descriptor)
else
- IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target.returnType, target.symbol)
+ IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target.returnType, target)
call.dispatchReceiver = wrapperIrFunction.dispatchReceiverParameter?.let { dispatchReceiver ->
IrGetValueImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- dispatchReceiver.symbol
+ dispatchReceiver
)
}
call.extensionReceiver = wrapperIrFunction.extensionReceiverParameter?.let { extensionReceiver ->
IrGetValueImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- extensionReceiver.symbol
+ extensionReceiver
)
}
@@ -82,7 +82,7 @@
i,
IrGetValueImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- wrapperIrFunction.valueParameters[parametersCopied++].symbol
+ wrapperIrFunction.valueParameters[parametersCopied++]
)
)
} else {
@@ -93,7 +93,7 @@
i,
IrGetValueImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- wrapperIrFunction.valueParameters[parametersCopied++].symbol
+ wrapperIrFunction.valueParameters[parametersCopied++]
)
)
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt
index 9c4ab89..d2ba1f7 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt
@@ -126,8 +126,7 @@
private fun createProxyBody(target: IrFunction, proxy: IrFunction, companion: IrClass): IrBody {
val companionInstanceField = context.declarationFactory.getFieldForObjectInstance(companion)
- val companionInstanceFieldSymbol = companionInstanceField.symbol
- val call = IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target.returnType, target.symbol)
+ val call = IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target.returnType, target)
call.passTypeArgumentsFrom(proxy)
@@ -135,7 +134,7 @@
call.dispatchReceiver = IrGetFieldImpl(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- companionInstanceFieldSymbol,
+ companionInstanceField,
companion.defaultType
)
}
@@ -143,7 +142,7 @@
call.extensionReceiver = IrGetValueImpl(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- extensionReceiver.symbol
+ extensionReceiver
)
}
proxy.valueParameters.mapIndexed { i, valueParameter ->
@@ -152,7 +151,7 @@
IrGetValueImpl(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- valueParameter.symbol
+ valueParameter
)
)
}
@@ -191,8 +190,8 @@
val context: JvmBackendContext
) : IrElementTransformerVoid() {
override fun visitCall(expression: IrCall): IrExpression {
- if (expression.symbol.owner.isJvmStaticInSingleton() && expression.dispatchReceiver != null) {
- return context.createIrBuilder(expression.symbol, expression.startOffset, expression.endOffset).irBlock(expression) {
+ if (expression.target.isJvmStaticInSingleton() && expression.dispatchReceiver != null) {
+ return context.createIrBuilder(expression.target, expression.startOffset, expression.endOffset).irBlock(expression) {
// OldReceiver has to be evaluated for its side effects.
val oldReceiver = super.visitExpression(expression.dispatchReceiver!!)
// `coerceToUnit()` is private in InsertImplicitCasts, have to reproduce it here
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MappedEnumWhenLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MappedEnumWhenLowering.kt
index 57eac2a..d1d49c1 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MappedEnumWhenLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MappedEnumWhenLowering.kt
@@ -23,7 +23,6 @@
import org.jetbrains.kotlin.ir.expressions.impl.IrGetEnumValueImpl
import org.jetbrains.kotlin.ir.types.getClass
import org.jetbrains.kotlin.ir.util.*
-import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.util.OperatorNameConventions
@@ -60,9 +59,9 @@
//
private class MappedEnumWhenLowering(context: CommonBackendContext) : EnumWhenLowering(context) {
private val intArray = context.irBuiltIns.primitiveArrayForType.getValue(context.irBuiltIns.intType)
- private val intArrayConstructor = intArray.constructors.single { it.owner.valueParameters.size == 1 }
- private val intArrayGet = intArray.functions.single { it.owner.name == OperatorNameConventions.GET }
- private val intArraySet = intArray.functions.single { it.owner.name == OperatorNameConventions.SET }
+ private val intArrayConstructor = intArray.constructors.single { it.valueParameters.size == 1 }
+ private val intArrayGet = intArray.functions.single { it.name == OperatorNameConventions.GET }
+ private val intArraySet = intArray.functions.single { it.name == OperatorNameConventions.SET }
private val refArraySize = context.irBuiltIns.arrayClass.owner.properties.single { it.name.toString() == "size" }.getter!!
// To avoid visibility-related issues, classes containing the mappings are direct children
@@ -110,13 +109,13 @@
for ((enum, mappingAndField) in state!!.mappings) {
val (mapping, field) = mappingAndField
- val builder = context.createIrBuilder(state!!.mappingsClass.symbol)
+ val builder = context.createIrBuilder(state!!.mappingsClass)
val enumValues = enum.functions.single { it.name.toString() == "values" }
field.initializer = builder.irExprBody(builder.irBlock {
val enumSize = irCall(refArraySize).apply { dispatchReceiver = irCall(enumValues) }
val result = irTemporary(irCall(intArrayConstructor).apply { putValueArgument(0, enumSize) })
for ((entry, index) in mapping) {
- val runtimeEntry = IrGetEnumValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, enum.defaultType, entry.symbol)
+ val runtimeEntry = IrGetEnumValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, enum.defaultType, entry)
+irCall(intArraySet).apply {
dispatchReceiver = irGet(result)
putValueArgument(0, super.mapRuntimeEnumEntry(builder, runtimeEntry)) // <entry>.ordinal()
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt
index 98b2751..a58adde 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/MoveCompanionObjectFieldsLowering.kt
@@ -23,7 +23,6 @@
import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl
@@ -42,7 +41,7 @@
private class MoveOrCopyCompanionObjectFieldsLowering(val context: CommonBackendContext) : ClassLoweringPass {
override fun lower(irClass: IrClass) {
- val fieldReplacementMap = mutableMapOf<IrFieldSymbol, IrFieldSymbol>()
+ val fieldReplacementMap = mutableMapOf<IrField, IrField>()
if (irClass.isObject && !irClass.isCompanion && irClass.visibility != Visibilities.LOCAL) {
handleObject(irClass, fieldReplacementMap)
} else {
@@ -53,7 +52,7 @@
irClass.replaceFieldReferences(fieldReplacementMap)
}
- private fun handleObject(irObject: IrClass, fieldReplacementMap: MutableMap<IrFieldSymbol, IrFieldSymbol>) {
+ private fun handleObject(irObject: IrClass, fieldReplacementMap: MutableMap<IrField, IrField>) {
irObject.declarations.replaceAll {
when (it) {
is IrProperty -> {
@@ -67,7 +66,7 @@
}
}
- private fun handleClass(irClass: IrClass, fieldReplacementMap: MutableMap<IrFieldSymbol, IrFieldSymbol>) {
+ private fun handleClass(irClass: IrClass, fieldReplacementMap: MutableMap<IrField, IrField>) {
val companion = irClass.declarations.find {
it is IrClass && it.isCompanion
} as IrClass? ?: return
@@ -114,7 +113,7 @@
irProperty: IrProperty,
propertyParent: IrClass,
fieldParent: IrClass,
- fieldReplacementMap: MutableMap<IrFieldSymbol, IrFieldSymbol>? = null
+ fieldReplacementMap: MutableMap<IrField, IrField>? = null
): IrField? {
if (irProperty.origin == IrDeclarationOrigin.FAKE_OVERRIDE) return null
val oldField = irProperty.backingField ?: return null
@@ -123,7 +122,7 @@
fieldReplacementMap?.run {
irProperty.backingField = newField
newField.correspondingPropertySymbol = irProperty.symbol
- put(oldField.symbol, newField.symbol)
+ put(oldField, newField)
}
return newField
@@ -133,7 +132,7 @@
irProperty: IrProperty,
propertyParent: IrClass,
fieldParent: IrClass,
- fieldReplacementMap: MutableMap<IrFieldSymbol, IrFieldSymbol>? = null
+ fieldReplacementMap: MutableMap<IrField, IrField>? = null
): IrField? = moveOrCopyPropertyFieldToStaticParent(irProperty, propertyParent, fieldParent, fieldReplacementMap)
private fun copyPropertyFieldToStaticParent(
@@ -149,7 +148,7 @@
): IrAnonymousInitializer =
with(oldInitializer) {
IrAnonymousInitializerImpl(
- startOffset, endOffset, origin, IrAnonymousInitializerSymbolImpl(newParent.symbol),
+ startOffset, endOffset, origin, IrAnonymousInitializerSymbolImpl(newParent),
isStatic = true
).apply {
parent = newParent
@@ -184,18 +183,18 @@
}
override fun visitGetValue(expression: IrGetValue): IrExpression {
- if (expression.symbol.owner == oldParent.thisReceiver) {
+ if (expression.target == oldParent.thisReceiver) {
return IrGetFieldImpl(
expression.startOffset, expression.endOffset,
- objectInstanceField.symbol,
+ objectInstanceField,
expression.type
)
}
- variableMap[expression.symbol.owner]?.let { newVariable ->
+ variableMap[expression.target]?.let { newVariable ->
return IrGetValueImpl(
expression.startOffset, expression.endOffset,
expression.type,
- newVariable.symbol,
+ newVariable,
expression.origin
)
}
@@ -231,33 +230,33 @@
}
}
-private fun IrElement.replaceFieldReferences(replacementMap: Map<IrFieldSymbol, IrFieldSymbol>) {
+private fun IrElement.replaceFieldReferences(replacementMap: Map<IrField, IrField>) {
transformChildrenVoid(FieldReplacer(replacementMap))
}
-private class FieldReplacer(val replacementMap: Map<IrFieldSymbol, IrFieldSymbol>) : IrElementTransformerVoid() {
+private class FieldReplacer(val replacementMap: Map<IrField, IrField>) : IrElementTransformerVoid() {
override fun visitGetField(expression: IrGetField): IrExpression =
- replacementMap[expression.symbol]?.let { newSymbol ->
+ replacementMap[expression.target]?.let { newSymbol ->
IrGetFieldImpl(
expression.startOffset, expression.endOffset,
newSymbol,
expression.type,
/* receiver = */ null,
expression.origin,
- expression.superQualifierSymbol
+ expression.irSuperQualifier
)
} ?: super.visitGetField(expression)
override fun visitSetField(expression: IrSetField): IrExpression =
- replacementMap[expression.symbol]?.let { _ ->
+ replacementMap[expression.target]?.let { _ ->
IrSetFieldImpl(
expression.startOffset, expression.endOffset,
- replacementMap.getValue(expression.symbol),
+ replacementMap.getValue(expression.target),
/* receiver = */ null,
visitExpression(expression.value),
expression.type,
expression.origin,
- expression.superQualifierSymbol
+ expression.irSuperQualifier
)
} ?: super.visitSetField(expression)
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt
index 5ab87c4..f5d3d52 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt
@@ -71,7 +71,7 @@
).apply {
privateFieldDescriptor.bind(this)
parent = irClass
- with(context.createIrBuilder(symbol)) {
+ with(context.createIrBuilder(this)) {
initializer = irExprBody(
irCall(constructor)
)
@@ -79,12 +79,12 @@
pendingTransformations.add { parentAsClass.declarations.add(this) }
}
- with(context.createIrBuilder(publicInstanceField.symbol)) {
+ with(context.createIrBuilder(publicInstanceField)) {
publicInstanceField.initializer = irExprBody(irGetField(null, privateField))
}
} else {
- with(context.createIrBuilder(publicInstanceField.symbol)) {
- publicInstanceField.initializer = irExprBody(irCall(constructor.symbol))
+ with(context.createIrBuilder(publicInstanceField)) {
+ publicInstanceField.initializer = irExprBody(irCall(constructor))
}
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertiesToFieldsLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertiesToFieldsLowering.kt
index 71ae531..40b5df9 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertiesToFieldsLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertiesToFieldsLowering.kt
@@ -46,7 +46,7 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- val simpleFunction = (expression.symbol.owner as? IrSimpleFunction) ?: return super.visitCall(expression)
+ val simpleFunction = (expression.target as? IrSimpleFunction) ?: return super.visitCall(expression)
val property = simpleFunction.correspondingPropertySymbol?.owner ?: return super.visitCall(expression)
if (shouldSubstituteAccessorWithField(property, simpleFunction)) {
@@ -79,12 +79,12 @@
val setExpr = IrSetFieldImpl(
expression.startOffset,
expression.endOffset,
- backingField.symbol,
+ backingField,
receiver,
expression.getValueArgument(expression.valueArgumentsCount - 1)!!.transform(this, null),
expression.type,
expression.origin,
- expression.superQualifierSymbol
+ expression.irSuperQualifier
)
return buildSubstitution(backingField.isStatic, setExpr, receiver)
}
@@ -95,11 +95,11 @@
val getExpr = IrGetFieldImpl(
expression.startOffset,
expression.endOffset,
- backingField.symbol,
+ backingField,
expression.type,
receiver,
expression.origin,
- expression.superQualifierSymbol
+ expression.irSuperQualifier
)
return buildSubstitution(backingField.isStatic, getExpr, receiver)
}
@@ -107,7 +107,7 @@
private fun buildSubstitution(needBlock: Boolean, setOrGetExpr: IrFieldAccessExpression, receiver: IrExpression?): IrExpression {
if (receiver != null && needBlock) {
// Evaluate `dispatchReceiver` for the sake of its side effects, then return `setOrGetExpr`.
- return context.createIrBuilder(setOrGetExpr.symbol, setOrGetExpr.startOffset, setOrGetExpr.endOffset).irBlock(setOrGetExpr) {
+ return context.createIrBuilder(setOrGetExpr.target, setOrGetExpr.startOffset, setOrGetExpr.endOffset).irBlock(setOrGetExpr) {
// `coerceToUnit()` is private in InsertImplicitCasts, have to reproduce it here
val receiverVoid = IrTypeOperatorCallImpl(
receiver.startOffset, receiver.endOffset,
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt
index 6942a6e..b1cd920 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt
@@ -24,7 +24,6 @@
import org.jetbrains.kotlin.ir.builders.declarations.buildField
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.types.createType
import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection
@@ -44,16 +43,16 @@
internal class PropertyReferenceLowering(val context: JvmBackendContext) : ClassLoweringPass {
// Reflection metadata for local properties is serialized under the signature "<v#$N>" attached to the containing class.
// This maps properties to values of N.
- private val localPropertyIndices = mutableMapOf<IrSymbol, Int>()
+ private val localPropertyIndices = mutableMapOf<IrSymbolOwner, Int>()
// TODO: join IrLocalDelegatedPropertyReference and IrPropertyReference via the class hierarchy?
- private val IrMemberAccessExpression.getter: IrSimpleFunctionSymbol?
+ private val IrMemberAccessExpression.getter: IrSimpleFunction?
get() = (this as? IrPropertyReference)?.getter ?: (this as? IrLocalDelegatedPropertyReference)?.getter
- private val IrMemberAccessExpression.setter: IrSimpleFunctionSymbol?
+ private val IrMemberAccessExpression.setter: IrSimpleFunction?
get() = (this as? IrPropertyReference)?.setter ?: (this as? IrLocalDelegatedPropertyReference)?.setter
- private val IrMemberAccessExpression.field: IrFieldSymbol?
+ private val IrMemberAccessExpression.field: IrField?
get() = (this as? IrPropertyReference)?.field
private val IrSimpleFunction.signature: String
@@ -67,7 +66,7 @@
private val IrMemberAccessExpression.signature: String
get() = getter?.let { getter ->
localPropertyIndices[getter]?.let { "<v#$it>" }
- } ?: getter?.owner?.signature ?: field!!.owner.signature
+ } ?: getter?.signature ?: field!!.signature
private val arrayItemGetter =
context.ir.symbols.array.owner.functions.single { it.name.asString() == "get" }
@@ -84,7 +83,7 @@
private val IrMemberAccessExpression.propertyContainer: IrDeclarationParent
get() {
- var current: IrDeclaration = getter?.owner ?: field?.owner ?: error("Property without getter or field: ${dump()}")
+ var current: IrDeclaration = getter ?: field ?: error("Property without getter or field: ${dump()}")
while (current.parent is IrFunction)
current = current.parent as IrFunction // Local delegated property.
return current.parent
@@ -103,7 +102,7 @@
visibility = method.visibility
origin = this@addOverride.origin
}.apply {
- overriddenSymbols.add(method.symbol)
+ overridden.add(method)
dispatchReceiverParameter = thisReceiver!!.copyTo(this)
for (parameter in method.valueParameters)
valueParameters.add(parameter.copyTo(this))
@@ -113,19 +112,19 @@
}
private class PropertyReferenceKind(
- val interfaceSymbol: IrClassSymbol,
- val reflectedSymbol: IrClassSymbol,
+ val interfaceClass: IrClass,
+ val reflected: IrClass,
val wrapper: IrFunction
)
private fun propertyReferenceKind(mutable: Boolean, i: Int) = PropertyReferenceKind(
context.ir.symbols.getPropertyReferenceClass(mutable, i, false),
context.ir.symbols.getPropertyReferenceClass(mutable, i, true),
- context.ir.symbols.reflection.owner.functions.single { it.name.asString() == (if (mutable) "mutableProperty$i" else "property$i") }
+ context.ir.symbols.reflection.functions.single { it.name.asString() == (if (mutable) "mutableProperty$i" else "property$i") }
)
private fun propertyReferenceKindFor(expression: IrMemberAccessExpression): PropertyReferenceKind =
- expression.getter?.owner?.let {
+ expression.getter?.let {
val boundReceivers = listOfNotNull(expression.dispatchReceiver, expression.extensionReceiver).size
val needReceivers = listOfNotNull(it.dispatchReceiverParameter, it.extensionReceiverParameter).size
// PropertyReference1 will swap the receivers if bound with the extension one, and PropertyReference0
@@ -133,14 +132,14 @@
if (boundReceivers == 2 || (expression.extensionReceiver != null && needReceivers == 2))
TODO("property reference with 2 receivers")
propertyReferenceKind(expression.setter != null, needReceivers - boundReceivers)
- } ?: expression.field?.owner?.let {
+ } ?: expression.field?.let {
propertyReferenceKind(!it.isFinal, if (it.isStatic || expression.dispatchReceiver != null) 0 else 1)
} ?: throw AssertionError("property has no getter and no field: ${expression.dump()}")
private data class PropertyInstance(val initializer: IrExpression, val index: Int)
override fun lower(irClass: IrClass) {
- val kProperties = mutableMapOf<IrSymbol, PropertyInstance>()
+ val kProperties = mutableMapOf<IrSymbolOwner, PropertyInstance>()
val kPropertiesField = buildField {
name = Name.identifier(JvmAbi.DELEGATED_PROPERTIES_ARRAY_NAME)
type = kPropertiesFieldType
@@ -153,7 +152,7 @@
irClass.transformChildrenVoid(object : IrElementTransformerVoidWithContext() {
override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty): IrStatement {
- localPropertyIndices[declaration.getter.symbol] = localPropertiesInClass++
+ localPropertyIndices[declaration.getter] = localPropertiesInClass++
return super.visitLocalDelegatedProperty(declaration)
}
@@ -169,8 +168,8 @@
// For delegated properties, the getter and setter contain a reference each as the second argument to getValue
// and setValue. Since it's highly unlikely that anyone will call get/set on these, optimize for space.
- return context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset).run {
- val (_, index) = kProperties.getOrPut(expression.symbol) {
+ return context.createIrBuilder(currentScope!!.scope.irScopeOwner, expression.startOffset, expression.endOffset).run {
+ val (_, index) = kProperties.getOrPut(expression.target) {
PropertyInstance(createReflectedKProperty(expression), kProperties.size)
}
irCall(arrayItemGetter).apply {
@@ -185,9 +184,9 @@
// Example: `C::property` -> `Reflection.property1(PropertyReference1Impl(C::class, "property", "getProperty()LType;"))`.
private fun createReflectedKProperty(expression: IrCallableReference): IrExpression {
val referenceKind = propertyReferenceKindFor(expression)
- return context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset).run {
+ return context.createIrBuilder(currentScope!!.scope.irScopeOwner, expression.startOffset, expression.endOffset).run {
irCall(referenceKind.wrapper).apply {
- putValueArgument(0, irCall(referenceKind.reflectedSymbol.constructors.single()).apply {
+ putValueArgument(0, irCall(referenceKind.reflected.constructors.single()).apply {
putValueArgument(0, buildReflectedContainerReference(expression))
putValueArgument(1, irString(expression.descriptor.name.asString()))
putValueArgument(2, irString(expression.signature))
@@ -212,7 +211,7 @@
//
private fun createSpecializedKProperty(expression: IrCallableReference): IrExpression {
val referenceClass = createKPropertySubclass(expression)
- return context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset)
+ return context.createIrBuilder(currentScope!!.scope.irScopeOwner, expression.startOffset, expression.endOffset)
.irBlock {
+referenceClass
+irCall(referenceClass.constructors.single()).apply {
@@ -224,10 +223,10 @@
}
private fun createKPropertySubclass(expression: IrCallableReference): IrClass {
- val superClass = propertyReferenceKindFor(expression).interfaceSymbol.owner
+ val superClass = propertyReferenceKindFor(expression).interfaceClass
val referenceClass = buildClass {
setSourceRange(expression)
- name = Name.special("<property reference to ${(expression.symbol.owner as IrDeclarationWithName).fqNameWhenAvailable}>")
+ name = Name.special("<property reference to ${(expression.target as IrDeclarationWithName).fqNameWhenAvailable}>")
origin = JvmLoweredDeclarationOrigin.GENERATED_PROPERTY_REFERENCE
visibility = Visibilities.LOCAL
}.apply {
@@ -251,18 +250,18 @@
referenceClass.addOverride(getOwner) { buildReflectedContainerReference(expression) }
referenceClass.addOverride(getSignature) { irString(expression.signature) }
- val field = expression.field?.owner
+ val field = expression.field
if (field == null) {
fun IrBuilderWithScope.setCallArguments(call: IrCall, arguments: List<IrValueParameter>) {
var index = 1
call.copyTypeArgumentsFrom(expression)
- call.dispatchReceiver = call.symbol.owner.dispatchReceiverParameter?.let {
+ call.dispatchReceiver = call.target.dispatchReceiverParameter?.let {
if (expression.dispatchReceiver != null)
irImplicitCast(irGetField(irGet(arguments[0]), receiverField), it.type)
else
irImplicitCast(irGet(arguments[index++]), it.type)
}
- call.extensionReceiver = call.symbol.owner.extensionReceiverParameter?.let {
+ call.extensionReceiver = call.target.extensionReceiverParameter?.let {
if (expression.extensionReceiver != null)
irImplicitCast(irGetField(irGet(arguments[0]), receiverField), it.type)
else
@@ -270,17 +269,17 @@
}
}
- expression.getter?.owner?.let { getter ->
+ expression.getter?.let { getter ->
referenceClass.addOverride(get!!) { arguments ->
- irGet(getter.returnType, null, getter.symbol).apply {
+ irGet(getter.returnType, null, getter).apply {
setCallArguments(this, arguments)
}
}
}
- expression.setter?.owner?.let { setter ->
+ expression.setter?.let { setter ->
referenceClass.addOverride(set!!) { arguments ->
- irSet(setter.returnType, null, setter.symbol, irGet(arguments.last())).apply {
+ irSet(setter.returnType, null, setter, irGet(arguments.last())).apply {
setCallArguments(this, arguments)
}
}
@@ -314,14 +313,14 @@
if (kProperties.isNotEmpty()) {
irClass.declarations.add(0, kPropertiesField.apply {
parent = irClass
- initializer = context.createJvmIrBuilder(irClass.symbol).run {
+ initializer = context.createJvmIrBuilder(irClass).run {
val initializers = kProperties.values.sortedBy { it.index }.map { it.initializer }
irExprBody(irArrayOf(kPropertiesFieldType, initializers))
}
})
context.localDelegatedProperties[irClass.attributeOwnerId as IrClass] =
- kProperties.keys.filterIsInstance<IrLocalDelegatedPropertySymbol>()
+ kProperties.keys.filterIsInstance<IrLocalDelegatedProperty>()
}
}
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RemoveDeclarationsThatWouldBeInlinedLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RemoveDeclarationsThatWouldBeInlinedLowering.kt
index e5fc95b..bb554c4 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RemoveDeclarationsThatWouldBeInlinedLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RemoveDeclarationsThatWouldBeInlinedLowering.kt
@@ -37,7 +37,7 @@
override fun visitFunctionReference(expression: IrFunctionReference) {
assert(expression.origin == IrStatementOrigin.LAMBDA || expression.origin == IrStatementOrigin.ANONYMOUS_FUNCTION)
- loweredLambdasToDelete.add(expression.symbol.owner)
+ loweredLambdasToDelete.add(expression.target)
expression.acceptChildrenVoid(this)
}
})
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RenameFieldsLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RenameFieldsLowering.kt
index 58bef2c..8e05e8e 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RenameFieldsLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RenameFieldsLowering.kt
@@ -20,7 +20,6 @@
import org.jetbrains.kotlin.ir.expressions.IrSetField
import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
import org.jetbrains.kotlin.ir.util.hasAnnotation
import org.jetbrains.kotlin.ir.util.patchDeclarationParents
@@ -74,7 +73,7 @@
val renamer = FieldRenamer(newNames)
irFile.transform(renamer, null)
- irFile.transform(FieldAccessTransformer(renamer.newSymbols), null)
+ irFile.transform(FieldAccessTransformer(renamer.newFields), null)
}
private val IrField.isJvmField: Boolean
@@ -94,7 +93,7 @@
}
private class FieldRenamer(private val newNames: Map<IrField, Name>) : IrElementTransformerVoid() {
- val newSymbols = mutableMapOf<IrField, IrFieldSymbol>()
+ val newFields = mutableMapOf<IrField, IrField>()
override fun visitField(declaration: IrField): IrStatement {
val newName = newNames[declaration] ?: return super.visitField(declaration)
@@ -112,31 +111,31 @@
?.patchDeclarationParents(it)
it.metadata = declaration.metadata
- newSymbols[declaration] = symbol
+ newFields[declaration] = it
}
}
}
-private class FieldAccessTransformer(private val oldToNew: Map<IrField, IrFieldSymbol>) : IrElementTransformerVoid() {
+private class FieldAccessTransformer(private val oldToNew: Map<IrField, IrField>) : IrElementTransformerVoid() {
override fun visitGetField(expression: IrGetField): IrExpression {
- val newSymbol = oldToNew[expression.symbol.owner] ?: return super.visitGetField(expression)
+ val newField = oldToNew[expression.target] ?: return super.visitGetField(expression)
return IrGetFieldImpl(
- expression.startOffset, expression.endOffset, newSymbol, expression.type,
+ expression.startOffset, expression.endOffset, newField, expression.type,
expression.receiver?.transform(this, null),
- expression.origin, expression.superQualifierSymbol
+ expression.origin, expression.irSuperQualifier
)
}
override fun visitSetField(expression: IrSetField): IrExpression {
- val newSymbol = oldToNew[expression.symbol.owner] ?: return super.visitSetField(expression)
+ val newField = oldToNew[expression.target] ?: return super.visitSetField(expression)
return IrSetFieldImpl(
- expression.startOffset, expression.endOffset, newSymbol,
+ expression.startOffset, expression.endOffset, newField,
expression.receiver?.transform(this, null),
expression.value.transform(this, null),
expression.type,
- expression.origin, expression.superQualifierSymbol
+ expression.origin, expression.irSuperQualifier
)
}
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ReplaceKFunctionInvokeWithFunctionInvoke.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ReplaceKFunctionInvokeWithFunctionInvoke.kt
index 8752e67..806a93c 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ReplaceKFunctionInvokeWithFunctionInvoke.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ReplaceKFunctionInvokeWithFunctionInvoke.kt
@@ -39,14 +39,14 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- val callee = expression.symbol.owner
+ val callee = expression.target
if (callee !is IrSimpleFunction || callee.name != OperatorNameConventions.INVOKE) return super.visitCall(expression)
val parentClass = callee.parent as? IrClass ?: return super.visitCall(expression)
if (!parentClass.defaultType.isKFunction() && !parentClass.defaultType.isKSuspendFunction()) return super.visitCall(expression)
// The single overridden function of KFunction{n}.invoke must be Function{n}.invoke.
- val newCallee = callee.overriddenSymbols.single()
+ val newCallee = callee.overridden.single()
return expression.run {
IrCallImpl(startOffset, endOffset, type, newCallee).apply {
copyTypeArgumentsFrom(expression)
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingleAbstractMethodLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingleAbstractMethodLowering.kt
index 9c0da7b..7e167a7 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingleAbstractMethodLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingleAbstractMethodLowering.kt
@@ -74,7 +74,7 @@
return super.visitTypeOperator(expression)
val superType = expression.typeOperand
val invokable = expression.argument.transform(this, null)
- context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol).apply {
+ context.createIrBuilder(currentScope!!.scope.irScopeOwner).apply {
// Do not generate a wrapper class for null, it has no invoke() anyway.
if (invokable.isNullConst())
return invokable
@@ -142,7 +142,7 @@
body = context.createIrBuilder(symbol).irBlockBody(startOffset, endOffset) {
+irDelegatingConstructorCall(context.irBuiltIns.anyClass.owner.constructors.single())
+irSetField(irGet(subclass.thisReceiver!!), field, irGet(parameter))
- +IrInstanceInitializerCallImpl(startOffset, endOffset, subclass.symbol, context.irBuiltIns.unitType)
+ +IrInstanceInitializerCallImpl(startOffset, endOffset, subclass, context.irBuiltIns.unitType)
}
}
@@ -153,7 +153,7 @@
visibility = superMethod.visibility
origin = subclass.origin
}.apply {
- overriddenSymbols += superMethod.symbol
+ overridden += superMethod
dispatchReceiverParameter = subclass.thisReceiver!!.copyTo(this)
superMethod.valueParameters.mapTo(valueParameters) { it.copyTo(this) }
val invokableClass = invokableType.classifierOrFail.owner as IrClass
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt
index 0924e66..34d4112 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SingletonReferencesLowering.kt
@@ -36,14 +36,14 @@
}
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrExpression {
- constructingEnums.push(expression.symbol.owner.parent)
+ constructingEnums.push(expression.target.parent)
val call = super.visitEnumConstructorCall(expression)
constructingEnums.pop()
return call
}
override fun visitGetEnumValue(expression: IrGetEnumValue): IrExpression {
- val candidate = expression.symbol.owner.correspondingClass
+ val candidate = expression.target.correspondingClass
return if (candidate != null && isInScope(candidate) && !isVisitingSuperConstructor(candidate)) {
// Replace `SomeEnumClass.SomeEnumEntry` with `this`, if possible.
@@ -51,16 +51,16 @@
// SomeEnumEntry is a singleton, which is assigned (SETFIELD) to SomeEnumClass after the construction of the singleton is done.
// Therefore, during the construction of SomeEnumEntry, SomeEnumClass.SomeEnumEntry isn't available yet. All references to it
// must be replaced with `SomeEnumEntry.this`.
- IrGetValueImpl(expression.startOffset, expression.endOffset, expression.type, candidate.thisReceiver!!.symbol)
+ IrGetValueImpl(expression.startOffset, expression.endOffset, expression.type, candidate.thisReceiver!!)
} else {
- val entrySymbol = context.declarationFactory.getFieldForEnumEntry(expression.symbol.owner, expression.type)
- IrGetFieldImpl(expression.startOffset, expression.endOffset, entrySymbol.symbol, expression.type)
+ val entry = context.declarationFactory.getFieldForEnumEntry(expression.target, expression.type)
+ IrGetFieldImpl(expression.startOffset, expression.endOffset, entry, expression.type)
}
}
override fun visitGetObjectValue(expression: IrGetObjectValue): IrExpression {
- val instanceField = context.declarationFactory.getFieldForObjectInstance(expression.symbol.owner)
- return IrGetFieldImpl(expression.startOffset, expression.endOffset, instanceField.symbol, expression.type)
+ val instanceField = context.declarationFactory.getFieldForObjectInstance(expression.target)
+ return IrGetFieldImpl(expression.startOffset, expression.endOffset, instanceField, expression.type)
}
// `this` is generally available while the reference is within the lexical scope of the containing enum entry.
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt
index 7ae0572..850b26b 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt
@@ -73,10 +73,10 @@
override fun visitReturn(expression: IrReturn): IrExpression {
return super.visitReturn(
- if (context.staticDefaultStubs.containsKey(expression.returnTargetSymbol)) {
+ if (context.staticDefaultStubs.containsKey(expression.irReturnTarget)) {
with(expression) {
- val irFunction = context.staticDefaultStubs[expression.returnTargetSymbol]!!
- IrReturnImpl(startOffset, endOffset, expression.type, irFunction.symbol, expression.value)
+ val irFunction = context.staticDefaultStubs[expression.irReturnTarget]!!
+ IrReturnImpl(startOffset, endOffset, expression.type, irFunction, expression.value)
}
} else {
expression
@@ -93,7 +93,7 @@
}
override fun visitCall(expression: IrCall): IrExpression {
- val callee = expression.symbol.owner
+ val callee = expression.target
if (callee.origin !== IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER || callee.dispatchReceiverParameter == null) {
return super.visitCall(expression)
}
@@ -106,7 +106,7 @@
}
private fun JvmBackendContext.getStaticFunctionWithReceivers(function: IrFunction) =
- staticDefaultStubs.getOrPut(function.symbol) {
+ staticDefaultStubs.getOrPut(function) {
createStaticFunctionWithReceivers(function.parent, function.name, function, copyBody = false)
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt
index 9493390..2220e4f 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt
@@ -35,6 +35,7 @@
import org.jetbrains.kotlin.load.java.JavaVisibilities
import org.jetbrains.kotlin.load.java.JvmAbi
import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
internal val syntheticAccessorPhase = makeIrFilePhase(
::SyntheticAccessorLowering,
@@ -51,55 +52,55 @@
pendingTransformations.forEach { it() }
}
- private val functionMap = mutableMapOf<IrFunctionSymbol, IrFunctionSymbol>()
- private val getterMap = mutableMapOf<IrFieldSymbol, IrSimpleFunctionSymbol>()
- private val setterMap = mutableMapOf<IrFieldSymbol, IrSimpleFunctionSymbol>()
+ private val functionMap = mutableMapOf<IrFunction, IrFunction>()
+ private val getterMap = mutableMapOf<IrField, IrSimpleFunction>()
+ private val setterMap = mutableMapOf<IrField, IrSimpleFunction>()
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
if (expression.usesDefaultArguments()) {
return super.visitFunctionAccess(expression)
}
- fun makeFunctionAccessorSymbolWithSuper(functionSymbol: IrFunctionSymbol): IrFunctionSymbol =
- when (functionSymbol) {
- is IrConstructorSymbol -> functionSymbol.owner.makeConstructorAccessor().symbol
- is IrSimpleFunctionSymbol -> functionSymbol.owner.makeSimpleFunctionAccessor(expression as IrCall).symbol
- else -> error("Unknown subclass of IrFunctionSymbol")
+ fun makeFunctionAccessorWithSuper(function: IrFunction): IrFunction =
+ when (function) {
+ is IrConstructor -> function.makeConstructorAccessor()
+ is IrSimpleFunction -> function.makeSimpleFunctionAccessor(expression as IrCall)
+ else -> error("Unknown subclass of IrFunction")
}
return super.visitExpression(
handleAccess(
expression,
- expression.symbol,
+ expression.target,
functionMap,
- ::makeFunctionAccessorSymbolWithSuper,
+ ::makeFunctionAccessorWithSuper,
::modifyFunctionAccessExpression,
- (expression as? IrCall)?.superQualifierSymbol,
- (expression as? IrCall)?.dispatchReceiver?.type?.classifierOrNull as? IrClassSymbol
+ (expression as? IrCall)?.irSuperQualifier,
+ (expression as? IrCall)?.dispatchReceiver?.type?.classifierOrNull.safeAs<IrClassSymbol>()?.owner
)
)
}
override fun visitGetField(expression: IrGetField) = super.visitExpression(
- handleAccess(expression, expression.symbol, getterMap, ::makeGetterAccessorSymbol, ::modifyGetterExpression)
+ handleAccess(expression, expression.target, getterMap, ::makeGetterAccessor, ::modifyGetterExpression)
)
override fun visitSetField(expression: IrSetField) = super.visitExpression(
- handleAccess(expression, expression.symbol, setterMap, ::makeSetterAccessorSymbol, ::modifySetterExpression)
+ handleAccess(expression, expression.target, setterMap, ::makeSetterAccessor, ::modifySetterExpression)
)
- private inline fun <ExprT : IrDeclarationReference, reified FromSyT : IrSymbol, ToSyT : IrSymbol> handleAccess(
+ private inline fun <ExprT : IrDeclarationReference, reified FromSyT : IrDeclarationWithVisibility, ToSyT : IrDeclarationWithVisibility> handleAccess(
expression: ExprT,
- symbol: FromSyT,
+ declaration: FromSyT,
accumMap: MutableMap<FromSyT, ToSyT>,
- symbolConverter: (FromSyT) -> ToSyT,
+ declarationConverter: (FromSyT) -> ToSyT,
exprConverter: (ExprT, ToSyT) -> IrDeclarationReference,
- superQualifierSymbol: IrClassSymbol? = null,
- thisSymbol: IrClassSymbol? = null
+ superQualifier: IrClass? = null,
+ thisObjReference: IrClass? = null
): IrExpression =
- if (!symbol.isAccessible(superQualifierSymbol != null, thisSymbol)) {
- val accessorSymbol = accumMap.getOrPut(symbol) { symbolConverter(symbol) }
- exprConverter(expression, accessorSymbol)
+ if (!declaration.isAccessible(superQualifier != null, thisObjReference)) {
+ val accessor = accumMap.getOrPut(declaration) { declarationConverter(declaration) }
+ exprConverter(expression, accessor)
} else {
expression
}
@@ -129,22 +130,22 @@
accessor.returnType = source.returnType.remapTypeParameters(source, accessor)
accessor.addValueParameter(
- "marker", context.ir.symbols.defaultConstructorMarker.owner.defaultType, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
+ "marker", context.ir.symbols.defaultConstructorMarker.defaultType, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
)
accessor.body = IrExpressionBodyImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- createConstructorCall(accessor, source.symbol)
+ createConstructorCall(accessor, source)
)
}
}
- private fun createConstructorCall(accessor: IrConstructor, targetSymbol: IrConstructorSymbol) =
+ private fun createConstructorCall(accessor: IrConstructor, target: IrConstructor) =
IrDelegatingConstructorCallImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
context.irBuiltIns.unitType,
- targetSymbol, targetSymbol.descriptor,
- targetSymbol.owner.parentAsClass.typeParameters.size + targetSymbol.owner.typeParameters.size
+ target, target.descriptor,
+ target.parentAsClass.typeParameters.size + target.typeParameters.size
).also {
copyAllParamsToArgs(it, accessor)
}
@@ -201,94 +202,94 @@
accessor.body = IrExpressionBodyImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- createSimpleFunctionCall(accessor, source.symbol, expression.superQualifierSymbol)
+ createSimpleFunctionCall(accessor, source, expression.irSuperQualifier)
)
}
}
- private fun createSimpleFunctionCall(accessor: IrFunction, targetSymbol: IrFunctionSymbol, superQualifierSymbol: IrClassSymbol?) =
+ private fun createSimpleFunctionCall(accessor: IrFunction, target: IrFunction, superQualifier: IrClass?) =
IrCallImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
accessor.returnType,
- targetSymbol, targetSymbol.descriptor,
- targetSymbol.owner.typeParameters.size,
- superQualifierSymbol = superQualifierSymbol
+ target, target.descriptor,
+ target.typeParameters.size,
+ irSuperQualifier = superQualifier
).also {
copyAllParamsToArgs(it, accessor)
}
- private fun makeGetterAccessorSymbol(fieldSymbol: IrFieldSymbol): IrSimpleFunctionSymbol =
+ private fun makeGetterAccessor(field: IrField): IrSimpleFunction =
buildFun {
origin = JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
- name = fieldSymbol.owner.accessorNameForGetter()
+ name = field.accessorNameForGetter()
visibility = Visibilities.PUBLIC
modality = Modality.FINAL
- returnType = fieldSymbol.owner.type
+ returnType = field.type
}.also { accessor ->
- accessor.parent = fieldSymbol.owner.accessorParent()
+ accessor.parent = field.accessorParent()
pendingTransformations.add { (accessor.parent as IrDeclarationContainer).declarations.add(accessor) }
- if (!fieldSymbol.owner.isStatic) {
+ if (!field.isStatic) {
accessor.addValueParameter(
- "\$this", fieldSymbol.owner.parentAsClass.defaultType, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
+ "\$this", field.parentAsClass.defaultType, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
)
}
- accessor.body = createAccessorBodyForGetter(fieldSymbol.owner, accessor)
- }.symbol
+ accessor.body = createAccessorBodyForGetter(field, accessor)
+ }
private fun createAccessorBodyForGetter(targetField: IrField, accessor: IrSimpleFunction): IrBody {
val resolvedTargetField = targetField.resolveFakeOverride()!!
val maybeDispatchReceiver =
if (resolvedTargetField.isStatic) null
- else IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, accessor.valueParameters[0].symbol)
+ else IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, accessor.valueParameters[0])
return IrExpressionBodyImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
IrGetFieldImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- resolvedTargetField.symbol,
+ resolvedTargetField,
resolvedTargetField.type,
maybeDispatchReceiver
)
)
}
- private fun makeSetterAccessorSymbol(fieldSymbol: IrFieldSymbol): IrSimpleFunctionSymbol =
+ private fun makeSetterAccessor(field: IrField): IrSimpleFunction =
buildFun {
origin = JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
- name = fieldSymbol.owner.accessorNameForSetter()
+ name = field.accessorNameForSetter()
visibility = Visibilities.PUBLIC
modality = Modality.FINAL
returnType = context.irBuiltIns.unitType
}.also { accessor ->
- accessor.parent = fieldSymbol.owner.accessorParent()
+ accessor.parent = field.accessorParent()
pendingTransformations.add { (accessor.parent as IrDeclarationContainer).declarations.add(accessor) }
- if (!fieldSymbol.owner.isStatic) {
+ if (!field.isStatic) {
accessor.addValueParameter(
- "\$this", fieldSymbol.owner.parentAsClass.defaultType, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
+ "\$this", field.parentAsClass.defaultType, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
)
}
- accessor.addValueParameter("value", fieldSymbol.owner.type, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR)
+ accessor.addValueParameter("value", field.type, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR)
- accessor.body = createAccessorBodyForSetter(fieldSymbol.owner, accessor)
- }.symbol
+ accessor.body = createAccessorBodyForSetter(field, accessor)
+ }
private fun createAccessorBodyForSetter(targetField: IrField, accessor: IrSimpleFunction): IrBody {
val resolvedTargetField = targetField.resolveFakeOverride()!!
val maybeDispatchReceiver =
if (resolvedTargetField.isStatic) null
- else IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, accessor.valueParameters[0].symbol)
+ else IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, accessor.valueParameters[0])
val value = IrGetValueImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- accessor.valueParameters[if (resolvedTargetField.isStatic) 0 else 1].symbol
+ accessor.valueParameters[if (resolvedTargetField.isStatic) 0 else 1]
)
return IrExpressionBodyImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
IrSetFieldImpl(
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
- resolvedTargetField.symbol,
+ resolvedTargetField,
maybeDispatchReceiver,
value,
context.irBuiltIns.unitType
@@ -298,27 +299,27 @@
private fun modifyFunctionAccessExpression(
oldExpression: IrFunctionAccessExpression,
- accessorSymbol: IrFunctionSymbol
+ accessor: IrFunction
): IrFunctionAccessExpression {
val newExpression = when (oldExpression) {
is IrCall -> IrCallImpl(
oldExpression.startOffset, oldExpression.endOffset,
oldExpression.type,
- accessorSymbol, accessorSymbol.descriptor,
+ accessor, accessor.descriptor,
oldExpression.typeArgumentsCount,
oldExpression.origin
)
is IrDelegatingConstructorCall -> IrDelegatingConstructorCallImpl(
oldExpression.startOffset, oldExpression.endOffset,
context.irBuiltIns.unitType,
- accessorSymbol as IrConstructorSymbol, accessorSymbol.descriptor,
+ accessor as IrConstructor, accessor.descriptor,
oldExpression.typeArgumentsCount
)
is IrConstructorCall ->
IrConstructorCallImpl.fromSymbolDescriptor(
oldExpression.startOffset, oldExpression.endOffset,
oldExpression.type,
- accessorSymbol as IrConstructorSymbol
+ accessor as IrConstructor
)
else ->
error("Unexpected IrFunctionAccessExpression: $oldExpression")
@@ -328,13 +329,13 @@
receiverAndArgs.forEachIndexed { i, irExpression ->
newExpression.putValueArgument(i, irExpression)
}
- if (accessorSymbol is IrConstructorSymbol) {
+ if (accessor is IrConstructor) {
newExpression.putValueArgument(
receiverAndArgs.size,
IrConstImpl.constNull(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- context.ir.symbols.defaultConstructorMarker.owner.defaultType
+ context.ir.symbols.defaultConstructorMarker.defaultType
)
)
}
@@ -343,12 +344,12 @@
private fun modifyGetterExpression(
oldExpression: IrGetField,
- accessorSymbol: IrFunctionSymbol
+ accessor: IrSimpleFunction
): IrCall {
val call = IrCallImpl(
oldExpression.startOffset, oldExpression.endOffset,
oldExpression.type,
- accessorSymbol, accessorSymbol.descriptor,
+ accessor, accessor.descriptor,
0,
oldExpression.origin
)
@@ -360,12 +361,12 @@
private fun modifySetterExpression(
oldExpression: IrSetField,
- accessorSymbol: IrFunctionSymbol
+ accessor: IrSimpleFunction
): IrCall {
val call = IrCallImpl(
oldExpression.startOffset, oldExpression.endOffset,
oldExpression.type,
- accessorSymbol, accessorSymbol.descriptor,
+ accessor, accessor.descriptor,
0,
oldExpression.origin
)
@@ -388,15 +389,15 @@
call.passTypeArgumentsFrom(syntheticFunction, offset = typeArgumentOffset)
var offset = 0
- val delegateTo = call.symbol.owner
+ val delegateTo = call.target
delegateTo.dispatchReceiverParameter?.let {
call.dispatchReceiver =
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, syntheticFunction.valueParameters[offset++].symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, syntheticFunction.valueParameters[offset++])
}
delegateTo.extensionReceiverParameter?.let {
call.extensionReceiver =
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, syntheticFunction.valueParameters[offset++].symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, syntheticFunction.valueParameters[offset++])
}
delegateTo.valueParameters.forEachIndexed { i, _ ->
@@ -405,7 +406,7 @@
IrGetValueImpl(
UNDEFINED_OFFSET,
UNDEFINED_OFFSET,
- syntheticFunction.valueParameters[i + offset].symbol
+ syntheticFunction.valueParameters[i + offset]
)
)
}
@@ -437,14 +438,13 @@
this == JavaVisibilities.PROTECTED_AND_PACKAGE ||
this == JavaVisibilities.PROTECTED_STATIC_VISIBILITY
- private fun IrSymbol.isAccessible(withSuper: Boolean, thisObjReference: IrClassSymbol?): Boolean {
+ private fun IrDeclarationWithVisibility.isAccessible(withSuper: Boolean, thisObjReference: IrClass?): Boolean {
/// We assume that IR code that reaches us has been checked for correctness at the frontend.
/// This function needs to single out those cases where Java accessibility rules differ from Kotlin's.
- val declarationRaw = owner as IrDeclarationWithVisibility
val declaration =
- (declarationRaw as? IrSimpleFunction)?.resolveFakeOverride()
- ?: (declarationRaw as? IrField)?.resolveFakeOverride() ?: declarationRaw
+ (this as? IrSimpleFunction)?.resolveFakeOverride()
+ ?: (this as? IrField)?.resolveFakeOverride() ?: this
// There is never a problem with visibility of inline functions, as those don't end up as Java entities
if (declaration is IrFunction && declaration.isInline) return true
@@ -472,7 +472,7 @@
// 1. `this` to be assign compatible with current class.
// 2. the method is a member of a superclass of current class.
(withSuper && contextDeclarationContainer is IrClass && symbolDeclarationContainer is IrClass &&
- ((thisObjReference != null && !contextDeclarationContainer.symbol.isSubtypeOfClass(thisObjReference)) ||
+ ((thisObjReference != null && !contextDeclarationContainer.isSubtypeOfClass(thisObjReference)) ||
!(contextDeclarationContainer.isSubclassOf(symbolDeclarationContainer)))) -> false
else -> true
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt
index 2c71982..19b451a 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/ToArrayLowering.kt
@@ -123,14 +123,14 @@
}
)
- irFunction.body = context.createIrBuilder(irFunction.symbol).irBlockBody {
+ irFunction.body = context.createIrBuilder(irFunction).irBlockBody {
+irReturn(
- irCall(symbols.genericToArray, symbols.genericToArray.owner.returnType).apply {
+ irCall(symbols.genericToArray, symbols.genericToArray.returnType).apply {
putValueArgument(
0,
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irFunction.dispatchReceiverParameter!!.symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irFunction.dispatchReceiverParameter!!)
)
- putValueArgument(1, IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irFunction.valueParameters[0].symbol))
+ putValueArgument(1, IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irFunction.valueParameters[0]))
})
}
@@ -172,12 +172,12 @@
parent = irFunction
}
- irFunction.body = context.createIrBuilder(irFunction.symbol).irBlockBody {
+ irFunction.body = context.createIrBuilder(irFunction).irBlockBody {
+irReturn(
- irCall(symbols.nonGenericToArray, symbols.nonGenericToArray.owner.returnType).apply {
+ irCall(symbols.nonGenericToArray, symbols.nonGenericToArray.returnType).apply {
putValueArgument(
0,
- IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irFunction.dispatchReceiverParameter!!.symbol)
+ IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, irFunction.dispatchReceiverParameter!!)
)
})
}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt
index 17d774d..2fe4873 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt
@@ -20,12 +20,12 @@
import org.jetbrains.kotlin.ir.builders.*
import org.jetbrains.kotlin.ir.declarations.IrDeclaration
import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.render
@@ -64,8 +64,8 @@
argument.type.isNullable() && type.isNullable() -> {
irLetS(argument) { valueSymbol ->
context.oror(
- irEqualsNull(irGet(valueSymbol.owner)),
- irIs(irGet(valueSymbol.owner), type.makeNotNull())
+ irEqualsNull(irGet(valueSymbol)),
+ irIs(irGet(valueSymbol), type.makeNotNull())
)
}
}
@@ -81,15 +81,15 @@
irLetS(argument) { valueSymbol ->
irIfNull(
type,
- irGet(valueSymbol.owner),
+ irGet(valueSymbol),
irThrow(irCall(typeCastException).apply {
putValueArgument(0, irString("null cannot be cast to non-null type ${type.render()}"))
}),
- lowerCast(irGet(valueSymbol.owner), type.makeNullable())
+ lowerCast(irGet(valueSymbol), type.makeNullable())
)
}
}
- argument.type.isSubtypeOfClass(type.erasedUpperBound.symbol) ->
+ argument.type.isSubtypeOfClass(type.erasedUpperBound) ->
argument
else ->
builder.irAs(argument, type)
@@ -123,8 +123,8 @@
irLetS(expression.argument.transformVoid(), IrStatementOrigin.SAFE_CALL) { valueSymbol ->
irIfThenElse(
expression.type,
- lowerInstanceOf(irGet(valueSymbol.owner), expression.typeOperand.makeNotNull()),
- irGet(valueSymbol.owner),
+ lowerInstanceOf(irGet(valueSymbol), expression.typeOperand.makeNotNull()),
+ irGet(valueSymbol),
irNull(expression.type)
)
}
@@ -143,10 +143,10 @@
irLetS(expression.argument.transformVoid()) { valueSymbol ->
irComposite(resultType = expression.type) {
+irCall(checkExpressionValueIsNotNull).apply {
- putValueArgument(0, irGet(valueSymbol.owner))
+ putValueArgument(0, irGet(valueSymbol))
putValueArgument(1, irString(source))
}
- +irGet(valueSymbol.owner)
+ +irGet(valueSymbol)
}
}
}
@@ -180,13 +180,13 @@
private val useNullPointerExceptions: Boolean
get() = context.state.languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4
- private val typeCastException: IrFunctionSymbol =
+ private val typeCastException: IrFunction =
if (useNullPointerExceptions)
context.ir.symbols.ThrowNullPointerException
else
context.ir.symbols.ThrowTypeCastException
- private val checkExpressionValueIsNotNull: IrFunctionSymbol =
+ private val checkExpressionValueIsNotNull: IrFunction =
if (useNullPointerExceptions)
context.ir.symbols.checkNotNullExpressionValue
else
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt
index eb9650b..fff4ad4 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt
@@ -22,7 +22,6 @@
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.util.*
val varargPhase = makeIrFilePhase(
@@ -36,7 +35,7 @@
// Ignore annotations
override fun visitConstructorCall(expression: IrConstructorCall): IrExpression {
- val constructor = expression.symbol.owner
+ val constructor = expression.target
if (constructor.constructedClass.isAnnotationClass)
return expression
return super.visitConstructorCall(expression)
@@ -44,14 +43,14 @@
override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
expression.transformChildrenVoid()
- val function = expression.symbol
+ val function = expression.target
// Replace empty varargs with empty arrays
for (i in 0 until expression.valueArgumentsCount) {
if (expression.getValueArgument(i) != null)
continue
- val parameter = function.owner.valueParameters[i]
+ val parameter = function.valueParameters[i]
if (parameter.varargElementType != null && !parameter.hasDefaultValue()) {
// Compute the correct type for the array argument.
val arrayType = parameter.type.substitute(expression.typeSubstitutionMap)
@@ -73,7 +72,7 @@
is IrExpression -> +element.transform(this@VarargLowering, null)
is IrSpreadElement -> {
val spread = element.expression
- if (spread is IrFunctionAccessExpression && spread.symbol.isArrayOf) {
+ if (spread is IrFunctionAccessExpression && spread.target.isArrayOf) {
// Skip empty arrays and don't copy immediately created arrays
val argument = spread.getValueArgument(0) ?: continue@loop
if (argument is IrVararg) {
@@ -89,10 +88,10 @@
}
private fun createBuilder(startOffset: Int = UNDEFINED_OFFSET, endOffset: Int = UNDEFINED_OFFSET) =
- context.createJvmIrBuilder(currentScope!!.scope.scopeOwnerSymbol, startOffset, endOffset)
+ context.createJvmIrBuilder(currentScope!!.scope.irScopeOwner, startOffset, endOffset)
- private val IrFunctionSymbol.isArrayOf
- get() = this == context.ir.symbols.arrayOf || owner.isPrimitiveArrayOf
+ private val IrFunction.isArrayOf
+ get() = this == context.ir.symbols.arrayOf || isPrimitiveArrayOf
companion object {
private val PRIMITIVE_ARRAY_OF_NAMES: Set<String> =
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt
index 5515a41..f2eb073 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt
@@ -18,8 +18,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
import org.jetbrains.kotlin.ir.types.getClass
import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
import org.jetbrains.kotlin.ir.types.impl.IrStarProjectionImpl
@@ -32,7 +30,7 @@
class IrReplacementFunction(
val function: IrFunction,
- val valueParameterMap: Map<IrValueParameterSymbol, IrValueParameter>
+ val valueParameterMap: Map<IrValueParameter, IrValueParameter>
)
/**
@@ -136,17 +134,17 @@
private fun createMethodReplacement(function: IrFunction): IrReplacementFunction? {
require(function.dispatchReceiverParameter != null && function is IrSimpleFunction)
- val overrides = function.overriddenSymbols.mapNotNull {
- getReplacementFunction(it.owner)?.function?.symbol as? IrSimpleFunctionSymbol
+ val overrides = function.overridden.mapNotNull {
+ getReplacementFunction(it)?.function as? IrSimpleFunction
}
if (function.origin == IrDeclarationOrigin.FAKE_OVERRIDE && overrides.isEmpty())
return null
- val parameterMap = mutableMapOf<IrValueParameterSymbol, IrValueParameter>()
+ val parameterMap = mutableMapOf<IrValueParameter, IrValueParameter>()
val replacement = buildReplacement(function) {
annotations += function.annotations
metadata = function.metadata
- overriddenSymbols.addAll(overrides)
+ overridden.addAll(overrides)
for ((index, parameter) in function.explicitParameters.withIndex()) {
val name = if (parameter == function.extensionReceiverParameter) Name.identifier("\$receiver") else parameter.name
@@ -158,16 +156,16 @@
newParameter = parameter.copyTo(this, index = index - 1, name = name)
valueParameters.add(newParameter)
}
- parameterMap[parameter.symbol] = newParameter
+ parameterMap[parameter] = newParameter
}
}
return IrReplacementFunction(replacement, parameterMap)
}
private fun createStaticReplacement(function: IrFunction): IrReplacementFunction {
- val parameterMap = mutableMapOf<IrValueParameterSymbol, IrValueParameter>()
+ val parameterMap = mutableMapOf<IrValueParameter, IrValueParameter>()
val replacement = buildReplacement(function) {
- if (function !is IrSimpleFunction || function.overriddenSymbols.isEmpty())
+ if (function !is IrSimpleFunction || function.overridden.isEmpty())
metadata = function.metadata
for ((index, parameter) in function.explicitParameters.withIndex()) {
@@ -179,7 +177,7 @@
val newParameter = parameter.copyTo(this, index = index, name = name)
valueParameters.add(newParameter)
- parameterMap[parameter.symbol] = newParameter
+ parameterMap[parameter] = newParameter
}
}
return IrReplacementFunction(replacement, parameterMap)
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmLoweringPhases.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmLoweringPhases.kt
index cd82dc7..9326e1c 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmLoweringPhases.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmLoweringPhases.kt
@@ -323,7 +323,8 @@
val wasmPhases = namedIrModulePhase<WasmBackendContext>(
name = "IrModuleLowering",
description = "IR module lowering",
- lower = validateIrBeforeLowering then
+ lower = desymbolizePhase then
+ validateIrBeforeLowering then
excludeDeclarationsFromCodegenPhase then
expectDeclarationsRemovingPhase then
provisionalFunctionExpressionPhase then
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/codegen/ExpressionTransformer.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/codegen/ExpressionTransformer.kt
index 54ba690..97b7c52 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/codegen/ExpressionTransformer.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/codegen/ExpressionTransformer.kt
@@ -54,7 +54,7 @@
}
override fun visitGetField(expression: IrGetField, data: WasmCodegenContext): WasmInstruction {
- val fieldName = data.getGlobalName(expression.symbol.owner)
+ val fieldName = data.getGlobalName(expression.target)
if (expression.receiver != null)
TODO("Support member fields")
@@ -62,14 +62,14 @@
}
override fun visitGetValue(expression: IrGetValue, data: WasmCodegenContext): WasmInstruction =
- WasmGetLocal(data.getLocalName(expression.symbol.owner))
+ WasmGetLocal(data.getLocalName(expression.target))
override fun visitGetObjectValue(expression: IrGetObjectValue, data: WasmCodegenContext): WasmInstruction {
TODO("IrGetObjectValue")
}
override fun visitSetField(expression: IrSetField, data: WasmCodegenContext): WasmInstruction {
- val fieldName = data.getGlobalName(expression.symbol.owner)
+ val fieldName = data.getGlobalName(expression.target)
if (expression.receiver != null)
TODO("Support member fields")
@@ -78,7 +78,7 @@
}
override fun visitSetVariable(expression: IrSetVariable, data: WasmCodegenContext): WasmInstruction {
- val fieldName = data.getLocalName(expression.symbol.owner)
+ val fieldName = data.getLocalName(expression.target)
val value = expression.value.accept(this, data)
return WasmSetLocal(fieldName, value)
}
@@ -88,7 +88,7 @@
}
override fun visitCall(expression: IrCall, data: WasmCodegenContext): WasmInstruction {
- val function = expression.symbol.owner.realOverrideTarget
+ val function = expression.target.realOverrideTarget
require(function is IrSimpleFunction) { "Only IrSimpleFunction could be called via IrCall" }
val valueArgs = (0 until expression.valueArgumentsCount).mapNotNull { expression.getValueArgument(it) }
val irArguments = listOfNotNull(expression.dispatchReceiver, expression.extensionReceiver) + valueArgs
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/BuiltInsLowering.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/BuiltInsLowering.kt
index b688091..256aaca 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/BuiltInsLowering.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/BuiltInsLowering.kt
@@ -9,7 +9,6 @@
import org.jetbrains.kotlin.backend.wasm.WasmBackendContext
import org.jetbrains.kotlin.ir.declarations.IrFile
import org.jetbrains.kotlin.ir.expressions.IrCall
-import org.jetbrains.kotlin.ir.expressions.IrConst
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.util.irCall
import org.jetbrains.kotlin.ir.util.render
@@ -21,7 +20,7 @@
private val symbols = context.wasmSymbols
fun transformCall(call: IrCall): IrExpression {
- when (val symbol = call.symbol) {
+ when (val symbol = call.target) {
irBuiltins.eqeqSymbol, irBuiltins.eqeqeqSymbol, in irBuiltins.ieee754equalsFunByOperandType.values -> {
val type = call.getValueArgument(0)!!.type
val newSymbol = symbols.equalityFunctions[type]
diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt
index 6901294..798053c 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt
@@ -420,7 +420,7 @@
context.symbolTable.referenceFunction(functionDescriptor.original),
functionDescriptor,
origin = null, // TODO origin for widening conversions?
- superQualifierSymbol = null
+ irSuperQualifier = null
).apply {
dispatchReceiver = receiver
}
diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt
index 46ca1bd..5704174 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt
@@ -17,6 +17,8 @@
package org.jetbrains.kotlin.psi2ir.generators
import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrClassifier
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt
index 43ffa8c..915ae74 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt
@@ -105,7 +105,7 @@
override fun visitReturn(expression: IrReturn): IrExpression =
expression.transformPostfix {
- value = if (expression.returnTargetSymbol is IrConstructorSymbol) {
+ value = if (expression.irReturnTarget is IrConstructorSymbol) {
value.coerceToUnit()
} else {
value.cast(expression.returnTarget.returnType)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt
index 597c6fa..01ef93d 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt
@@ -11,7 +11,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.util.parentAsClass
import org.jetbrains.kotlin.types.KotlinType
@@ -23,10 +22,10 @@
value: IrExpression,
origin: IrStatementOrigin? = null,
nameHint: String? = null,
- body: (IrValueSymbol) -> IrExpression
+ body: (IrValueDeclaration) -> IrExpression
): IrExpression {
val irTemporary = scope.createTemporaryVariable(value, nameHint)
- val irResult = body(irTemporary.symbol)
+ val irResult = body(irTemporary)
val irBlock = IrBlockImpl(startOffset, endOffset, irResult.type, origin)
irBlock.statements.add(irTemporary)
irBlock.statements.add(irResult)
@@ -88,7 +87,7 @@
IrReturnImpl(
startOffset, endOffset,
context.irBuiltIns.nothingType,
- scope.scopeOwnerSymbol.assertedCast<IrReturnTargetSymbol> {
+ scope.irScopeOwner.assertedCast<IrReturnTarget> {
"Function scope expected: ${scope.scopeOwner}"
},
value
@@ -150,22 +149,22 @@
fun IrBuilderWithScope.irIfThenReturnFalse(condition: IrExpression) =
irIfThen(context.irBuiltIns.unitType, condition, irReturnFalse())
-fun IrBuilderWithScope.irGet(type: IrType, variable: IrValueSymbol) =
+fun IrBuilderWithScope.irGet(type: IrType, variable: IrValueDeclaration) =
IrGetValueImpl(startOffset, endOffset, type, variable)
-fun IrBuilderWithScope.irGet(variable: IrValueDeclaration) = irGet(variable.type, variable.symbol)
+fun IrBuilderWithScope.irGet(variable: IrValueDeclaration) = irGet(variable.type, variable)
-fun IrBuilderWithScope.irSetVar(variable: IrVariableSymbol, value: IrExpression) =
+fun IrBuilderWithScope.irSetVar(variable: IrVariable, value: IrExpression) =
IrSetVariableImpl(startOffset, endOffset, context.irBuiltIns.unitType, variable, value, IrStatementOrigin.EQ)
fun IrBuilderWithScope.irGetField(receiver: IrExpression?, field: IrField) =
- IrGetFieldImpl(startOffset, endOffset, field.symbol, field.type, receiver)
+ IrGetFieldImpl(startOffset, endOffset, field, field.type, receiver)
fun IrBuilderWithScope.irSetField(receiver: IrExpression?, field: IrField, value: IrExpression) =
- IrSetFieldImpl(startOffset, endOffset, field.symbol, receiver, value, context.irBuiltIns.unitType)
+ IrSetFieldImpl(startOffset, endOffset, field, receiver, value, context.irBuiltIns.unitType)
-fun IrBuilderWithScope.irGetObjectValue(type: IrType, classSymbol: IrClassSymbol) =
- IrGetObjectValueImpl(startOffset, endOffset, type, classSymbol)
+fun IrBuilderWithScope.irGetObjectValue(type: IrType, klass: IrClass) =
+ IrGetObjectValueImpl(startOffset, endOffset, type, klass)
fun IrBuilderWithScope.irEqeqeq(arg1: IrExpression, arg2: IrExpression) =
context.eqeqeq(startOffset, endOffset, arg1, arg2)
@@ -191,26 +190,26 @@
irEquals(arg1, arg2, origin = IrStatementOrigin.EXCLEQ)
)
-fun IrBuilderWithScope.irGet(type: IrType, receiver: IrExpression?, getterSymbol: IrFunctionSymbol): IrCall =
+fun IrBuilderWithScope.irGet(type: IrType, receiver: IrExpression?, getter: IrFunction): IrCall =
IrCallImpl(
startOffset, endOffset,
type,
- getterSymbol as IrSimpleFunctionSymbol,
- getterSymbol.descriptor,
- typeArgumentsCount = getterSymbol.owner.typeParameters.size,
+ getter as IrSimpleFunction,
+ getter.descriptor,
+ typeArgumentsCount = getter.typeParameters.size,
valueArgumentsCount = 0,
origin = IrStatementOrigin.GET_PROPERTY
).apply {
dispatchReceiver = receiver
}
-fun IrBuilderWithScope.irSet(type: IrType, receiver: IrExpression?, setterSymbol: IrFunctionSymbol, value: IrExpression): IrCall =
+fun IrBuilderWithScope.irSet(type: IrType, receiver: IrExpression?, setter: IrFunction, value: IrExpression): IrCall =
IrCallImpl(
startOffset, endOffset,
type,
- setterSymbol as IrSimpleFunctionSymbol,
- setterSymbol.descriptor,
- typeArgumentsCount = setterSymbol.owner.typeParameters.size,
+ setter as IrSimpleFunction,
+ setter.descriptor,
+ typeArgumentsCount = setter.typeParameters.size,
valueArgumentsCount = 1,
origin = IrStatementOrigin.EQ
).apply {
@@ -219,7 +218,7 @@
}
fun IrBuilderWithScope.irCall(
- callee: IrFunctionSymbol,
+ callee: IrFunction,
type: IrType,
typeArguments: List<IrType>
): IrMemberAccessExpression =
@@ -229,11 +228,11 @@
}
}
-fun IrBuilderWithScope.irCallConstructor(callee: IrConstructorSymbol, typeArguments: List<IrType>): IrConstructorCall =
+fun IrBuilderWithScope.irCallConstructor(callee: IrConstructor, typeArguments: List<IrType>): IrConstructorCall =
IrConstructorCallImpl.fromSymbolOwner(
startOffset,
endOffset,
- callee.owner.returnType,
+ callee.returnType,
callee
).apply {
typeArguments.forEachIndexed { index, irType ->
@@ -241,49 +240,46 @@
}
}
-fun IrBuilderWithScope.irCall(callee: IrSimpleFunctionSymbol, type: IrType): IrCall =
+fun IrBuilderWithScope.irCall(callee: IrSimpleFunction, type: IrType): IrCall =
IrCallImpl(startOffset, endOffset, type, callee, callee.descriptor)
-fun IrBuilderWithScope.irCall(callee: IrConstructorSymbol, type: IrType): IrConstructorCall =
+fun IrBuilderWithScope.irCall(callee: IrConstructor, type: IrType): IrConstructorCall =
IrConstructorCallImpl.fromSymbolDescriptor(startOffset, endOffset, type, callee)
-fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol, type: IrType): IrFunctionAccessExpression =
+fun IrBuilderWithScope.irCall(callee: IrFunction, type: IrType): IrFunctionAccessExpression =
when (callee) {
- is IrConstructorSymbol -> irCall(callee, type)
- is IrSimpleFunctionSymbol -> irCall(callee, type)
+ is IrConstructor -> irCall(callee, type)
+ is IrSimpleFunction -> irCall(callee, type)
else -> throw AssertionError("Unexpected callee: $callee")
}
-fun IrBuilderWithScope.irCall(callee: IrSimpleFunctionSymbol): IrCall =
- irCall(callee, callee.owner.returnType)
+fun IrBuilderWithScope.irCall(callee: IrSimpleFunction): IrCall =
+ irCall(callee, callee.returnType)
-fun IrBuilderWithScope.irCall(callee: IrConstructorSymbol): IrConstructorCall =
- irCall(callee, callee.owner.returnType)
-
-fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol): IrFunctionAccessExpression =
- irCall(callee, callee.owner.returnType)
-
-fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol, descriptor: FunctionDescriptor, type: IrType): IrCall =
- IrCallImpl(startOffset, endOffset, type, callee as IrSimpleFunctionSymbol, descriptor)
+fun IrBuilderWithScope.irCall(callee: IrConstructor): IrConstructorCall =
+ irCall(callee, callee.returnType)
fun IrBuilderWithScope.irCall(callee: IrFunction): IrFunctionAccessExpression =
- irCall(callee.symbol)
+ irCall(callee, callee.returnType)
+
+fun IrBuilderWithScope.irCall(callee: IrFunction, descriptor: FunctionDescriptor, type: IrType): IrCall =
+ IrCallImpl(startOffset, endOffset, type, callee as IrSimpleFunction, descriptor)
fun IrBuilderWithScope.irCall(callee: IrFunction, origin: IrStatementOrigin): IrCall =
IrCallImpl(
startOffset, endOffset, callee.returnType,
- callee.symbol as IrSimpleFunctionSymbol,
+ callee as IrSimpleFunction,
callee.descriptor, origin
)
fun IrBuilderWithScope.irDelegatingConstructorCall(callee: IrConstructor): IrDelegatingConstructorCall =
IrDelegatingConstructorCallImpl(
- startOffset, endOffset, context.irBuiltIns.unitType, callee.symbol, callee.descriptor,
+ startOffset, endOffset, context.irBuiltIns.unitType, callee, callee.descriptor,
callee.parentAsClass.typeParameters.size, callee.valueParameters.size
)
fun IrBuilderWithScope.irCallOp(
- callee: IrFunctionSymbol,
+ callee: IrFunction,
type: IrType,
dispatchReceiver: IrExpression,
argument: IrExpression? = null
@@ -334,7 +330,7 @@
IrSetFieldImpl(
startOffset,
endOffset,
- irField.symbol,
+ irField,
receiver = receiver,
value = value,
type = context.irBuiltIns.unitType
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Scope.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Scope.kt
index 01cf3cc..e377feb 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Scope.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Scope.kt
@@ -18,10 +18,7 @@
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
-import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
import org.jetbrains.kotlin.ir.descriptors.IrTemporaryVariableDescriptor
import org.jetbrains.kotlin.ir.descriptors.IrTemporaryVariableDescriptorImpl
@@ -34,16 +31,15 @@
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.types.KotlinType
-class Scope(val scopeOwnerSymbol: IrSymbol) {
- val scopeOwner: DeclarationDescriptor get() = scopeOwnerSymbol.descriptor
+class Scope(val irScopeOwner: IrSymbolOwner) {
+ val scopeOwner: DeclarationDescriptor get() = irScopeOwner.symbol.descriptor
fun getLocalDeclarationParent(): IrDeclarationParent {
- if (!scopeOwnerSymbol.isBound) throw AssertionError("Unbound symbol: $scopeOwner")
- val scopeOwnerElement = scopeOwnerSymbol.owner
- return when (scopeOwnerElement) {
- is IrDeclarationParent -> scopeOwnerElement
- !is IrDeclaration -> throw AssertionError("Not a declaration: $scopeOwnerElement")
- else -> scopeOwnerElement.parent
+ if (!irScopeOwner.symbol.isBound) throw AssertionError("Unbound symbol: $scopeOwner")
+ return when (irScopeOwner) {
+ is IrDeclarationParent -> irScopeOwner
+ !is IrDeclaration -> throw AssertionError("Not a declaration: $irScopeOwner")
+ else -> irScopeOwner.parent
}
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt
index 285ccae..c1ee57e 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt
@@ -24,7 +24,7 @@
import org.jetbrains.kotlin.ir.types.IrType
interface IrClass :
- IrSymbolDeclaration<IrClassSymbol>, IrDeclarationWithName, IrDeclarationWithVisibility,
+ IrSymbolDeclaration<IrClassSymbol>, IrDeclarationWithName, IrDeclarationWithVisibility, IrClassifier,
IrDeclarationContainer, IrTypeParametersContainer, IrAttributeContainer {
override val descriptor: ClassDescriptor
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClassifier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClassifier.kt
new file mode 100644
index 0000000..d01bbbb
--- /dev/null
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClassifier.kt
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.declarations
+
+import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
+import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
+import org.jetbrains.kotlin.types.model.TypeConstructorMarker
+
+interface IrClassifier : IrDeclaration, IrSymbolOwner, TypeConstructorMarker {
+ override val symbol: IrClassifierSymbol
+ override val descriptor: ClassifierDescriptor
+}
\ No newline at end of file
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclaration.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclaration.kt
index d308113..332e5fd 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclaration.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclaration.kt
@@ -46,8 +46,8 @@
override val symbol: S
}
-interface IrOverridableDeclaration<S : IrSymbol> : IrDeclaration {
- val overriddenSymbols: MutableList<S>
+interface IrOverridableDeclaration<S : IrDeclaration> : IrDeclaration {
+ val overridden: MutableList<S>
}
interface IrDeclarationWithVisibility : IrDeclaration {
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrField.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrField.kt
index 4232a87..af29556 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrField.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrField.kt
@@ -12,7 +12,7 @@
import org.jetbrains.kotlin.ir.types.IrType
interface IrField :
- IrSymbolDeclaration<IrFieldSymbol>, IrOverridableDeclaration<IrFieldSymbol>,
+ IrSymbolDeclaration<IrFieldSymbol>, IrOverridableDeclaration<IrField>,
IrDeclarationWithName, IrDeclarationWithVisibility, IrDeclarationParent {
override val descriptor: PropertyDescriptor
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrSimpleFunction.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrSimpleFunction.kt
index 31bf00f..bd8985a 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrSimpleFunction.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrSimpleFunction.kt
@@ -23,7 +23,7 @@
interface IrSimpleFunction :
IrFunction,
IrSymbolDeclaration<IrSimpleFunctionSymbol>,
- IrOverridableDeclaration<IrSimpleFunctionSymbol> {
+ IrOverridableDeclaration<IrSimpleFunction> {
val modality: Modality
val isTailrec: Boolean
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeParameter.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeParameter.kt
index f13063b..d2f4b26 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeParameter.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeParameter.kt
@@ -21,8 +21,11 @@
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.model.TypeConstructorMarker
+import org.jetbrains.kotlin.types.model.TypeParameterMarker
-interface IrTypeParameter : IrSymbolDeclaration<IrTypeParameterSymbol>, IrDeclarationWithName {
+interface IrTypeParameter : IrSymbolDeclaration<IrTypeParameterSymbol>, IrDeclarationWithName, IrClassifier,
+ TypeParameterMarker {
override val descriptor: TypeParameterDescriptor
val variance: Variance
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt
index f5ff028..3462eef 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt
@@ -89,7 +89,7 @@
correspondingProperty = value?.owner
}
- override val overriddenSymbols: MutableList<IrFieldSymbol> = mutableListOf()
+ override val overridden: MutableList<IrField> = mutableListOf()
override var metadata: MetadataSource.Property? = null
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt
index 2515e51..9bac52c 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt
@@ -58,7 +58,7 @@
override val descriptor: FunctionDescriptor = symbol.descriptor
- override val overriddenSymbols: MutableList<IrSimpleFunctionSymbol> = SmartList()
+ override val overridden: MutableList<IrSimpleFunction> = SmartList()
override var correspondingProperty: IrProperty? = null
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt
index 49ab59e..8828bd7 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt
@@ -65,9 +65,9 @@
override val descriptor: PropertyDescriptor = symbol.descriptor
- override val overriddenSymbols: MutableList<IrFieldSymbol> by lazy {
+ override val overridden: MutableList<IrField> by lazy {
symbol.descriptor.overriddenDescriptors.map {
- stubGenerator.generateFieldStub(it.original).symbol
+ stubGenerator.generateFieldStub(it.original)
}.toMutableList()
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt
index 816a6d2..b8693ec 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt
@@ -79,9 +79,9 @@
}
- override val overriddenSymbols: MutableList<IrSimpleFunctionSymbol> by lazy {
+ override val overridden: MutableList<IrSimpleFunction> by lazy {
descriptor.overriddenDescriptors.mapTo(arrayListOf()) {
- stubGenerator.generateFunctionStub(it.original).symbol
+ stubGenerator.generateFunctionStub(it.original)
}
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBlock.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBlock.kt
index a2640e6..0a55847 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBlock.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBlock.kt
@@ -16,11 +16,11 @@
package org.jetbrains.kotlin.ir.expressions
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrReturnTarget
import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
import org.jetbrains.kotlin.ir.declarations.name
import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
import org.jetbrains.kotlin.ir.util.file
@@ -41,11 +41,11 @@
interface IrReturnableBlock : IrBlock, IrSymbolOwner, IrReturnTarget {
override val symbol: IrReturnableBlockSymbol
- val inlineFunctionSymbol: IrFunctionSymbol?
+ val inlineFunction: IrFunction?
}
val IrReturnableBlock.sourceFileSymbol: IrFileSymbol?
- get() = inlineFunctionSymbol?.owner?.file?.symbol
+ get() = inlineFunction?.file?.symbol
@Deprecated("Please avoid using it")
val IrReturnableBlock.sourceFileName: String
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCall.kt
index a042b3d..6f6b378 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCall.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCall.kt
@@ -17,9 +17,9 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.declarations.IrClass
interface IrCall : IrFunctionAccessExpression {
val superQualifier: ClassDescriptor?
- val superQualifierSymbol: IrClassSymbol?
+ val irSuperQualifier: IrClass?
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt
index 221406d..5de2375 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt
@@ -20,7 +20,7 @@
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
-import org.jetbrains.kotlin.ir.symbols.*
+import org.jetbrains.kotlin.ir.declarations.*
interface IrCallableReference : IrMemberAccessExpression, IrDeclarationReference {
override val descriptor: CallableDescriptor
@@ -28,21 +28,21 @@
interface IrFunctionReference : IrCallableReference {
override val descriptor: FunctionDescriptor
- override val symbol: IrFunctionSymbol
+ override val target: IrFunction
}
interface IrPropertyReference : IrCallableReference {
override val descriptor: PropertyDescriptor
- override val symbol: IrPropertySymbol
- val field: IrFieldSymbol?
- val getter: IrSimpleFunctionSymbol?
- val setter: IrSimpleFunctionSymbol?
+ override val target: IrProperty
+ val field: IrField?
+ val getter: IrSimpleFunction?
+ val setter: IrSimpleFunction?
}
interface IrLocalDelegatedPropertyReference : IrCallableReference {
override val descriptor: VariableDescriptorWithAccessors
- override val symbol: IrLocalDelegatedPropertySymbol
- val delegate: IrVariableSymbol
- val getter: IrSimpleFunctionSymbol
- val setter: IrSimpleFunctionSymbol?
+ override val target: IrLocalDelegatedProperty
+ val delegate: IrVariable
+ val getter: IrSimpleFunction
+ val setter: IrSimpleFunction?
}
\ No newline at end of file
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrClassReference.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrClassReference.kt
index 3ea1ba7..c73027a 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrClassReference.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrClassReference.kt
@@ -17,13 +17,13 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
+import org.jetbrains.kotlin.ir.declarations.IrClassifier
import org.jetbrains.kotlin.ir.types.IrType
interface IrClassReference : IrDeclarationReference {
override val descriptor: ClassifierDescriptor
- override val symbol: IrClassifierSymbol
+ override val target: IrClassifier
val classType: IrType
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConstructorCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConstructorCall.kt
index 646b97f..30ff176 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConstructorCall.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConstructorCall.kt
@@ -6,12 +6,12 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.types.IrType
interface IrConstructorCall : IrFunctionAccessExpression {
override val descriptor: ClassConstructorDescriptor
- override val symbol: IrConstructorSymbol
+ override val target: IrConstructor
val constructorTypeArgumentsCount: Int
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDeclarationReference.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDeclarationReference.kt
index e483d10..0ed3128 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDeclarationReference.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDeclarationReference.kt
@@ -18,14 +18,13 @@
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
-
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
interface IrDeclarationReference : IrExpression {
val descriptor: DeclarationDescriptor
- val symbol: IrSymbol
+ val target: IrSymbolOwner
}
interface IrGetSingletonValue : IrDeclarationReference {
@@ -33,10 +32,10 @@
}
interface IrGetObjectValue : IrGetSingletonValue {
- override val symbol: IrClassSymbol
+ override val target: IrClass
}
interface IrGetEnumValue : IrGetSingletonValue {
- override val symbol: IrEnumEntrySymbol
+ override val target: IrEnumEntry
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDelegatingConstructorCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDelegatingConstructorCall.kt
index 66dacc6..3c50356 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDelegatingConstructorCall.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDelegatingConstructorCall.kt
@@ -17,10 +17,10 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
interface IrDelegatingConstructorCall : IrFunctionAccessExpression {
override val descriptor: ClassConstructorDescriptor
- override val symbol: IrConstructorSymbol
+ override val target: IrConstructor
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrEnumConstructorCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrEnumConstructorCall.kt
index b9a7d3d..6e7c427 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrEnumConstructorCall.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrEnumConstructorCall.kt
@@ -17,10 +17,10 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
interface IrEnumConstructorCall : IrFunctionAccessExpression {
override val descriptor: ClassConstructorDescriptor
- override val symbol: IrConstructorSymbol
+ override val target: IrConstructor
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrFieldAccessExpression.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrFieldAccessExpression.kt
index d5c85e0..72715aa 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrFieldAccessExpression.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrFieldAccessExpression.kt
@@ -18,15 +18,15 @@
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrField
interface IrFieldAccessExpression : IrDeclarationReference {
override val descriptor: PropertyDescriptor
- override val symbol: IrFieldSymbol
+ override val target: IrField
val superQualifier: ClassDescriptor?
- val superQualifierSymbol: IrClassSymbol?
+ val irSuperQualifier: IrClass?
var receiver: IrExpression?
val origin: IrStatementOrigin?
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInstanceInitializerCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInstanceInitializerCall.kt
index 02c1d4b..ecd8bf1 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInstanceInitializerCall.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInstanceInitializerCall.kt
@@ -17,10 +17,10 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.declarations.IrClass
interface IrInstanceInitializerCall : IrExpression {
val classDescriptor: ClassDescriptor
- val classSymbol: IrClassSymbol
+ val irClass: IrClass
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt
index 0c0d6fe..c56f33cb 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt
@@ -9,12 +9,8 @@
import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrValueParameter
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.defaultType
-import org.jetbrains.kotlin.ir.types.toKotlinType
-import org.jetbrains.kotlin.ir.util.dump
-import org.jetbrains.kotlin.ir.util.render
import org.jetbrains.kotlin.types.KotlinType
interface IrMemberAccessExpression : IrExpression {
@@ -44,6 +40,14 @@
for (i in 0 until typeArgumentsCount) {
putTypeArgument(i, other.getTypeArgument(i))
}
+ if (this is IrConstructorCall && other is IrConstructorCall) {
+ assert(constructorTypeArgumentsCount == other.constructorTypeArgumentsCount) {
+ "Mismatching constructor type arguments: $constructorTypeArgumentsCount vs ${other.constructorTypeArgumentsCount} "
+ }
+ for (i in 0 until constructorTypeArgumentsCount) {
+ putConstructorTypeArgument(i, other.getConstructorTypeArgument(i))
+ }
+ }
}
inline fun IrMemberAccessExpression.putTypeArguments(
@@ -68,7 +72,7 @@
interface IrFunctionAccessExpression : IrMemberAccessExpression, IrDeclarationReference {
override val descriptor: FunctionDescriptor
- override val symbol: IrFunctionSymbol
+ override val target: IrFunction
}
fun IrMemberAccessExpression.getValueArgument(valueParameterDescriptor: ValueParameterDescriptor) =
@@ -111,4 +115,4 @@
}
fun IrFunctionAccessExpression.putArgument(parameter: IrValueParameter, argument: IrExpression) =
- putArgument(symbol.owner, parameter, argument)
+ putArgument(target, parameter, argument)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrReturn.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrReturn.kt
index adae088..de079e0 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrReturn.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrReturn.kt
@@ -17,12 +17,11 @@
package org.jetbrains.kotlin.ir.expressions
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
-
+import org.jetbrains.kotlin.ir.declarations.IrReturnTarget
interface IrReturn : IrExpression {
var value: IrExpression
val returnTarget: FunctionDescriptor
- val returnTargetSymbol: IrReturnTargetSymbol
+ val irReturnTarget: IrReturnTarget
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrValueAccessExpression.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrValueAccessExpression.kt
index 6cc37c7..58cb1fb 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrValueAccessExpression.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrValueAccessExpression.kt
@@ -18,12 +18,12 @@
import org.jetbrains.kotlin.descriptors.ValueDescriptor
import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
+import org.jetbrains.kotlin.ir.declarations.IrValueDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrVariable
interface IrValueAccessExpression : IrDeclarationReference {
override val descriptor: ValueDescriptor
- override val symbol: IrValueSymbol
+ override val target: IrValueDeclaration
val origin: IrStatementOrigin?
}
@@ -33,7 +33,7 @@
interface IrSetVariable : IrValueAccessExpression {
override val descriptor: VariableDescriptor
- override val symbol: IrVariableSymbol
+ override val target: IrVariable
var value: IrExpression
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt
index b11f476..2b924b3 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt
@@ -16,14 +16,12 @@
package org.jetbrains.kotlin.ir.expressions.impl
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.ir.IrStatement
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.expressions.IrBlock
import org.jetbrains.kotlin.ir.expressions.IrReturnableBlock
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
-import org.jetbrains.kotlin.ir.symbols.impl.IrReturnableBlockSymbolImpl
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -70,7 +68,7 @@
type: IrType,
override val symbol: IrReturnableBlockSymbol,
origin: IrStatementOrigin? = null,
- override val inlineFunctionSymbol: IrFunctionSymbol? = null
+ override val inlineFunction: IrFunction? = null
) :
IrContainerExpressionBase(startOffset, endOffset, type, origin),
IrReturnableBlock {
@@ -84,8 +82,8 @@
symbol: IrReturnableBlockSymbol,
origin: IrStatementOrigin?,
statements: List<IrStatement>,
- inlineFunctionSymbol: IrFunctionSymbol? = null
- ) : this(startOffset, endOffset, type, symbol, origin, inlineFunctionSymbol) {
+ inlineFunction: IrFunction? = null
+ ) : this(startOffset, endOffset, type, symbol, origin, inlineFunction) {
this.statements.addAll(statements)
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt
index 98b94c1..5788699 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt
@@ -19,11 +19,11 @@
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
import org.jetbrains.kotlin.ir.expressions.typeParametersCount
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -31,12 +31,12 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrFunctionSymbol,
+ override val target: IrFunction,
override val descriptor: FunctionDescriptor,
typeArgumentsCount: Int,
valueArgumentsCount: Int,
origin: IrStatementOrigin? = null,
- override val superQualifierSymbol: IrClassSymbol? = null
+ override val irSuperQualifier: IrClass? = null
) :
IrCallWithIndexedArgumentsBase(
startOffset, endOffset, type,
@@ -56,34 +56,34 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrFunctionSymbol,
+ target: IrFunction,
descriptor: FunctionDescriptor,
origin: IrStatementOrigin? = null,
- superQualifierSymbol: IrClassSymbol? = null
+ irSuperQualifier: IrClass? = null
) : this(
- startOffset, endOffset, type, symbol, descriptor, descriptor.typeParametersCount,
- descriptor.valueParameters.size, origin, superQualifierSymbol
+ startOffset, endOffset, type, target, descriptor, descriptor.typeParametersCount,
+ descriptor.valueParameters.size, origin, irSuperQualifier
)
constructor(
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrFunctionSymbol,
+ target: IrFunction,
descriptor: FunctionDescriptor,
typeArgumentsCount: Int,
origin: IrStatementOrigin? = null,
- superQualifierSymbol: IrClassSymbol? = null
+ irSuperQualifier: IrClass? = null
) : this(
- startOffset, endOffset, type, symbol, descriptor, typeArgumentsCount,
- descriptor.valueParameters.size, origin, superQualifierSymbol
+ startOffset, endOffset, type, target, descriptor, typeArgumentsCount,
+ descriptor.valueParameters.size, origin, irSuperQualifier
)
- constructor(startOffset: Int, endOffset: Int, type: IrType, symbol: IrFunctionSymbol) :
- this(startOffset, endOffset, type, symbol, symbol.descriptor)
+ constructor(startOffset: Int, endOffset: Int, type: IrType, target: IrFunction) :
+ this(startOffset, endOffset, type, target, target.descriptor)
- override val superQualifier: ClassDescriptor? = superQualifierSymbol?.descriptor
+ override val superQualifier: ClassDescriptor? = irSuperQualifier?.descriptor
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
visitor.visitCall(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrClassReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrClassReferenceImpl.kt
index cf126d7..65917cc 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrClassReferenceImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrClassReferenceImpl.kt
@@ -17,8 +17,9 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrClassifier
import org.jetbrains.kotlin.ir.expressions.IrClassReference
-import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -26,16 +27,16 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrClassifierSymbol,
+ target: IrClassifier,
override val classType: IrType
) :
- IrTerminalDeclarationReferenceBase<IrClassifierSymbol, ClassifierDescriptor>(
+ IrTerminalDeclarationReferenceBase<IrClassifier, ClassifierDescriptor>(
startOffset, endOffset, type,
- symbol, symbol.descriptor
+ target, target.descriptor
),
IrClassReference {
- override val descriptor: ClassifierDescriptor get() = symbol.descriptor
+ override val descriptor: ClassifierDescriptor get() = target.descriptor
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
visitor.visitClassReference(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt
index 8145db6..549576b 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt
@@ -7,9 +7,9 @@
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.util.parentAsClass
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -18,7 +18,7 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrConstructorSymbol,
+ override val target: IrConstructor,
override val descriptor: ClassConstructorDescriptor,
typeArgumentsCount: Int,
override val constructorTypeArgumentsCount: Int,
@@ -36,7 +36,7 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- constructorSymbol: IrConstructorSymbol,
+ target: IrConstructor,
constructorDescriptor: ClassConstructorDescriptor,
origin: IrStatementOrigin? = null
): IrConstructorCallImpl {
@@ -47,7 +47,7 @@
return IrConstructorCallImpl(
startOffset, endOffset,
type,
- constructorSymbol,
+ target,
constructorDescriptor,
totalTypeParametersCount,
totalTypeParametersCount - classTypeParametersCount,
@@ -60,30 +60,29 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- constructorSymbol: IrConstructorSymbol,
+ target: IrConstructor,
origin: IrStatementOrigin? = null
): IrConstructorCallImpl =
- fromSubstitutedDescriptor(startOffset, endOffset, type, constructorSymbol, constructorSymbol.descriptor, origin)
+ fromSubstitutedDescriptor(startOffset, endOffset, type, target, target.descriptor, origin)
fun fromSymbolOwner(
startOffset: Int,
endOffset: Int,
type: IrType,
- constructorSymbol: IrConstructorSymbol,
+ target: IrConstructor,
origin: IrStatementOrigin? = null
): IrConstructorCallImpl {
- val constructor = constructorSymbol.owner
- val constructedClass = constructor.parentAsClass
+ val constructedClass = target.parentAsClass
val classTypeParametersCount = constructedClass.typeParameters.size
- val constructorTypeParametersCount = constructor.typeParameters.size
+ val constructorTypeParametersCount = target.typeParameters.size
val totalTypeParametersCount = classTypeParametersCount + constructorTypeParametersCount
- val valueParametersCount = constructor.valueParameters.size
+ val valueParametersCount = target.valueParameters.size
return IrConstructorCallImpl(
startOffset, endOffset,
type,
- constructorSymbol,
- constructorSymbol.descriptor,
+ target,
+ target.descriptor,
totalTypeParametersCount,
constructorTypeParametersCount,
valueParametersCount,
@@ -93,10 +92,10 @@
fun fromSymbolOwner(
type: IrType,
- constructorSymbol: IrConstructorSymbol,
+ target: IrConstructor,
origin: IrStatementOrigin? = null
) =
- fromSymbolOwner(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, constructorSymbol, origin)
+ fromSymbolOwner(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, target, origin)
}
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDeclarationReferenceBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDeclarationReferenceBase.kt
index c4de372..bcd9a1e 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDeclarationReferenceBase.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDeclarationReferenceBase.kt
@@ -17,15 +17,15 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.IrType
-abstract class IrDeclarationReferenceBase<out S : IrSymbol, out D : DeclarationDescriptor>(
+abstract class IrDeclarationReferenceBase<out S : IrSymbolOwner, out D : DeclarationDescriptor>(
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: S,
+ override val target: S,
override val descriptor: D
) :
IrExpressionBase(startOffset, endOffset, type),
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
index 001548b..dae93f1 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
@@ -17,9 +17,9 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
import org.jetbrains.kotlin.ir.expressions.typeParametersCount
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -27,7 +27,7 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrConstructorSymbol,
+ override val target: IrConstructor,
override val descriptor: ClassConstructorDescriptor,
typeArgumentsCount: Int,
valueArgumentsCount: Int
@@ -45,25 +45,25 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrConstructorSymbol,
+ target: IrConstructor,
descriptor: ClassConstructorDescriptor
- ) : this(startOffset, endOffset, type, symbol, descriptor, descriptor.typeParametersCount, descriptor.valueParameters.size)
+ ) : this(startOffset, endOffset, type, target, descriptor, descriptor.typeParametersCount, descriptor.valueParameters.size)
constructor(
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrConstructorSymbol
- ) : this(startOffset, endOffset, type, symbol, symbol.descriptor)
+ target: IrConstructor
+ ) : this(startOffset, endOffset, type, target, target.descriptor)
constructor(
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrConstructorSymbol,
+ target: IrConstructor,
descriptor: ClassConstructorDescriptor,
typeArgumentsCount: Int
- ) : this(startOffset, endOffset, type, symbol, descriptor, typeArgumentsCount, descriptor.valueParameters.size)
+ ) : this(startOffset, endOffset, type, target, descriptor, typeArgumentsCount, descriptor.valueParameters.size)
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
return visitor.visitDelegatingConstructorCall(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt
index ba7c70d..439c60e 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt
@@ -17,9 +17,9 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
import org.jetbrains.kotlin.ir.expressions.typeParametersCount
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -27,7 +27,7 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrConstructorSymbol,
+ override val target: IrConstructor,
typeArgumentsCount: Int,
valueArgumentsCount: Int
) :
@@ -44,18 +44,18 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrConstructorSymbol
- ) : this(startOffset, endOffset, type, symbol, symbol.descriptor.typeParametersCount, symbol.descriptor.valueParameters.size)
+ target: IrConstructor
+ ) : this(startOffset, endOffset, type, target, target.descriptor.typeParametersCount, target.descriptor.valueParameters.size)
constructor(
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrConstructorSymbol,
+ target: IrConstructor,
typeArgumentsCount: Int
- ) : this(startOffset, endOffset, type, symbol, typeArgumentsCount, symbol.descriptor.valueParameters.size)
+ ) : this(startOffset, endOffset, type, target, typeArgumentsCount, target.descriptor.valueParameters.size)
- override val descriptor: ClassConstructorDescriptor get() = symbol.descriptor
+ override val descriptor: ClassConstructorDescriptor get() = target.descriptor
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
return visitor.visitEnumConstructorCall(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFieldExpressionBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFieldExpressionBase.kt
index 7800d7a..70d91fa 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFieldExpressionBase.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFieldExpressionBase.kt
@@ -18,25 +18,25 @@
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
import org.jetbrains.kotlin.ir.types.IrType
abstract class IrFieldExpressionBase(
startOffset: Int, endOffset: Int,
- override val symbol: IrFieldSymbol,
+ override val target: IrField,
type: IrType,
override val origin: IrStatementOrigin? = null,
- override val superQualifierSymbol: IrClassSymbol?
+ override val irSuperQualifier: IrClass?
) :
IrExpressionBase(startOffset, endOffset, type),
IrFieldAccessExpression {
- override val descriptor: PropertyDescriptor get() = symbol.descriptor
- override val superQualifier: ClassDescriptor? get() = superQualifierSymbol?.descriptor
+ override val descriptor: PropertyDescriptor get() = target.descriptor
+ override val superQualifier: ClassDescriptor? get() = irSuperQualifier?.descriptor
final override var receiver: IrExpression? = null
}
\ No newline at end of file
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt
index 9af008f..797c469 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt
@@ -17,9 +17,9 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -27,7 +27,7 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrFunctionSymbol,
+ override val target: IrFunction,
override val descriptor: FunctionDescriptor,
typeArgumentsCount: Int,
valueArgumentsCount: Int,
@@ -47,11 +47,11 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrFunctionSymbol,
+ target: IrFunction,
descriptor: FunctionDescriptor,
typeArgumentsCount: Int,
origin: IrStatementOrigin? = null
- ) : this(startOffset, endOffset, type, symbol, descriptor, typeArgumentsCount, descriptor.valueParameters.size, origin)
+ ) : this(startOffset, endOffset, type, target, descriptor, typeArgumentsCount, descriptor.valueParameters.size, origin)
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
visitor.visitFunctionReference(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetEnumValueImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetEnumValueImpl.kt
index 359e3ed..2535abc 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetEnumValueImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetEnumValueImpl.kt
@@ -17,8 +17,8 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
-import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -26,9 +26,9 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrEnumEntrySymbol
+ target: IrEnumEntry
) :
- IrTerminalDeclarationReferenceBase<IrEnumEntrySymbol, ClassDescriptor>(startOffset, endOffset, type, symbol, symbol.descriptor),
+ IrTerminalDeclarationReferenceBase<IrEnumEntry, ClassDescriptor>(startOffset, endOffset, type, target, target.descriptor),
IrGetEnumValue {
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetFieldImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetFieldImpl.kt
index 7a4edd9..05d437d 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetFieldImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetFieldImpl.kt
@@ -16,11 +16,11 @@
package org.jetbrains.kotlin.ir.expressions.impl
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrGetField
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -28,22 +28,22 @@
class IrGetFieldImpl(
startOffset: Int,
endOffset: Int,
- symbol: IrFieldSymbol,
+ target: IrField,
type: IrType,
origin: IrStatementOrigin? = null,
- superQualifierSymbol: IrClassSymbol? = null
+ irSuperQualifier: IrClass? = null
) :
- IrFieldExpressionBase(startOffset, endOffset, symbol, type, origin, superQualifierSymbol),
+ IrFieldExpressionBase(startOffset, endOffset, target, type, origin, irSuperQualifier),
IrGetField {
constructor(
startOffset: Int, endOffset: Int,
- symbol: IrFieldSymbol,
+ target: IrField,
type: IrType,
receiver: IrExpression?,
origin: IrStatementOrigin? = null,
- superQualifierSymbol: IrClassSymbol? = null
- ) : this(startOffset, endOffset, symbol, type, origin, superQualifierSymbol) {
+ irSuperQualifier: IrClass? = null
+ ) : this(startOffset, endOffset, target, type, origin, irSuperQualifier) {
this.receiver = receiver
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetObjectValueImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetObjectValueImpl.kt
index 24f715a..d0b3f4c 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetObjectValueImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetObjectValueImpl.kt
@@ -17,8 +17,8 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -26,9 +26,9 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrClassSymbol
+ target: IrClass
) :
- IrTerminalDeclarationReferenceBase<IrClassSymbol, ClassDescriptor>(startOffset, endOffset, type, symbol, symbol.descriptor),
+ IrTerminalDeclarationReferenceBase<IrClass, ClassDescriptor>(startOffset, endOffset, type, target, target.descriptor),
IrGetObjectValue {
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetValueImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetValueImpl.kt
index 458c4ab..2ef1114 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetValueImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetValueImpl.kt
@@ -6,9 +6,9 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ValueDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrValueDeclaration
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -16,28 +16,28 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrValueSymbol,
+ target: IrValueDeclaration,
override val origin: IrStatementOrigin? = null
) :
- IrTerminalDeclarationReferenceBase<IrValueSymbol, ValueDescriptor>(
+ IrTerminalDeclarationReferenceBase<IrValueDeclaration, ValueDescriptor>(
startOffset,
endOffset,
type,
- symbol,
- symbol.descriptor
+ target,
+ target.descriptor
),
IrGetValue {
constructor(
startOffset: Int,
endOffset: Int,
- symbol: IrValueSymbol,
+ target: IrValueDeclaration,
origin: IrStatementOrigin? = null
- ) : this(startOffset, endOffset, symbol.owner.type, symbol, origin)
+ ) : this(startOffset, endOffset, target.type, target, origin)
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
visitor.visitGetValue(this, data)
override fun copy(): IrGetValue =
- IrGetValueImpl(startOffset, endOffset, type, symbol, origin)
+ IrGetValueImpl(startOffset, endOffset, type, target, origin)
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrInstanceInitializerCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrInstanceInitializerCallImpl.kt
index f25f014..09091b8 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrInstanceInitializerCallImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrInstanceInitializerCallImpl.kt
@@ -17,21 +17,21 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
class IrInstanceInitializerCallImpl(
startOffset: Int,
endOffset: Int,
- override val classSymbol: IrClassSymbol,
+ override val irClass: IrClass,
type: IrType
) :
IrTerminalExpressionBase(startOffset, endOffset, type),
IrInstanceInitializerCall {
- override val classDescriptor: ClassDescriptor get() = classSymbol.descriptor
+ override val classDescriptor: ClassDescriptor get() = irClass.descriptor
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
return visitor.visitInstanceInitializerCall(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt
index b3fd9e1..c82dbc5 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt
@@ -17,11 +17,11 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
+import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrLocalDelegatedPropertySymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -29,17 +29,17 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrLocalDelegatedPropertySymbol,
- override val delegate: IrVariableSymbol,
- override val getter: IrSimpleFunctionSymbol,
- override val setter: IrSimpleFunctionSymbol?,
+ override val target: IrLocalDelegatedProperty,
+ override val delegate: IrVariable,
+ override val getter: IrSimpleFunction,
+ override val setter: IrSimpleFunction?,
origin: IrStatementOrigin? = null
) :
IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, 0, origin),
IrLocalDelegatedPropertyReference {
override val descriptor: VariableDescriptorWithAccessors
- get() = symbol.descriptor
+ get() = target.descriptor
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
visitor.visitLocalDelegatedPropertyReference(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt
index 17cb397..cfd2b9e 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt
@@ -17,11 +17,11 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
-import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -30,12 +30,12 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrPropertySymbol,
+ override val target: IrProperty,
override val descriptor: PropertyDescriptor,
typeArgumentsCount: Int,
- override val field: IrFieldSymbol?,
- override val getter: IrSimpleFunctionSymbol?,
- override val setter: IrSimpleFunctionSymbol?,
+ override val field: IrField?,
+ override val getter: IrSimpleFunction?,
+ override val setter: IrSimpleFunction?,
origin: IrStatementOrigin? = null
) :
IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, typeArgumentsCount, origin),
@@ -45,15 +45,15 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrPropertySymbol,
+ target: IrProperty,
typeArgumentsCount: Int,
- field: IrFieldSymbol?,
- getter: IrSimpleFunctionSymbol?,
- setter: IrSimpleFunctionSymbol?,
+ field: IrField?,
+ getter: IrSimpleFunction?,
+ setter: IrSimpleFunction?,
origin: IrStatementOrigin? = null
) : this(
startOffset, endOffset, type,
- symbol, symbol.descriptor,
+ target, target.descriptor,
typeArgumentsCount, field, getter, setter, origin
)
@@ -64,9 +64,9 @@
type: IrType,
descriptor: PropertyDescriptor,
typeArgumentsCount: Int,
- field: IrFieldSymbol?,
- getter: IrSimpleFunctionSymbol?,
- setter: IrSimpleFunctionSymbol?,
+ field: IrField?,
+ getter: IrSimpleFunction?,
+ setter: IrSimpleFunction?,
origin: IrStatementOrigin? = null
) : this(
startOffset, endOffset, type,
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrReturnImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrReturnImpl.kt
index 04e669f..7214ae5 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrReturnImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrReturnImpl.kt
@@ -17,9 +17,9 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrReturnTarget
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrReturn
-import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -28,13 +28,13 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val returnTargetSymbol: IrReturnTargetSymbol,
+ override val irReturnTarget: IrReturnTarget,
override var value: IrExpression
) :
IrExpressionBase(startOffset, endOffset, type),
IrReturn {
- override val returnTarget: FunctionDescriptor get() = returnTargetSymbol.descriptor
+ override val returnTarget: FunctionDescriptor get() = irReturnTarget.descriptor
override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
visitor.visitReturn(this, data)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetFieldImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetFieldImpl.kt
index b3fe569..ec1fba5 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetFieldImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetFieldImpl.kt
@@ -16,11 +16,11 @@
package org.jetbrains.kotlin.ir.expressions.impl
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrField
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrSetField
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -28,29 +28,29 @@
class IrSetFieldImpl(
startOffset: Int,
endOffset: Int,
- symbol: IrFieldSymbol,
+ target: IrField,
type: IrType,
origin: IrStatementOrigin? = null,
- superQualifierSymbol: IrClassSymbol? = null
+ irSuperQualifier: IrClass? = null
) :
IrFieldExpressionBase(
startOffset, endOffset,
- symbol,
+ target,
type,
origin,
- superQualifierSymbol
+ irSuperQualifier
),
IrSetField {
constructor(
startOffset: Int, endOffset: Int,
- symbol: IrFieldSymbol,
+ target: IrField,
receiver: IrExpression?,
value: IrExpression,
type: IrType,
origin: IrStatementOrigin? = null,
- superQualifierSymbol: IrClassSymbol? = null
- ) : this(startOffset, endOffset, symbol, type, origin, superQualifierSymbol) {
+ irSuperQualifier: IrClass? = null
+ ) : this(startOffset, endOffset, target, type, origin, irSuperQualifier) {
this.receiver = receiver
this.value = value
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetVariableImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetVariableImpl.kt
index ec1ae7f..f0ef2cf3 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetVariableImpl.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetVariableImpl.kt
@@ -17,10 +17,10 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrSetVariable
import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -29,7 +29,7 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- override val symbol: IrVariableSymbol,
+ override val target: IrVariable,
override val origin: IrStatementOrigin?
) :
IrExpressionBase(startOffset, endOffset, type),
@@ -39,14 +39,14 @@
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: IrVariableSymbol,
+ target: IrVariable,
value: IrExpression,
origin: IrStatementOrigin?
- ) : this(startOffset, endOffset, type, symbol, origin) {
+ ) : this(startOffset, endOffset, type, target, origin) {
this.value = value
}
- override val descriptor: VariableDescriptor get() = symbol.descriptor
+ override val descriptor: VariableDescriptor get() = target.descriptor
override lateinit var value: IrExpression
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalDeclarationReferenceBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalDeclarationReferenceBase.kt
index cded755..5b05185 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalDeclarationReferenceBase.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalDeclarationReferenceBase.kt
@@ -17,20 +17,20 @@
package org.jetbrains.kotlin.ir.expressions.impl
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
-abstract class IrTerminalDeclarationReferenceBase<out S : IrSymbol, out D : DeclarationDescriptor>(
+abstract class IrTerminalDeclarationReferenceBase<out S : IrSymbolOwner, out D : DeclarationDescriptor>(
startOffset: Int,
endOffset: Int,
type: IrType,
- symbol: S,
+ target: S,
descriptor: D
) :
- IrDeclarationReferenceBase<S, D>(startOffset, endOffset, type, symbol, descriptor),
+ IrDeclarationReferenceBase<S, D>(startOffset, endOffset, type, target, descriptor),
IrDeclarationReference {
override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt
index db4ca1c..13cedf4 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt
@@ -21,7 +21,6 @@
import org.jetbrains.kotlin.ir.expressions.IrReturnableBlock
import org.jetbrains.kotlin.ir.util.IrSymbolVisitor
import org.jetbrains.kotlin.types.model.TypeConstructorMarker
-import org.jetbrains.kotlin.types.model.TypeParameterMarker
interface IrSymbol : IrSymbolOwner {
val owner: IrSymbolOwner
@@ -86,9 +85,11 @@
}
interface IrClassifierSymbol :
- IrSymbol, TypeConstructorMarker {
+ IrSymbol, TypeConstructorMarker,
+ IrClassifier {
override val descriptor: ClassifierDescriptor
+ override val owner: IrClassifier
override fun <D, R> accept(visitor: IrSymbolVisitor<R, D>, data: D): R =
visitor.visitClassifierSymbol(this, data)
@@ -103,7 +104,7 @@
}
interface IrTypeParameterSymbol :
- IrClassifierSymbol, IrBindableSymbol<TypeParameterDescriptor, IrTypeParameter>, TypeParameterMarker,
+ IrClassifierSymbol, IrBindableSymbol<TypeParameterDescriptor, IrTypeParameter>,
IrTypeParameter {
override fun <D, R> accept(visitor: IrSymbolVisitor<R, D>, data: D): R =
@@ -111,7 +112,7 @@
}
interface IrValueSymbol :
- IrSymbol {
+ IrSymbol, IrValueDeclaration {
override val descriptor: ValueDescriptor
override val owner: IrValueDeclaration
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt
index a38f3cb..3a26e37 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt
@@ -97,7 +97,7 @@
class IrAnonymousInitializerSymbolImpl(descriptor: ClassDescriptor) :
IrBindableSymbolBase<ClassDescriptor, IrAnonymousInitializer>(descriptor),
IrAnonymousInitializerSymbol, IrAnonymousInitializer {
- constructor(irClassSymbol: IrClassSymbol) : this(irClassSymbol.descriptor) {}
+ constructor(irClass: IrClass) : this(irClass.descriptor) {}
override val symbol get() = this
override val startOffset get() = owner.startOffset
override val endOffset get() = owner.endOffset
@@ -181,7 +181,7 @@
override val isFinal get() = owner.isFinal
override val isExternal get() = owner.isExternal
override val isStatic get() = owner.isStatic
- override val overriddenSymbols get() = owner.overriddenSymbols
+ override val overridden get() = owner.overridden
override val visibility get() = owner.visibility
override var parent get() = owner.parent; set(value) { owner.parent = value }
@@ -281,7 +281,7 @@
override val visibility get() = owner.visibility
override val typeParameters get() = owner.typeParameters
override val valueParameters get() = owner.valueParameters
- override val overriddenSymbols get() = owner.overriddenSymbols
+ override val overridden get() = owner.overridden
override val isTailrec get() = owner.isTailrec
override val isSuspend get() = owner.isSuspend
override val isInline get() = owner.isInline
@@ -338,7 +338,7 @@
override val startOffset get() = owner.startOffset
override val endOffset get() = owner.endOffset
override val type get() = owner.type
- override val inlineFunctionSymbol get() = owner.inlineFunctionSymbol
+ override val inlineFunction get() = owner.inlineFunction
override val statements get() = owner.statements
override val origin get() = owner.origin
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt
index 0e8db66..9cd6d77 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt
@@ -7,7 +7,6 @@
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibilities
@@ -97,37 +96,37 @@
private fun getTypeParameters(typeConstructor: TypeConstructorMarker): List<IrTypeParameter> {
return when (typeConstructor) {
- is IrTypeParameterSymbol -> emptyList()
- is IrClassSymbol -> typeConstructor.owner.typeParameters
+ is IrTypeParameter -> emptyList()
+ is IrClass -> typeConstructor.typeParameters
else -> error("unsupported type constructor")
}
}
override fun TypeConstructorMarker.parametersCount() = getTypeParameters(this).size
- override fun TypeConstructorMarker.getParameter(index: Int) = getTypeParameters(this)[index].symbol
+ override fun TypeConstructorMarker.getParameter(index: Int) = getTypeParameters(this)[index]
override fun TypeConstructorMarker.supertypes(): Collection<KotlinTypeMarker> {
return when (this) {
- is IrClassSymbol -> owner.superTypes
- is IrTypeParameterSymbol -> owner.superTypes
+ is IrClass -> superTypes
+ is IrTypeParameter -> superTypes
else -> error("unsupported type constructor")
}
}
override fun TypeConstructorMarker.isIntersection() = false
- override fun TypeConstructorMarker.isClassTypeConstructor() = this is IrClassSymbol
+ override fun TypeConstructorMarker.isClassTypeConstructor() = this is IrClass
- override fun TypeParameterMarker.getVariance() = (this as IrTypeParameterSymbol).owner.variance.convertVariance()
+ override fun TypeParameterMarker.getVariance() = (this as IrTypeParameter).variance.convertVariance()
- private fun getSuperTypes(typeParameterMarker: TypeParameterMarker) = (typeParameterMarker as IrTypeParameterSymbol).owner.superTypes
+ private fun getSuperTypes(typeParameterMarker: TypeParameterMarker) = (typeParameterMarker as IrTypeParameter).superTypes
override fun TypeParameterMarker.upperBoundCount() = getSuperTypes(this).size
override fun TypeParameterMarker.getUpperBound(index: Int) = getSuperTypes(this)[index] as KotlinTypeMarker
- override fun TypeParameterMarker.getTypeConstructor() = this as IrTypeParameterSymbol
+ override fun TypeParameterMarker.getTypeConstructor() = this as IrTypeParameter
override fun isEqualTypeConstructors(c1: TypeConstructorMarker, c2: TypeConstructorMarker) = FqNameEqualityChecker.areEqual(
c1 as IrClassifierSymbol, c2 as IrClassifierSymbol
@@ -136,8 +135,7 @@
override fun TypeConstructorMarker.isDenotable() = true
override fun TypeConstructorMarker.isCommonFinalClassConstructor(): Boolean {
- val classSymbol = this as? IrClassSymbol ?: return false
- return classSymbol.owner.run { modality == Modality.FINAL && kind != ClassKind.ENUM_CLASS && kind != ClassKind.ANNOTATION_CLASS }
+ return this is IrClass && modality == Modality.FINAL && kind != ClassKind.ENUM_CLASS && kind != ClassKind.ANNOTATION_CLASS
}
/*
@@ -191,10 +189,10 @@
override fun SimpleTypeMarker.asArgumentList() = this as IrSimpleType
override fun TypeConstructorMarker.isAnyConstructor(): Boolean =
- this is IrClassSymbol && isClassWithFqName(KotlinBuiltIns.FQ_NAMES.any)
+ this is IrClass && isClassWithFqName(KotlinBuiltIns.FQ_NAMES.any)
override fun TypeConstructorMarker.isNothingConstructor(): Boolean =
- this is IrClassSymbol && isClassWithFqName(KotlinBuiltIns.FQ_NAMES.nothing)
+ this is IrClass && isClassWithFqName(KotlinBuiltIns.FQ_NAMES.nothing)
override fun SimpleTypeMarker.isSingleClassifierType() = true
@@ -214,7 +212,7 @@
constructor: TypeConstructorMarker,
arguments: List<TypeArgumentMarker>,
nullable: Boolean
- ): SimpleTypeMarker = IrSimpleTypeImpl(constructor as IrClassifierSymbol, nullable, arguments.map { it as IrTypeArgument }, emptyList())
+ ): SimpleTypeMarker = IrSimpleTypeImpl((constructor as IrClassifier).symbol, nullable, arguments.map { it as IrTypeArgument }, emptyList())
private fun TypeVariance.convertVariance(): Variance {
return when (this) {
@@ -277,10 +275,7 @@
(this as IrType).isArray() || isNullableArray()
override fun TypeConstructorMarker.isFinalClassOrEnumEntryOrAnnotationClassConstructor(): Boolean {
- val symbol = this as IrClassifierSymbol
- return symbol is IrClassSymbol && symbol.owner.let {
- it.modality == Modality.FINAL && !it.isEnumClass
- }
+ return this is IrClass && modality == Modality.FINAL && !isEnumClass
}
override fun KotlinTypeMarker.hasAnnotation(fqName: FqName): Boolean =
@@ -290,22 +285,22 @@
override fun KotlinTypeMarker.getAnnotationFirstArgumentValue(fqName: FqName): Any? =
(this as? IrType)?.annotations?.firstOrNull { annotation ->
- annotation.symbol.owner.parentAsClass.descriptor.fqNameSafe == fqName
+ annotation.target.parentAsClass.descriptor.fqNameSafe == fqName
}?.run {
if (valueArgumentsCount > 0) (getValueArgument(0) as? IrConst<*>)?.value else null
}
override fun TypeConstructorMarker.getTypeParameterClassifier(): TypeParameterMarker? =
- this as? IrTypeParameterSymbol
+ this as? IrTypeParameter
override fun TypeConstructorMarker.isInlineClass(): Boolean =
- (this as? IrClassSymbol)?.owner?.isInline == true
+ (this as? IrClass)?.isInline == true
override fun TypeParameterMarker.getRepresentativeUpperBound(): KotlinTypeMarker =
- (this as IrTypeParameterSymbol).owner.superTypes.firstOrNull {
+ (this as IrTypeParameter).superTypes.firstOrNull {
val irClass = it.classOrNull?.owner ?: return@firstOrNull false
irClass.kind != ClassKind.INTERFACE && irClass.kind != ClassKind.ANNOTATION_CLASS
- } ?: owner.superTypes.first()
+ } ?: superTypes.first()
override fun KotlinTypeMarker.getSubstitutedUnderlyingType(): KotlinTypeMarker? {
// Code in inlineClassesUtils.kt loads the property with the same name from the scope of the substituted type and takes its type.
@@ -324,16 +319,16 @@
override fun TypeConstructorMarker.getPrimitiveType(): PrimitiveType? {
// TODO: get rid of descriptor
- return KotlinBuiltIns.getPrimitiveType((this as IrClassifierSymbol).descriptor as ClassDescriptor)
+ return KotlinBuiltIns.getPrimitiveType((this as IrClass).descriptor)
}
override fun TypeConstructorMarker.getPrimitiveArrayType(): PrimitiveType? {
// TODO: get rid of descriptor
- return KotlinBuiltIns.getPrimitiveArrayType((this as IrClassifierSymbol).descriptor as ClassDescriptor)
+ return KotlinBuiltIns.getPrimitiveArrayType((this as IrClass).descriptor)
}
override fun TypeConstructorMarker.isUnderKotlinPackage(): Boolean {
- var declaration: IrDeclaration = (this as? IrClassifierSymbol)?.owner as? IrClass ?: return false
+ var declaration: IrDeclaration = this as? IrClass ?: return false
while (true) {
val parent = declaration.parent
if (parent is IrPackageFragment) {
@@ -344,13 +339,13 @@
}
override fun TypeConstructorMarker.getClassFqNameUnsafe(): FqNameUnsafe? =
- (this as IrClassSymbol).owner.fqNameWhenAvailable?.toUnsafe()
+ (this as IrClass).fqNameWhenAvailable?.toUnsafe()
override fun TypeParameterMarker.getName(): Name =
- (this as IrTypeParameterSymbol).owner.name
+ (this as IrTypeParameter).name
override fun TypeParameterMarker.isReified(): Boolean =
- (this as IrTypeParameterSymbol).owner.isReified
+ (this as IrTypeParameter).isReified
override fun KotlinTypeMarker.isInterfaceOrAnnotationClass(): Boolean {
val irClass = (this as IrType).classOrNull?.owner
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt
index 6259f8e..6a2112a 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.ir.types
+import org.jetbrains.kotlin.ir.declarations.IrClass
import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
import org.jetbrains.kotlin.ir.symbols.FqNameEqualityChecker
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
@@ -22,12 +23,14 @@
else -> emptyList<IrType>()
}
-fun IrClassifierSymbol.isSubtypeOfClass(superClass: IrClassSymbol): Boolean {
- if (FqNameEqualityChecker.areEqual(this, superClass)) return true
+fun IrClass.isSubtypeOfClass(superClass: IrClass): Boolean = (symbol as IrClassifierSymbol).isSubtypeOfClass(superClass)
+
+fun IrClassifierSymbol.isSubtypeOfClass(superClass: IrClass): Boolean {
+ if (FqNameEqualityChecker.areEqual(this, superClass.symbol)) return true
return superTypes().any { it.isSubtypeOfClass(superClass) }
}
-fun IrType.isSubtypeOfClass(superClass: IrClassSymbol): Boolean {
+fun IrType.isSubtypeOfClass(superClass: IrClass): Boolean {
if (this !is IrSimpleType) return false
return classifier.isSubtypeOfClass(superClass)
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt
index 230342b..834ffe4 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt
@@ -8,8 +8,8 @@
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrClassifier
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
import org.jetbrains.kotlin.name.FqNameUnsafe
import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -21,11 +21,12 @@
private fun IrType.isClassType(fqName: FqNameUnsafe, hasQuestionMark: Boolean? = null): Boolean {
if (this !is IrSimpleType) return false
if (hasQuestionMark != null && this.hasQuestionMark != hasQuestionMark) return false
- return classifier.isClassWithFqName(fqName)
+ return classifier.owner.isClassWithFqName(fqName)
}
-fun IrClassifierSymbol.isClassWithFqName(fqName: FqNameUnsafe): Boolean =
- this is IrClassSymbol && classFqNameEquals(this, fqName)
+fun IrClassifier.isClassWithFqName(fqName: FqNameUnsafe): Boolean =
+ this is IrClass && isClassWithFqName(fqName)
+fun IrClass.isClassWithFqName(fqName: FqNameUnsafe): Boolean = classFqNameEquals(this, fqName)
private fun classFqNameEquals(symbol: IrClassSymbol, fqName: FqNameUnsafe): Boolean =
if (symbol.isBound) classFqNameEquals(symbol.owner, fqName) else classFqNameEquals(symbol.descriptor, fqName)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt
index c618d76..f583b7d 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypes.kt
@@ -73,9 +73,9 @@
fun IrType.getClass(): IrClass? =
classOrNull?.owner
-fun IrClassSymbol.createType(hasQuestionMark: Boolean, arguments: List<IrTypeArgument>): IrSimpleType =
+fun IrClass.createType(hasQuestionMark: Boolean, arguments: List<IrTypeArgument>): IrSimpleType =
IrSimpleTypeImpl(
- this,
+ this.symbol,
hasQuestionMark,
arguments,
emptyList()
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt
index c0ca56a..d58fb6d 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/AdditionalIrUtils.kt
@@ -68,8 +68,8 @@
fun IrSimpleFunction.overrides(other: IrSimpleFunction): Boolean {
if (this == other) return true
- this.overriddenSymbols.forEach {
- if (it.owner.overrides(other)) {
+ this.overridden.forEach {
+ if (it.overrides(other)) {
return true
}
}
@@ -78,7 +78,7 @@
}
private val IrConstructorCall.annotationClass
- get() = this.symbol.owner.constructedClass
+ get() = this.target.constructedClass
fun List<IrConstructorCall>.hasAnnotation(fqName: FqName): Boolean =
any { it.annotationClass.fqNameWhenAvailable == fqName }
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ConstantValueGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ConstantValueGenerator.kt
index 02810dc..f45f1b2 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ConstantValueGenerator.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ConstantValueGenerator.kt
@@ -11,6 +11,7 @@
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
+import org.jetbrains.kotlin.ir.declarations.IrClassifier
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.impl.*
@@ -109,7 +110,7 @@
IrClassReferenceImpl(
startOffset, endOffset,
constantValue.getType(moduleDescriptor).toIrType(),
- classifierDescriptor.defaultType.toIrType().classifierOrFail,
+ classifierDescriptor.defaultType.toIrType().classifierOrFail as IrClassifier,
classifierKtType.toIrType()
)
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt
index f6c9946..a005b36 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt
@@ -38,7 +38,9 @@
val symbolRemapper = DeepCopySymbolRemapper(descriptorRemapper)
acceptVoid(symbolRemapper)
val typeRemapper = DeepCopyTypeRemapper(symbolRemapper)
- return transform(DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper), null).patchDeclarationParents(initialParent) as T
+ return transform(DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper), null)
+ .desymbolize()
+ .patchDeclarationParents(initialParent) as T
}
interface SymbolRenamer {
@@ -155,8 +157,8 @@
declaration.isTailrec,
declaration.isSuspend
).apply {
- declaration.overriddenSymbols.mapTo(overriddenSymbols) {
- symbolRemapper.getReferencedFunction(it) as IrSimpleFunctionSymbol
+ declaration.overridden.mapTo(overridden) {
+ (symbolRemapper.getReferencedFunction(it.symbol) as IrSimpleFunctionSymbol)
}
transformFunctionChildren(declaration)
}
@@ -229,8 +231,8 @@
declaration.isStatic
).apply {
transformAnnotations(declaration)
- declaration.overriddenSymbols.mapTo(overriddenSymbols) {
- symbolRemapper.getReferencedField(it)
+ declaration.overridden.mapTo(overridden) {
+ symbolRemapper.getReferencedField(it.symbol)
}
initializer = declaration.initializer?.transform()
}
@@ -389,7 +391,7 @@
symbolRemapper.getReferencedReturnableBlock(expression.symbol),
mapStatementOrigin(expression.origin),
expression.statements.map { it.transform() },
- expression.inlineFunctionSymbol
+ expression.inlineFunction
).copyAttributes(expression)
else
IrBlockImpl(
@@ -418,21 +420,21 @@
IrGetObjectValueImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedClass(expression.symbol)
+ symbolRemapper.getReferencedClass(expression.target.symbol)
).copyAttributes(expression)
override fun visitGetEnumValue(expression: IrGetEnumValue): IrGetEnumValue =
IrGetEnumValueImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedEnumEntry(expression.symbol)
+ symbolRemapper.getReferencedEnumEntry(expression.target.symbol)
).copyAttributes(expression)
override fun visitGetValue(expression: IrGetValue): IrGetValue =
IrGetValueImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedValue(expression.symbol),
+ symbolRemapper.getReferencedValue(expression.target.symbol),
mapStatementOrigin(expression.origin)
).copyAttributes(expression)
@@ -440,7 +442,7 @@
IrSetVariableImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedVariable(expression.symbol),
+ symbolRemapper.getReferencedVariable(expression.target.symbol),
expression.value.transform(),
mapStatementOrigin(expression.origin)
).copyAttributes(expression)
@@ -448,22 +450,22 @@
override fun visitGetField(expression: IrGetField): IrGetField =
IrGetFieldImpl(
expression.startOffset, expression.endOffset,
- symbolRemapper.getReferencedField(expression.symbol),
+ symbolRemapper.getReferencedField(expression.target.symbol),
expression.type.remapType(),
expression.receiver?.transform(),
mapStatementOrigin(expression.origin),
- symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol)
+ symbolRemapper.getReferencedClassOrNull(expression.irSuperQualifier?.symbol)
).copyAttributes(expression)
override fun visitSetField(expression: IrSetField): IrSetField =
IrSetFieldImpl(
expression.startOffset, expression.endOffset,
- symbolRemapper.getReferencedField(expression.symbol),
+ symbolRemapper.getReferencedField(expression.target.symbol),
expression.receiver?.transform(),
expression.value.transform(),
expression.type.remapType(),
mapStatementOrigin(expression.origin),
- symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol)
+ symbolRemapper.getReferencedClassOrNull(expression.irSuperQualifier?.symbol)
).copyAttributes(expression)
override fun visitCall(expression: IrCall): IrCall =
@@ -473,12 +475,12 @@
}
override fun visitConstructorCall(expression: IrConstructorCall): IrConstructorCall {
- val constructorSymbol = symbolRemapper.getReferencedConstructor(expression.symbol)
+ val constructor = symbolRemapper.getReferencedConstructor(expression.target.symbol)
return IrConstructorCallImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- constructorSymbol,
- constructorSymbol.descriptor,
+ constructor,
+ constructor.descriptor,
expression.typeArgumentsCount,
expression.constructorTypeArgumentsCount,
expression.valueArgumentsCount,
@@ -499,7 +501,7 @@
}
private fun shallowCopyCall(expression: IrCall): IrCall {
- val newCallee = symbolRemapper.getReferencedFunction(expression.symbol)
+ val newCallee = symbolRemapper.getReferencedFunction(expression.target.symbol)
return IrCallImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
@@ -508,7 +510,7 @@
expression.typeArgumentsCount,
expression.valueArgumentsCount,
mapStatementOrigin(expression.origin),
- symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol)
+ symbolRemapper.getReferencedClassOrNull(expression.irSuperQualifier?.symbol)
).apply {
copyRemappedTypeArgumentsFrom(expression)
}.copyAttributes(expression)
@@ -528,7 +530,7 @@
}
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrDelegatingConstructorCall {
- val newConstructor = symbolRemapper.getReferencedConstructor(expression.symbol)
+ val newConstructor = symbolRemapper.getReferencedConstructor(expression.target.symbol)
return IrDelegatingConstructorCallImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
@@ -542,7 +544,7 @@
}
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrEnumConstructorCall {
- val newConstructor = symbolRemapper.getReferencedConstructor(expression.symbol)
+ val newConstructor = symbolRemapper.getReferencedConstructor(expression.target.symbol)
return IrEnumConstructorCallImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
@@ -562,12 +564,12 @@
).copyAttributes(expression)
override fun visitFunctionReference(expression: IrFunctionReference): IrFunctionReference {
- val symbol = symbolRemapper.getReferencedFunction(expression.symbol)
+ val target = symbolRemapper.getReferencedFunction(expression.target.symbol)
return IrFunctionReferenceImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbol,
- symbol.descriptor,
+ target,
+ target.descriptor,
expression.typeArgumentsCount,
expression.valueArgumentsCount,
mapStatementOrigin(expression.origin)
@@ -581,11 +583,11 @@
IrPropertyReferenceImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedProperty(expression.symbol),
+ symbolRemapper.getReferencedProperty(expression.target.symbol),
expression.typeArgumentsCount,
- expression.field?.let { symbolRemapper.getReferencedField(it) },
- expression.getter?.let { symbolRemapper.getReferencedSimpleFunction(it) },
- expression.setter?.let { symbolRemapper.getReferencedSimpleFunction(it) },
+ expression.field?.let { symbolRemapper.getReferencedField(it.symbol) },
+ expression.getter?.let { symbolRemapper.getReferencedSimpleFunction(it.symbol) },
+ expression.setter?.let { symbolRemapper.getReferencedSimpleFunction(it.symbol) },
mapStatementOrigin(expression.origin)
).apply {
copyRemappedTypeArgumentsFrom(expression)
@@ -596,10 +598,10 @@
IrLocalDelegatedPropertyReferenceImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedLocalDelegatedProperty(expression.symbol),
- symbolRemapper.getReferencedVariable(expression.delegate),
- symbolRemapper.getReferencedSimpleFunction(expression.getter),
- expression.setter?.let { symbolRemapper.getReferencedSimpleFunction(it) },
+ symbolRemapper.getReferencedLocalDelegatedProperty(expression.target.symbol),
+ symbolRemapper.getReferencedVariable(expression.delegate.symbol),
+ symbolRemapper.getReferencedSimpleFunction(expression.getter.symbol),
+ expression.setter?.let { symbolRemapper.getReferencedSimpleFunction(it.symbol) },
mapStatementOrigin(expression.origin)
).copyAttributes(expression)
@@ -615,14 +617,14 @@
IrClassReferenceImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedClassifier(expression.symbol),
+ symbolRemapper.getReferencedClassifier(expression.target.symbol),
expression.classType.remapType()
).copyAttributes(expression)
override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall): IrInstanceInitializerCall =
IrInstanceInitializerCallImpl(
expression.startOffset, expression.endOffset,
- symbolRemapper.getReferencedClass(expression.classSymbol),
+ symbolRemapper.getReferencedClass(expression.irClass.symbol),
expression.type.remapType()
).copyAttributes(expression)
@@ -715,7 +717,7 @@
IrReturnImpl(
expression.startOffset, expression.endOffset,
expression.type.remapType(),
- symbolRemapper.getReferencedReturnTarget(expression.returnTargetSymbol),
+ symbolRemapper.getReferencedReturnTarget(expression.irReturnTarget.symbol),
expression.value.transform()
).copyAttributes(expression)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Desymbolize.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Desymbolize.kt
new file mode 100644
index 0000000..7c6b12a
--- /dev/null
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Desymbolize.kt
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.util
+
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.IrStatement
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
+import org.jetbrains.kotlin.ir.declarations.copyAttributes
+import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.symbols.*
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
+
+fun IrElement.desymbolize(): IrElement = transform(DesymbolizeTransformer, null)
+
+object DesymbolizeTransformer : IrElementTransformerVoid() {
+ override fun visitField(declaration: IrField): IrStatement {
+ declaration.overridden.replaceAll {
+ if (it is IrFieldSymbol) it.owner else it
+ }
+ return super.visitField(declaration)
+ }
+
+ override fun visitSimpleFunction(declaration: IrSimpleFunction): IrStatement {
+ declaration.overridden.replaceAll {
+ if (it is IrSimpleFunctionSymbol) it.owner else it
+ }
+ return super.visitSimpleFunction(declaration)
+ }
+
+ override fun visitClassReference(expression: IrClassReference): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrClassifierSymbol)
+ IrClassReferenceImpl(
+ expression.startOffset, expression.endOffset,
+ expression.type,
+ target.owner,
+ expression.classType
+ )
+ else expression
+ return super.visitClassReference(newExpression)
+ }
+
+ override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrFunctionSymbol)
+ IrFunctionReferenceImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.descriptor, expression.typeArgumentsCount, expression.valueArgumentsCount, expression.origin
+ ).apply {
+ copyTypeAndValueArgumentsFrom(expression)
+ copyAttributes(expression)
+ }
+ else expression
+ return super.visitFunctionReference(newExpression)
+ }
+
+ override fun visitPropertyReference(expression: IrPropertyReference): IrExpression {
+ val newExpression = IrPropertyReferenceImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ expression.target.desymbolizeLink(),
+ expression.descriptor, expression.typeArgumentsCount,
+ expression.field?.desymbolizeLink(),
+ expression.getter?.desymbolizeLink(),
+ expression.setter?.desymbolizeLink(),
+ expression.origin
+ ).apply {
+ copyTypeArgumentsFrom(expression)
+ dispatchReceiver = expression.dispatchReceiver
+ extensionReceiver = expression.extensionReceiver
+ copyAttributes(expression)
+ }
+ return super.visitPropertyReference(newExpression)
+ }
+
+ override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrExpression {
+ val newExpression = IrLocalDelegatedPropertyReferenceImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ expression.target.desymbolizeLink(),
+ expression.delegate.desymbolizeLink(),
+ expression.getter.desymbolizeLink(),
+ expression.setter?.desymbolizeLink(),
+ expression.origin
+ ).apply {
+ copyAttributes(expression)
+ }
+ return super.visitLocalDelegatedPropertyReference(newExpression)
+ }
+
+ override fun visitGetField(expression: IrGetField): IrExpression {
+ val target = expression.target.desymbolizeLink()
+ val irSuperQualifier = expression.irSuperQualifier?.desymbolizeLink()
+ val newExpression = IrGetFieldImpl(
+ expression.startOffset, expression.endOffset,
+ target,
+ expression.type, expression.receiver, expression.origin,
+ irSuperQualifier
+ )
+ return super.visitGetField(newExpression)
+ }
+
+ override fun visitSetField(expression: IrSetField): IrExpression {
+ val newExpression = IrSetFieldImpl(
+ expression.startOffset, expression.endOffset,
+ expression.target.desymbolizeLink(),
+ expression.receiver, expression.value, expression.type, expression.origin,
+ expression.irSuperQualifier?.desymbolizeLink()
+ )
+ return super.visitSetField(newExpression)
+ }
+
+ override fun visitGetValue(expression: IrGetValue): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrValueSymbol)
+ IrGetValueImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.origin
+ )
+ else expression
+ return super.visitGetValue(newExpression)
+ }
+
+ override fun visitSetVariable(expression: IrSetVariable): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrVariableSymbol)
+ IrSetVariableImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.value, expression.origin
+ )
+ else expression
+ return super.visitSetVariable(newExpression)
+ }
+
+ override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrConstructorSymbol)
+ IrDelegatingConstructorCallImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.descriptor, expression.typeArgumentsCount, expression.valueArgumentsCount
+ ).apply {
+ copyTypeAndValueArgumentsFrom(expression)
+ }
+ else expression
+ return super.visitDelegatingConstructorCall(newExpression)
+ }
+
+ override fun visitConstructorCall(expression: IrConstructorCall): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrConstructorSymbol)
+ IrConstructorCallImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.descriptor,
+ expression.typeArgumentsCount, expression.constructorTypeArgumentsCount, expression.valueArgumentsCount,
+ expression.origin
+ ).apply {
+ copyTypeAndValueArgumentsFrom(expression)
+ }
+ else expression
+ return super.visitConstructorCall(newExpression)
+ }
+
+ override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrExpression {
+ val target = expression.target
+ val newExpression = if (target is IrConstructorSymbol)
+ IrEnumConstructorCallImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.typeArgumentsCount, expression.valueArgumentsCount
+ ).apply {
+ copyTypeAndValueArgumentsFrom(expression)
+ }
+ else expression
+ return super.visitEnumConstructorCall(newExpression)
+ }
+
+ override fun visitCall(expression: IrCall): IrExpression {
+ val newExpression = IrCallImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ expression.target.desymbolizeLink(),
+ expression.descriptor,
+ expression.typeArgumentsCount, expression.valueArgumentsCount, expression.origin,
+ expression.irSuperQualifier?.desymbolizeLink()
+ ).apply {
+ copyTypeAndValueArgumentsFrom(expression)
+ }
+ return super.visitCall(newExpression)
+ }
+
+ override fun visitReturn(expression: IrReturn): IrExpression {
+ val target = expression.irReturnTarget
+ val newExpression = if (target is IrReturnTargetSymbol)
+ IrReturnImpl(
+ expression.startOffset, expression.endOffset, expression.type,
+ target.owner,
+ expression.value
+ )
+ else expression
+ return super.visitReturn(newExpression)
+ }
+
+ private inline fun <reified Ir : IrSymbolOwner, D : DeclarationDescriptor, reified S : IrBindableSymbol<D, Ir>> Ir.desymbolizeLink() =
+ if (this is S) owner else this
+}
\ No newline at end of file
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt
index 258b1ab..6e02c82 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt
@@ -94,8 +94,8 @@
declaration.dumpLabeledElementWith(data) {
dumpAnnotations(declaration)
declaration.correspondingPropertySymbol?.dumpInternal("correspondingProperty")
- declaration.overriddenSymbols.dumpItems<IrSymbol>("overridden") {
- it.dump()
+ declaration.overridden.dumpItems("overridden") {
+ it.symbol.dump()
}
declaration.typeParameters.dumpElements()
declaration.dispatchReceiverParameter?.accept(this, "\$this")
@@ -140,8 +140,8 @@
override fun visitField(declaration: IrField, data: String) {
declaration.dumpLabeledElementWith(data) {
dumpAnnotations(declaration)
- declaration.overriddenSymbols.dumpItems("overridden") {
- it.dump()
+ declaration.overridden.dumpItems("overridden") {
+ it.symbol.dump()
}
declaration.initializer?.accept(this, "")
}
@@ -214,8 +214,8 @@
}
private fun IrMemberAccessExpression.getTypeParameterNames(expectedCount: Int): List<String> =
- if (this is IrDeclarationReference && symbol.isBound)
- symbol.owner.getTypeParameterNames(expectedCount)
+ if (this is IrDeclarationReference && target.symbol.isBound)
+ target.getTypeParameterNames(expectedCount)
else
getPlaceholderParameterNames(expectedCount)
@@ -371,8 +371,8 @@
internal fun IrMemberAccessExpression.getValueParameterNamesForDebug(): List<String> {
val expectedCount = valueArgumentsCount
- return if (this is IrDeclarationReference && symbol.isBound) {
- val owner = symbol.owner
+ return if (this is IrDeclarationReference && target.symbol.isBound) {
+ val owner = target
if (owner is IrFunction) {
(0 until expectedCount).map {
if (it < owner.valueParameters.size)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExpectDeclarationRemover.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExpectDeclarationRemover.kt
index 1c05b63..8cbbad8 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExpectDeclarationRemover.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExpectDeclarationRemover.kt
@@ -11,8 +11,6 @@
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
-import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
@@ -98,42 +96,41 @@
override fun visitGetValue(expression: IrGetValue): IrExpression {
expression.transformChildrenVoid()
- val newValue = remapExpectValue(expression.symbol)
+ val newValue = remapExpectValue(expression.target)
?: return expression
return IrGetValueImpl(
expression.startOffset,
expression.endOffset,
newValue.type,
- newValue.symbol,
+ newValue,
expression.origin
)
}
}, data = null)
}
- private fun remapExpectValue(symbol: IrValueSymbol): IrValueParameter? {
- if (symbol !is IrValueParameterSymbol) {
+ private fun remapExpectValue(declaration: IrValueDeclaration): IrValueParameter? {
+ if (declaration !is IrValueParameter) {
return null
}
- val parameter = symbol.owner
- val parent = parameter.parent
+ val parent = declaration.parent
return when (parent) {
is IrClass -> {
- assert(parameter == parent.thisReceiver)
+ assert(declaration == parent.thisReceiver)
parent.findActualForExpected().thisReceiver!!
}
- is IrFunction -> when (parameter) {
+ is IrFunction -> when (declaration) {
parent.dispatchReceiverParameter ->
parent.findActualForExpected().dispatchReceiverParameter!!
parent.extensionReceiverParameter ->
parent.findActualForExpected().extensionReceiverParameter!!
else -> {
- assert(parent.valueParameters[parameter.index] == parameter)
- parent.findActualForExpected().valueParameters[parameter.index]
+ assert(parent.valueParameters[declaration.index] == declaration)
+ parent.findActualForExpected().valueParameters[declaration.index]
}
}
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt
index ec27fba..a628381 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt
@@ -59,22 +59,21 @@
* Binds the arguments explicitly represented in the IR to the parameters of the accessed function.
* The arguments are to be evaluated in the same order as they appear in the resulting list.
*/
-fun IrFunctionAccessExpression.getArgumentsWithSymbols(): List<Pair<IrValueParameterSymbol, IrExpression>> {
- val res = mutableListOf<Pair<IrValueParameterSymbol, IrExpression>>()
- val irFunction = symbol.owner
+fun IrFunctionAccessExpression.getArgumentsWithParameters(): List<Pair<IrValueParameter, IrExpression>> {
+ val res = mutableListOf<Pair<IrValueParameter, IrExpression>>()
dispatchReceiver?.let {
- res += (irFunction.dispatchReceiverParameter!!.symbol to it)
+ res += (target.dispatchReceiverParameter!! to it)
}
extensionReceiver?.let {
- res += (irFunction.extensionReceiverParameter!!.symbol to it)
+ res += (target.extensionReceiverParameter!! to it)
}
- irFunction.valueParameters.forEach {
+ target.valueParameters.forEach {
val arg = getValueArgument(it.descriptor as ValueParameterDescriptor)
if (arg != null) {
- res += (it.symbol to arg)
+ res += (it to arg)
}
}
@@ -88,8 +87,8 @@
fun IrMemberAccessExpression.getArgumentsWithIr(): List<Pair<IrValueParameter, IrExpression>> {
val res = mutableListOf<Pair<IrValueParameter, IrExpression>>()
val irFunction = when (this) {
- is IrFunctionAccessExpression -> this.symbol.owner
- is IrFunctionReference -> this.symbol.owner
+ is IrFunctionAccessExpression -> this.target
+ is IrFunctionReference -> this.target
else -> error(this)
}
@@ -181,21 +180,12 @@
val IrClass.functions: Sequence<IrSimpleFunction>
get() = declarations.asSequence().filterIsInstance<IrSimpleFunction>()
-val IrClassSymbol.functions: Sequence<IrSimpleFunctionSymbol>
- get() = owner.functions.map { it.symbol }
-
val IrClass.constructors: Sequence<IrConstructor>
get() = declarations.asSequence().filterIsInstance<IrConstructor>()
-val IrClassSymbol.constructors: Sequence<IrConstructorSymbol>
- get() = owner.constructors.map { it.symbol }
-
val IrClass.fields: Sequence<IrField>
get() = declarations.asSequence().filterIsInstance<IrField>()
-val IrClassSymbol.fields: Sequence<IrFieldSymbol>
- get() = owner.fields.map { it.symbol }
-
val IrClass.primaryConstructor: IrConstructor?
get() = this.declarations.singleOrNull { it is IrConstructor && it.isPrimary } as IrConstructor?
@@ -223,9 +213,9 @@
val IrDeclaration.isFakeOverride: Boolean get() = origin == IrDeclarationOrigin.FAKE_OVERRIDE
fun IrClass.isSubclassOf(ancestor: IrClass): Boolean {
-
val alreadyVisited = mutableSetOf<IrClass>()
+
fun IrClass.hasAncestorInSuperTypes(): Boolean = when {
this === ancestor -> true
this in alreadyVisited -> false
@@ -250,18 +240,18 @@
if (func.isReal) {
realOverrides += func
} else {
- func.overriddenSymbols.forEach { collectRealOverrides(it.owner) }
+ func.overridden.forEach { collectRealOverrides(it) }
}
}
- overriddenSymbols.forEach { collectRealOverrides(it.owner) }
+ overridden.forEach { collectRealOverrides(it) }
fun excludeRepeated(func: IrSimpleFunction) {
if (!visited.add(func)) return
- func.overriddenSymbols.forEach {
- realOverrides.remove(it.owner)
- excludeRepeated(it.owner)
+ func.overridden.forEach {
+ realOverrides.remove(it)
+ excludeRepeated(it)
}
}
@@ -280,7 +270,7 @@
fun IrSimpleFunction.isOrOverridesSynthesized(): Boolean {
if (isSynthesized) return true
- if (isFakeOverride) return overriddenSymbols.all { it.owner.isOrOverridesSynthesized() }
+ if (isFakeOverride) return overridden.all { it.isOrOverridesSynthesized() }
return false
}
@@ -297,8 +287,8 @@
var toVisit = setOf(this)
val nonOverridden = mutableSetOf<IrField>()
while (toVisit.isNotEmpty()) {
- nonOverridden += toVisit.filter { it.overriddenSymbols.isEmpty() }
- toVisit = toVisit.flatMap { it.overriddenSymbols }.map { it.owner }.toSet()
+ nonOverridden += toVisit.filter { it.overridden.isEmpty() }
+ toVisit = toVisit.flatMap { it.overridden }.toSet()
}
return nonOverridden.singleOrNull()
}
@@ -343,17 +333,17 @@
fun IrAnnotationContainer.getAnnotation(name: FqName): IrConstructorCall? =
annotations.find {
- it.symbol.owner.parentAsClass.descriptor.fqNameSafe == name
+ it.target.parentAsClass.descriptor.fqNameSafe == name
}
fun IrAnnotationContainer.hasAnnotation(name: FqName) =
annotations.any {
- it.symbol.owner.parentAsClass.descriptor.fqNameSafe == name
+ it.target.parentAsClass.descriptor.fqNameSafe == name
}
-fun IrAnnotationContainer.hasAnnotation(symbol: IrClassSymbol) =
+fun IrAnnotationContainer.hasAnnotation(clazz: IrClass) =
annotations.any {
- it.symbol.owner.parentAsClass.symbol == symbol
+ it.target.parentAsClass == clazz
}
@@ -364,10 +354,10 @@
return (parent as? IrClass)?.thisReceiver?.type?.isAny() ?: false
}
- return (this as IrSimpleFunction).overriddenSymbols.all { it.owner.isFakeOverriddenFromAny() }
+ return (this as IrSimpleFunction).overridden.all { it.isFakeOverriddenFromAny() }
}
-fun IrCall.isSuperToAny() = superQualifier?.let { this.symbol.owner.isFakeOverriddenFromAny() } ?: false
+fun IrCall.isSuperToAny() = superQualifier?.let { this.target.isFakeOverriddenFromAny() } ?: false
fun IrDeclaration.isEffectivelyExternal(): Boolean {
@@ -389,7 +379,7 @@
fun IrFunction.isExternalOrInheritedFromExternal(): Boolean {
fun isExternalOrInheritedFromExternalImpl(f: IrSimpleFunction): Boolean =
- f.isEffectivelyExternal() || f.overriddenSymbols.any { isExternalOrInheritedFromExternalImpl(it.owner) }
+ f.isEffectivelyExternal() || f.overridden.any { isExternalOrInheritedFromExternalImpl(it) }
return isEffectivelyExternal() || (this is IrSimpleFunction && isExternalOrInheritedFromExternalImpl(this))
}
@@ -403,7 +393,7 @@
fun IrValueParameter.hasDefaultValue(): Boolean = DFS.ifAny(
listOf(this),
- { current -> (current.parent as? IrSimpleFunction)?.overriddenSymbols?.map { it.owner.valueParameters[current.index] } ?: listOf() },
+ { current -> (current.parent as? IrSimpleFunction)?.overridden?.map { it.valueParameters[current.index] } ?: listOf() },
{ current -> current.defaultValue != null }
)
@@ -454,15 +444,7 @@
fun irConstructorCall(
call: IrFunctionAccessExpression,
- newFunction: IrConstructor,
- receiversAsArguments: Boolean = false,
- argumentsAsReceivers: Boolean = false
-): IrConstructorCall =
- irConstructorCall(call, newFunction.symbol, receiversAsArguments, argumentsAsReceivers)
-
-fun irConstructorCall(
- call: IrFunctionAccessExpression,
- newSymbol: IrConstructorSymbol,
+ newCallee: IrConstructor,
receiversAsArguments: Boolean = false,
argumentsAsDispatchers: Boolean = false
): IrConstructorCall =
@@ -471,8 +453,8 @@
startOffset,
endOffset,
type,
- newSymbol,
- newSymbol.descriptor,
+ newCallee,
+ newCallee.descriptor,
typeArgumentsCount,
0,
call.valueArgumentsCount,
@@ -492,26 +474,13 @@
receiversAsArguments: Boolean = false,
argumentsAsReceivers: Boolean = false
): IrCall =
- irCall(
- call,
- newFunction.symbol,
- receiversAsArguments,
- argumentsAsReceivers
- )
-
-fun irCall(
- call: IrFunctionAccessExpression,
- newSymbol: IrFunctionSymbol,
- receiversAsArguments: Boolean = false,
- argumentsAsReceivers: Boolean = false
-): IrCall =
call.run {
IrCallImpl(
startOffset,
endOffset,
type,
- newSymbol,
- newSymbol.descriptor,
+ newFunction,
+ newFunction.descriptor,
typeArgumentsCount,
origin
).apply {
@@ -529,8 +498,8 @@
argumentsAsReceivers: Boolean = false
) = copyTypeAndValueArgumentsFrom(
src,
- src.symbol.owner,
- symbol.owner,
+ src.target,
+ target,
receiversAsArguments,
argumentsAsReceivers
)
@@ -541,8 +510,8 @@
argumentsAsReceivers: Boolean = false
) = copyTypeAndValueArgumentsFrom(
src,
- src.symbol.owner,
- symbol.owner,
+ src.target,
+ target,
receiversAsArguments,
argumentsAsReceivers
)
@@ -604,13 +573,13 @@
else
typeParameters
-fun IrMemberAccessExpression.getTypeSubstitutionMap(irFunction: IrFunction): Map<IrTypeParameterSymbol, IrType> =
+fun IrMemberAccessExpression.getTypeSubstitutionMap(irFunction: IrFunction): Map<IrTypeParameter, IrType> =
irFunction.allTypeParameters.withIndex().associate {
- it.value.symbol to getTypeArgument(it.index)!!
+ it.value to getTypeArgument(it.index)!!
}
-val IrFunctionReference.typeSubstitutionMap: Map<IrTypeParameterSymbol, IrType>
- get() = getTypeSubstitutionMap(symbol.owner)
+val IrFunctionReference.typeSubstitutionMap: Map<IrTypeParameter, IrType>
+ get() = getTypeSubstitutionMap(target)
-val IrFunctionAccessExpression.typeSubstitutionMap: Map<IrTypeParameterSymbol, IrType>
- get() = getTypeSubstitutionMap(symbol.owner)
+val IrFunctionAccessExpression.typeSubstitutionMap: Map<IrTypeParameter, IrType>
+ get() = getTypeSubstitutionMap(target)
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt
index bad56ef..5917bc9 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt
@@ -45,7 +45,7 @@
private fun StringBuilder.renderAsAnnotation(irAnnotation: IrConstructorCall) {
val annotationClassName = try {
- irAnnotation.symbol.owner.parentAsClass.name.asString()
+ irAnnotation.target.parentAsClass.name.asString()
} catch (e: Exception) {
"<unbound>"
}
@@ -545,44 +545,44 @@
"COMPOSITE type=${expression.type.render()} origin=${expression.origin}"
override fun visitReturn(expression: IrReturn, data: Nothing?): String =
- "RETURN type=${expression.type.render()} from='${expression.returnTargetSymbol.renderReference()}'"
+ "RETURN type=${expression.type.render()} from='${expression.irReturnTarget.symbol.renderReference()}'"
override fun visitCall(expression: IrCall, data: Nothing?): String =
- "CALL '${expression.symbol.renderReference()}' ${expression.renderSuperQualifier()}" +
+ "CALL '${expression.target.symbol.renderReference()}' ${expression.renderSuperQualifier()}" +
"type=${expression.type.render()} origin=${expression.origin}"
private fun IrCall.renderSuperQualifier(): String =
- superQualifierSymbol?.let { "superQualifier='${it.renderReference()}' " } ?: ""
+ irSuperQualifier?.let { "superQualifier='${it.symbol.renderReference()}' " } ?: ""
override fun visitConstructorCall(expression: IrConstructorCall, data: Nothing?): String =
- "CONSTRUCTOR_CALL '${expression.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
+ "CONSTRUCTOR_CALL '${expression.target.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?): String =
- "DELEGATING_CONSTRUCTOR_CALL '${expression.symbol.renderReference()}'"
+ "DELEGATING_CONSTRUCTOR_CALL '${expression.target.symbol.renderReference()}'"
override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?): String =
- "ENUM_CONSTRUCTOR_CALL '${expression.symbol.renderReference()}'"
+ "ENUM_CONSTRUCTOR_CALL '${expression.target.symbol.renderReference()}'"
override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?): String =
- "INSTANCE_INITIALIZER_CALL classDescriptor='${expression.classSymbol.renderReference()}'"
+ "INSTANCE_INITIALIZER_CALL classDescriptor='${expression.irClass.symbol.renderReference()}'"
override fun visitGetValue(expression: IrGetValue, data: Nothing?): String =
- "GET_VAR '${expression.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
+ "GET_VAR '${expression.target.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
override fun visitSetVariable(expression: IrSetVariable, data: Nothing?): String =
- "SET_VAR '${expression.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
+ "SET_VAR '${expression.target.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
override fun visitGetField(expression: IrGetField, data: Nothing?): String =
- "GET_FIELD '${expression.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
+ "GET_FIELD '${expression.target.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
override fun visitSetField(expression: IrSetField, data: Nothing?): String =
- "SET_FIELD '${expression.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
+ "SET_FIELD '${expression.target.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?): String =
- "GET_OBJECT '${expression.symbol.renderReference()}' type=${expression.type.render()}"
+ "GET_OBJECT '${expression.target.symbol.renderReference()}' type=${expression.type.render()}"
override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?): String =
- "GET_ENUM '${expression.symbol.renderReference()}' type=${expression.type.render()}"
+ "GET_ENUM '${expression.target.symbol.renderReference()}' type=${expression.type.render()}"
override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?): String =
"STRING_CONCATENATION type=${expression.type.render()}"
@@ -612,15 +612,15 @@
"THROW type=${expression.type.render()}"
override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?): String =
- "FUNCTION_REFERENCE '${expression.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
+ "FUNCTION_REFERENCE '${expression.target.symbol.renderReference()}' type=${expression.type.render()} origin=${expression.origin}"
override fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?): String =
buildTrimEnd {
append("PROPERTY_REFERENCE ")
- append("'${expression.symbol.renderReference()}' ")
- appendNullableAttribute("field=", expression.field) { "'${it.renderReference()}'" }
- appendNullableAttribute("getter=", expression.getter) { "'${it.renderReference()}'" }
- appendNullableAttribute("setter=", expression.setter) { "'${it.renderReference()}'" }
+ append("'${expression.target.symbol.renderReference()}' ")
+ appendNullableAttribute("field=", expression.field) { "'${it.symbol.renderReference()}'" }
+ appendNullableAttribute("getter=", expression.getter) { "'${it.symbol.renderReference()}'" }
+ appendNullableAttribute("setter=", expression.setter) { "'${it.symbol.renderReference()}'" }
append("type=${expression.type.render()} ")
append("origin=${expression.origin}")
}
@@ -638,10 +638,10 @@
override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: Nothing?): String =
buildTrimEnd {
append("LOCAL_DELEGATED_PROPERTY_REFERENCE ")
- append("'${expression.symbol.renderReference()}' ")
- append("delegate='${expression.delegate.renderReference()}' ")
- append("getter='${expression.getter.renderReference()}' ")
- appendNullableAttribute("setter=", expression.setter) { "'${it.renderReference()}'" }
+ append("'${expression.target.symbol.renderReference()}' ")
+ append("delegate='${expression.delegate.symbol.renderReference()}' ")
+ append("getter='${expression.getter.symbol.renderReference()}' ")
+ appendNullableAttribute("setter=", expression.setter) { "'${it.symbol.renderReference()}'" }
append("type=${expression.type.render()} ")
append("origin=${expression.origin}")
}
@@ -652,7 +652,7 @@
}
override fun visitClassReference(expression: IrClassReference, data: Nothing?): String =
- "CLASS_REFERENCE '${expression.symbol.renderReference()}' type=${expression.type.render()}"
+ "CLASS_REFERENCE '${expression.target.symbol.renderReference()}' type=${expression.type.render()}"
override fun visitGetClass(expression: IrGetClass, data: Nothing?): String =
"GET_CLASS type=${expression.type.render()}"
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt
index 24299c5..6ba993e 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt
@@ -27,7 +27,7 @@
declaration: IrSimpleFunction,
symbolTable: SymbolTable
) {
- declaration.descriptor.overriddenDescriptors.mapTo(declaration.overriddenSymbols) {
+ declaration.descriptor.overriddenDescriptors.mapTo(declaration.overridden) {
symbolTable.referenceSimpleFunction(it.original)
}
}
@@ -49,7 +49,7 @@
symbolTable: SymbolTable,
hasBackingField: (PropertyDescriptor) -> Boolean
) {
- declaration.descriptor.overriddenDescriptors.mapNotNullTo(declaration.overriddenSymbols) {
+ declaration.descriptor.overriddenDescriptors.mapNotNullTo(declaration.overridden) {
if (hasBackingField(it)) {
symbolTable.referenceField(it.original)
} else null
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt
index 407ba2a..7d30274 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFakeOverrideUtils.kt
@@ -7,13 +7,12 @@
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.symbols.IrBindableSymbol
import org.jetbrains.kotlin.ir.util.isReal
import org.jetbrains.kotlin.ir.util.original
// We may get several real supers here (e.g. see the code snippet from KT-33034).
// TODO: Consider reworking the resolution algorithm to get a determined super declaration.
-private fun <S: IrBindableSymbol<*, D>, D: IrOverridableDeclaration<S>> D.getRealSupers(): Set<D> {
+private fun <D: IrOverridableDeclaration<D>> D.getRealSupers(): Set<D> {
if (this.isReal) {
return setOf(this)
}
@@ -27,7 +26,7 @@
if (declaration.isReal) {
realSupers += declaration
} else {
- declaration.overriddenSymbols.forEach { findRealSupers(it.owner) }
+ declaration.overridden.forEach { findRealSupers(it) }
}
}
@@ -39,9 +38,9 @@
fun excludeOverridden(declaration: D) {
if (declaration in visited) return
visited += declaration
- declaration.overriddenSymbols.forEach {
- realSupers.remove(it.owner)
- excludeOverridden(it.owner)
+ declaration.overridden.forEach {
+ realSupers.remove(it)
+ excludeOverridden(it)
}
}
@@ -85,11 +84,11 @@
*/
internal fun IrField.resolveFakeOverride(): IrField = getRealSupers().first()
-val IrSimpleFunction.target: IrSimpleFunction
- get() = (if (modality == Modality.ABSTRACT) this else resolveFakeOverride()).original
+val IrSimpleFunction.resolved: IrSimpleFunction
+ get() = (if (modality == Modality.ABSTRACT) this else resolveFakeOverride())
-val IrFunction.target: IrFunction get() = when (this) {
- is IrSimpleFunction -> this.target
+val IrFunction.resolved: IrFunction get() = when (this) {
+ is IrSimpleFunction -> this.resolved
is IrConstructor -> this
else -> error(this)
}
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt
index b14134e..3842abb 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt
@@ -1059,7 +1059,7 @@
proto.isSuspend
)
}.apply {
- proto.overriddenList.mapTo(overriddenSymbols) { deserializeIrSymbol(it) as IrSimpleFunctionSymbol }
+ proto.overriddenList.mapTo(overridden) { deserializeIrSymbol(it) as IrSimpleFunctionSymbol }
(descriptor as? WrappedSimpleFunctionDescriptor)?.bind(this)
}
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt
index 3ac41b4..ba4d243 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt
@@ -543,11 +543,11 @@
private fun serializeCall(call: IrCall): ProtoCall {
val proto = ProtoCall.newBuilder()
- proto.symbol = serializeIrSymbol(call.symbol)
+ proto.symbol = serializeIrSymbol(call.target.symbol)
call.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
- call.superQualifierSymbol?.let {
- proto.`super` = serializeIrSymbol(it)
+ call.irSuperQualifier?.let {
+ proto.`super` = serializeIrSymbol(it.symbol)
}
proto.memberAccess = serializeMemberAccessCommon(call)
@@ -556,7 +556,7 @@
private fun serializeConstructorCall(call: IrConstructorCall): ProtoConstructorCall =
ProtoConstructorCall.newBuilder().apply {
- symbol = serializeIrSymbol(call.symbol)
+ symbol = serializeIrSymbol(call.target.symbol)
constructorTypeArgumentsCount = call.constructorTypeArgumentsCount
memberAccess = serializeMemberAccessCommon(call)
}.build()
@@ -569,7 +569,7 @@
private fun serializeFunctionReference(callable: IrFunctionReference): ProtoFunctionReference {
val proto = ProtoFunctionReference.newBuilder()
- .setSymbol(serializeIrSymbol(callable.symbol))
+ .setSymbol(serializeIrSymbol(callable.target.symbol))
.setMemberAccess(serializeMemberAccessCommon(callable))
callable.origin?.let { proto.setOrigin(serializeIrStatementOrigin(it)) }
@@ -580,12 +580,12 @@
callable: IrLocalDelegatedPropertyReference
): ProtoLocalDelegatedPropertyReference {
val proto = ProtoLocalDelegatedPropertyReference.newBuilder()
- .setDelegate(serializeIrSymbol(callable.delegate))
- .setGetter(serializeIrSymbol(callable.getter))
- .setSymbol(serializeIrSymbol(callable.symbol))
+ .setDelegate(serializeIrSymbol(callable.delegate.symbol))
+ .setGetter(serializeIrSymbol(callable.getter.symbol))
+ .setSymbol(serializeIrSymbol(callable.target.symbol))
callable.origin?.let { proto.setOrigin(serializeIrStatementOrigin(it)) }
- callable.setter?.let { proto.setSetter(serializeIrSymbol(it)) }
+ callable.setter?.let { proto.setSetter(serializeIrSymbol(it.symbol)) }
return proto.build()
}
@@ -593,18 +593,18 @@
private fun serializePropertyReference(callable: IrPropertyReference): ProtoPropertyReference {
val proto = ProtoPropertyReference.newBuilder()
.setMemberAccess(serializeMemberAccessCommon(callable))
- .setSymbol(serializeIrSymbol(callable.symbol))
+ .setSymbol(serializeIrSymbol(callable.target.symbol))
callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
- callable.field?.let { proto.field = serializeIrSymbol(it) }
- callable.getter?.let { proto.getter = serializeIrSymbol(it) }
- callable.setter?.let { proto.setter = serializeIrSymbol(it) }
+ callable.field?.let { proto.field = serializeIrSymbol(it.symbol) }
+ callable.getter?.let { proto.getter = serializeIrSymbol(it.symbol) }
+ callable.setter?.let { proto.setter = serializeIrSymbol(it.symbol) }
return proto.build()
}
private fun serializeClassReference(expression: IrClassReference): ProtoClassReference {
val proto = ProtoClassReference.newBuilder()
- .setClassSymbol(serializeIrSymbol(expression.symbol))
+ .setClassSymbol(serializeIrSymbol(expression.target.symbol))
.setClassType(serializeIrType(expression.classType))
return proto.build()
}
@@ -628,7 +628,7 @@
private fun serializeDelegatingConstructorCall(call: IrDelegatingConstructorCall): ProtoDelegatingConstructorCall {
val proto = ProtoDelegatingConstructorCall.newBuilder()
- .setSymbol(serializeIrSymbol(call.symbol))
+ .setSymbol(serializeIrSymbol(call.target.symbol))
.setMemberAccess(serializeMemberAccessCommon(call))
return proto.build()
}
@@ -640,7 +640,7 @@
private fun serializeEnumConstructorCall(call: IrEnumConstructorCall): ProtoEnumConstructorCall {
val proto = ProtoEnumConstructorCall.newBuilder()
- .setSymbol(serializeIrSymbol(call.symbol))
+ .setSymbol(serializeIrSymbol(call.target.symbol))
.setMemberAccess(serializeMemberAccessCommon(call))
return proto.build()
}
@@ -653,14 +653,14 @@
private fun serializeGetEnumValue(expression: IrGetEnumValue): ProtoGetEnumValue {
val proto = ProtoGetEnumValue.newBuilder()
- .setSymbol(serializeIrSymbol(expression.symbol))
+ .setSymbol(serializeIrSymbol(expression.target.symbol))
return proto.build()
}
private fun serializeFieldAccessCommon(expression: IrFieldAccessExpression): ProtoFieldAccessCommon {
val proto = ProtoFieldAccessCommon.newBuilder()
- .setSymbol(serializeIrSymbol(expression.symbol))
- expression.superQualifierSymbol?.let { proto.`super` = serializeIrSymbol(it) }
+ .setSymbol(serializeIrSymbol(expression.target.symbol))
+ expression.irSuperQualifier?.let { proto.`super` = serializeIrSymbol(it.symbol) }
expression.receiver?.let { proto.receiver = serializeExpression(it) }
return proto.build()
}
@@ -674,28 +674,28 @@
private fun serializeGetValue(expression: IrGetValue): ProtoGetValue =
ProtoGetValue.newBuilder()
- .setSymbol(serializeIrSymbol(expression.symbol)).apply {
+ .setSymbol(serializeIrSymbol(expression.target.symbol)).apply {
expression.origin?.let { origin = serializeIrStatementOrigin(it) }
}
.build()
private fun serializeGetObject(expression: IrGetObjectValue): ProtoGetObject {
val proto = ProtoGetObject.newBuilder()
- .setSymbol(serializeIrSymbol(expression.symbol))
+ .setSymbol(serializeIrSymbol(expression.target.symbol))
return proto.build()
}
private fun serializeInstanceInitializerCall(call: IrInstanceInitializerCall): ProtoInstanceInitializerCall {
val proto = ProtoInstanceInitializerCall.newBuilder()
- proto.symbol = serializeIrSymbol(call.classSymbol)
+ proto.symbol = serializeIrSymbol(call.irClass.symbol)
return proto.build()
}
private fun serializeReturn(expression: IrReturn): ProtoReturn {
val proto = ProtoReturn.newBuilder()
- .setReturnTarget(serializeIrSymbol(expression.returnTargetSymbol))
+ .setReturnTarget(serializeIrSymbol(expression.irReturnTarget.symbol))
.setValue(serializeExpression(expression.value))
return proto.build()
}
@@ -710,7 +710,7 @@
private fun serializeSetVariable(expression: IrSetVariable): ProtoSetVariable =
ProtoSetVariable.newBuilder()
- .setSymbol(serializeIrSymbol(expression.symbol))
+ .setSymbol(serializeIrSymbol(expression.target.symbol))
.setValue(serializeExpression(expression.value)).apply {
expression.origin?.let { origin = serializeIrStatementOrigin(it) }
}
@@ -1103,8 +1103,8 @@
.setIsTailrec(declaration.isTailrec)
.setIsSuspend(declaration.isSuspend)
- declaration.overriddenSymbols.forEach {
- proto.addOverridden(serializeIrSymbol(it))
+ declaration.overridden.forEach {
+ proto.addOverridden(serializeIrSymbol(it.symbol))
}
return proto.build()
diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt
index 8dfac0d..bda06b5 100644
--- a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt
@@ -223,11 +223,11 @@
}
override fun visitDeclarationReference(expression: IrDeclarationReference) {
- expression.symbol.checkBinding("ref", expression)
+ expression.target.checkBinding("ref", expression)
}
override fun visitFunctionReference(expression: IrFunctionReference) {
- expression.symbol.checkBinding("ref", expression)
+ expression.target.checkBinding("ref", expression)
}
override fun visitPropertyReference(expression: IrPropertyReference) {
@@ -242,11 +242,11 @@
expression.setter?.checkBinding("setter", expression)
}
- private fun IrSymbol.checkBinding(kind: String, irElement: IrElement) {
- if (!isBound) {
- error("${javaClass.simpleName} $descriptor is unbound @$kind ${irElement.render()}")
+ private fun IrSymbolOwner.checkBinding(kind: String, irElement: IrElement) {
+ if (!symbol.isBound) {
+ error("${javaClass.simpleName} ${symbol.descriptor} is unbound @$kind ${irElement.render()}")
} else {
- val irDeclaration = owner as? IrDeclaration
+ val irDeclaration = this as? IrDeclaration
if (irDeclaration != null) {
try {
irDeclaration.parent
@@ -256,9 +256,9 @@
}
}
- val otherSymbol = symbolForDeclaration.getOrPut(owner) { this }
+ val otherSymbol = symbolForDeclaration.getOrPut(this) { symbol }
if (this != otherSymbol) {
- error("Multiple symbols for $descriptor @$kind ${irElement.render()}")
+ error("Multiple symbols for ${symbol.descriptor} @$kind ${irElement.render()}")
}
}
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt
index 02170aa..6e9ff65 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt
@@ -62,7 +62,7 @@
private fun IrClass.declareSimpleFunctionWithExternalOverrides(descriptor: FunctionDescriptor): IrSimpleFunction {
return compilerContext.localSymbolTable.declareSimpleFunction(startOffset, endOffset, SERIALIZABLE_PLUGIN_ORIGIN, descriptor)
.also { f ->
- descriptor.overriddenDescriptors.mapTo(f.overriddenSymbols) {
+ descriptor.overriddenDescriptors.mapTo(f.overridden) {
compilerContext.externalSymbols.referenceSimpleFunction(it.original)
}
}
@@ -79,7 +79,7 @@
f.parent = this
f.returnType = descriptor.returnType!!.toIrType()
if (!fromStubs) f.createParameterDeclarations(this.thisReceiver!!)
- f.body = compilerContext.createIrBuilder(f.symbol).at(this).irBlockBody(this.startOffset, this.endOffset) { bodyGen(f) }
+ f.body = compilerContext.createIrBuilder(f).at(this).irBlockBody(this.startOffset, this.endOffset) { bodyGen(f) }
this.addMember(f)
}
@@ -102,13 +102,13 @@
overwriteValueParameters = overwriteValueParameters,
copyTypeParameters = false
)
- c.body = compilerContext.createIrBuilder(c.symbol).at(this).irBlockBody(this.startOffset, this.endOffset) { bodyGen(c) }
+ c.body = compilerContext.createIrBuilder(c).at(this).irBlockBody(this.startOffset, this.endOffset) { bodyGen(c) }
this.addMember(c)
}
fun IrBuilderWithScope.irInvoke(
dispatchReceiver: IrExpression? = null,
- callee: IrFunctionSymbol,
+ callee: IrFunction,
vararg args: IrExpression,
typeHint: IrType? = null
): IrMemberAccessExpression {
@@ -120,7 +120,7 @@
fun IrBuilderWithScope.irInvoke(
dispatchReceiver: IrExpression? = null,
- callee: IrFunctionSymbol,
+ callee: IrFunction,
typeArguments: List<IrType?>,
valueArguments: List<IrExpression>,
returnTypeHint: IrType? = null
@@ -147,12 +147,12 @@
}
fun IrBuilderWithScope.irBinOp(name: Name, lhs: IrExpression, rhs: IrExpression): IrExpression {
- val symbol = compilerContext.ir.symbols.getBinaryOperator(
+ val function = compilerContext.ir.symbols.getBinaryOperator(
name,
lhs.type.toKotlinType(),
rhs.type.toKotlinType()
)
- return irInvoke(lhs, symbol, rhs)
+ return irInvoke(lhs, function, rhs)
}
fun IrBuilderWithScope.irGetObject(classDescriptor: ClassDescriptor) =
@@ -168,7 +168,7 @@
startOffset,
endOffset,
irObject.defaultType,
- irObject.symbol
+ irObject
)
fun <T : IrDeclaration> T.buildWithScope(builder: (T) -> Unit): T =
@@ -239,7 +239,7 @@
}
fun generateSimplePropertyWithBackingField(
- ownerSymbol: IrValueSymbol,
+ owner: IrValueDeclaration,
propertyDescriptor: PropertyDescriptor,
propertyParent: IrClass
): IrProperty {
@@ -253,10 +253,10 @@
parent = propertyParent
correspondingPropertySymbol = irProperty.symbol
}
- val fieldSymbol = irProperty.backingField!!.symbol
- irProperty.getter = propertyDescriptor.getter?.let { generatePropertyAccessor(it, fieldSymbol) }
+ val field = irProperty.backingField!!
+ irProperty.getter = propertyDescriptor.getter?.let { generatePropertyAccessor(it, field) }
?.apply { parent = propertyParent }
- irProperty.setter = propertyDescriptor.setter?.let { generatePropertyAccessor(it, fieldSymbol) }
+ irProperty.setter = propertyDescriptor.setter?.let { generatePropertyAccessor(it, field) }
?.apply { parent = propertyParent }
return irProperty
}
@@ -276,7 +276,7 @@
fun generatePropertyAccessor(
descriptor: PropertyAccessorDescriptor,
- fieldSymbol: IrFieldSymbol
+ field: IrField
): IrSimpleFunction {
// Declaration can also be called from user code. Since we lookup descriptor getter in externalSymbols
// (see generateSave/generateLoad), seems it is correct approach to declare getter lazily there.
@@ -302,12 +302,12 @@
val endOffset = irAccessor.endOffset
val irBody = IrBlockBodyImpl(startOffset, endOffset)
- val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!.symbol, property)
+ val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!, property)
irBody.statements.add(
IrReturnImpl(
startOffset, endOffset, compilerContext.irBuiltIns.nothingType,
- irAccessor.symbol,
+ irAccessor,
IrGetFieldImpl(
startOffset, endOffset,
compilerContext.localSymbolTable.referenceField(property),
@@ -329,7 +329,7 @@
val endOffset = irAccessor.endOffset
val irBody = IrBlockBodyImpl(startOffset, endOffset)
- val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!.symbol, property)
+ val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!, property)
val irValueParameter = irAccessor.valueParameters.single()
irBody.statements.add(
@@ -337,7 +337,7 @@
startOffset, endOffset,
compilerContext.localSymbolTable.referenceField(property),
receiver,
- IrGetValueImpl(startOffset, endOffset, irValueParameter.type, irValueParameter.symbol),
+ IrGetValueImpl(startOffset, endOffset, irValueParameter.type, irValueParameter),
compilerContext.irBuiltIns.unitType
)
)
@@ -345,16 +345,16 @@
}
fun generateReceiverExpressionForFieldAccess(
- ownerSymbol: IrValueSymbol,
+ owner: IrValueDeclaration,
property: PropertyDescriptor
): IrExpression {
val containingDeclaration = property.containingDeclaration
return when (containingDeclaration) {
is ClassDescriptor ->
IrGetValueImpl(
- ownerSymbol.owner.startOffset, ownerSymbol.owner.endOffset,
+ owner.startOffset, owner.endOffset,
// symbolTable.referenceValue(containingDeclaration.thisAsReceiverParameter)
- ownerSymbol
+ owner
)
else -> throw AssertionError("Property must be in class")
}
@@ -409,7 +409,7 @@
startOffset,
endOffset,
returnType.toIrType(),
- compilerContext.externalSymbols.referenceClassifier(clazz),
+ (compilerContext.externalSymbols.referenceClassifier(clazz) as IrClassSymbol).owner,
classType.toIrType()
)
}
@@ -481,7 +481,7 @@
module: ModuleDescriptor,
type: KotlinType,
expression: IrExpression,
- nullableSerializerClass: IrClassSymbol
+ nullableSerializerClass: IrClass
): IrExpression {
return if (type.isMarkedNullable)
irInvoke(
@@ -591,6 +591,6 @@
}
}
- fun ReferenceSymbolTable.serializableSyntheticConstructor(forClass: ClassDescriptor): IrConstructorSymbol =
+ fun ReferenceSymbolTable.serializableSyntheticConstructor(forClass: ClassDescriptor): IrConstructor =
referenceConstructor(forClass.constructors.single { it.isSerializationCtor() })
}
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt
index c4c36d9..e926100 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt
@@ -152,7 +152,7 @@
endOffset,
compilerContext.irBuiltIns.unitType,
superCtorRef,
- superCtorRef.owner.descriptor
+ superCtorRef.descriptor
)
arguments.forEachIndexed { index, parameter -> call.putValueArgument(index, irGet(parameter)) }
call.insertTypeArgumentsForSuperClass(superClass)
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt
index d52ee6a..43c1628 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt
@@ -15,7 +15,6 @@
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.*
@@ -428,7 +427,7 @@
// todo: set properties in external deserialization
var args: List<IrExpression> = localProps.map { it.get() }
val typeArgs = (loadFunc.returnType as IrSimpleType).arguments.map { (it as IrTypeProjection).type }
- val ctor: IrConstructorSymbol = if (serializableDescriptor.isInternalSerializable) {
+ val ctor: IrConstructor = if (serializableDescriptor.isInternalSerializable) {
args = bitMasks.map { irGet(it) } + args + irNull()
compilerContext.externalSymbols.serializableSyntheticConstructor(serializableDescriptor)
} else {
