[IR] Remove DeclarationDescriptor from IrExpression* tree API

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/AbstractClosureAnnotator.kt

@@ -98,7 +98,7 @@ abstract class AbstractClosureAnnotator : IrElementVisitorVoid {
     override fun visitVariableAccess(expression: IrValueAccessExpression) {
         val closureBuilder = closuresStack.peek() ?: return
 
-        val variableDescriptor = expression.descriptor
+        val variableDescriptor = expression.symbol.descriptor
         if (variableDescriptor.containingDeclaration != closureBuilder.owner) {
             closureBuilder.capturedValues.add(variableDescriptor)
         }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt

@@ -294,7 +294,7 @@ class CheckIrElementVisitor(
         super.visitDeclarationReference(expression)
 
         // TODO: Fix unbound external declarations
-        if (expression.descriptor.isEffectivelyExternal())
+        if (expression.symbol.descriptor.isEffectivelyExternal())
             return
 
         // TODO: Fix unbound dynamic filed declarations

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DumpIrTreeWithDescriptorsVisitor.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.backend.common
 
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.ir.IrElement
@@ -87,38 +88,38 @@ class RenderIrElementWithDescriptorsVisitor : IrElementVisitor<String, Nothing?>
         "RETURN type=${expression.type.render()} from='${expression.returnTarget}'"
 
     override fun visitCall(expression: IrCall, data: Nothing?): String =
-        "CALL '${expression.descriptor}' ${expression.renderSuperQualifier()}" +
+        "CALL '${expression.symbol.descriptor}' ${expression.renderSuperQualifier()}" +
                 "type=${expression.type.render()} origin=${expression.origin}"
 
     private fun IrCall.renderSuperQualifier(): String =
         superQualifierSymbol?.let { "superQualifier=${it.owner.name} " } ?: ""
 
     override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?): String =
-        "DELEGATING_CONSTRUCTOR_CALL '${expression.descriptor}'"
+        "DELEGATING_CONSTRUCTOR_CALL '${expression.symbol.descriptor}'"
 
     override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?): String =
-        "ENUM_CONSTRUCTOR_CALL '${expression.descriptor}'"
+        "ENUM_CONSTRUCTOR_CALL '${expression.symbol.descriptor}'"
 
     override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?): String =
         "INSTANCE_INITIALIZER_CALL classDescriptor='${expression.classDescriptor}'"
 
     override fun visitGetValue(expression: IrGetValue, data: Nothing?): String =
-        "GET_VAR '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
+        "GET_VAR '${expression.symbol.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
 
     override fun visitSetVariable(expression: IrSetVariable, data: Nothing?): String =
-        "SET_VAR '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
+        "SET_VAR '${expression.symbol.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
 
     override fun visitGetField(expression: IrGetField, data: Nothing?): String =
-        "GET_FIELD '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
+        "GET_FIELD '${expression.symbol.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
 
     override fun visitSetField(expression: IrSetField, data: Nothing?): String =
-        "SET_FIELD '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
+        "SET_FIELD '${expression.symbol.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
 
     override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?): String =
-        "GET_OBJECT '${expression.descriptor}' type=${expression.type.render()}"
+        "GET_OBJECT '${expression.symbol.descriptor}' type=${expression.type.render()}"
 
     override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?): String =
-        "GET_ENUM '${expression.descriptor}' type=${expression.type.render()}"
+        "GET_ENUM '${expression.symbol.descriptor}' type=${expression.type.render()}"
 
     override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?): String =
         "STRING_CONCATENATION type=${expression.type.render()}"
@@ -148,10 +149,10 @@ class RenderIrElementWithDescriptorsVisitor : IrElementVisitor<String, Nothing?>
         "THROW type=${expression.type.render()}"
 
     override fun visitCallableReference(expression: IrCallableReference, data: Nothing?): String =
-        "CALLABLE_REFERENCE '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
+        "CALLABLE_REFERENCE '${expression.symbol.descriptor}' type=${expression.type.render()} origin=${expression.origin}"
 
     override fun visitClassReference(expression: IrClassReference, data: Nothing?): String =
-        "CLASS_REFERENCE '${expression.descriptor}' type=${expression.type.render()}"
+        "CLASS_REFERENCE '${expression.symbol.descriptor}' type=${expression.type.render()}"
 
     override fun visitGetClass(expression: IrGetClass, data: Nothing?): String =
         "GET_CLASS type=${expression.type.render()}"
@@ -271,16 +272,18 @@ class DumpIrTreeWithDescriptorsVisitor(out: Appendable) : IrElementVisitor<Unit,
         expression.dumpLabeledElementWith(data) {
             dumpTypeArguments(expression)
 
+            val descriptor = expression.symbol.descriptor as CallableDescriptor
             expression.dispatchReceiver?.accept(this, "\$this")
             expression.extensionReceiver?.accept(this, "\$receiver")
-            for (valueParameter in expression.descriptor.valueParameters) {
+            for (valueParameter in descriptor.valueParameters) {
                 expression.getValueArgument(valueParameter.index)?.accept(this, valueParameter.name.asString())
             }
         }
     }
 
     private fun dumpTypeArguments(expression: IrMemberAccessExpression) {
-        for (typeParameter in expression.descriptor.original.typeParameters) {
+        val descriptor = expression.symbol.descriptor as CallableDescriptor
+        for (typeParameter in descriptor.original.typeParameters) {
             val typeArgument = expression.getTypeArgument(typeParameter) ?: continue
             val renderedParameter = DescriptorRenderer.ONLY_NAMES_WITH_SHORT_TYPES.render(typeParameter)
             val renderedType = typeArgument.render()

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt

@@ -97,7 +97,7 @@ abstract class AbstractValueUsageTransformer(
         with(expression) {
             dispatchReceiver = dispatchReceiver?.useAsDispatchReceiver(expression)
             extensionReceiver = extensionReceiver?.useAsExtensionReceiver(expression)
-            for (index in descriptor.valueParameters.indices) {
+            for (index in 0 until valueArgumentsCount) {
                 val argument = getValueArgument(index) ?: continue
                 val parameter = symbol.owner.valueParameters[index]
                 putValueArgument(index, argument.useAsValueArgument(expression, parameter))

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt

@@ -76,7 +76,7 @@ private class KCallableNamePropertyTransformer(val lower: KCallableNamePropertyL
                     expression.startOffset,
                     expression.endOffset,
                     lower.context.irBuiltIns.stringType,
-                    callableReference.descriptor.name.asString()
+                    callableReference.symbol.descriptor.name.asString()
                 )
             )
         }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/FunctionInlining.kt

@@ -136,7 +136,7 @@ class FunctionInlining(val context: CommonBackendContext) : IrElementTransformer
             statements.transform { it.transform(transformer, data = null) }
             statements.addAll(0, evaluationStatements)
 
-            val isCoroutineIntrinsicCall = callSite.descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(
+            val isCoroutineIntrinsicCall = callSite.symbol.descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(
                 context.configuration.languageVersionSettings
             )
 
@@ -434,10 +434,12 @@ class FunctionInlining(val context: CommonBackendContext) : IrElementTransformer
                 val variableInitializer = it.argumentExpression.transform(substitutor, data = null) // Arguments may reference the previous ones - substitute them.
                 val newVariable =
                     currentScope.scope.createTemporaryVariableWithWrappedDescriptor(
-                        irExpression = IrBlockImpl (variableInitializer.startOffset,
+                        irExpression = IrBlockImpl(
-                                variableInitializer.endOffset,
+                            variableInitializer.startOffset,
-                                variableInitializer.type,
+                            variableInitializer.endOffset,
-                                InlinerExpressionLocationHint((currentScope.irElement as IrSymbolOwner).symbol)).apply {
+                            variableInitializer.type,
+                            InlinerExpressionLocationHint((currentScope.irElement as IrSymbolOwner).symbol)
+                        ).apply {
                             statements.add(variableInitializer)
                         },
                         nameHint = callee.symbol.owner.name.toString(),
@@ -454,10 +456,10 @@ class FunctionInlining(val context: CommonBackendContext) : IrElementTransformer
     private class IrGetValueWithoutLocation(
         symbol: IrValueSymbol,
         override val origin: IrStatementOrigin? = null
-    ) : IrTerminalDeclarationReferenceBase<IrValueSymbol, ValueDescriptor>(
+    ) : IrTerminalDeclarationReferenceBase<IrValueSymbol>(
         UNDEFINED_OFFSET, UNDEFINED_OFFSET,
         symbol.owner.type,
-        symbol, symbol.descriptor
+        symbol
     ), IrGetValue {
         override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D) =
             visitor.visitGetValue(this, data)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt

@@ -361,7 +361,7 @@ class ExpressionCodegen(
                     }
                 }
             }
-            expression.descriptor is ConstructorDescriptor ->
+            expression.symbol.descriptor is ConstructorDescriptor ->
                 throw AssertionError("IrCall with ConstructorDescriptor: ${expression.javaClass.simpleName}")
             callee.isSuspend && !irFunction.shouldNotContainSuspendMarkers(classCodegen.context) ->
                 addInlineMarker(mv, isStartNotEnd = true)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt

@@ -54,7 +54,7 @@ class IrSourceCompilerForInline(
         get() = codegen.context.psiSourceManager.getKtFile(codegen.irFunction.fileParent)
 
     override val contextKind: OwnerKind
-        get() = OwnerKind.getMemberOwnerKind(callElement.descriptor.containingDeclaration)
+        get() = OwnerKind.getMemberOwnerKind(callElement.symbol.descriptor.containingDeclaration!!)
 
     override val inlineCallSiteInfo: InlineCallSiteInfo
         get() {
@@ -94,7 +94,7 @@ class IrSourceCompilerForInline(
         callDefault: Boolean,
         asmMethod: Method
     ): SMAPAndMethodNode {
-        assert(callableDescriptor == callee.descriptor.original) { "Expected $callableDescriptor got ${callee.descriptor.original}" }
+        assert(callableDescriptor == callee.symbol.descriptor.original) { "Expected $callableDescriptor got ${callee.descriptor.original}" }
         val irFunction = getFunctionToInline(jvmSignature, callDefault)
         return makeInlineNode(irFunction, FakeClassCodegen(irFunction, codegen.classCodegen), false)
     }
@@ -144,10 +144,10 @@ class IrSourceCompilerForInline(
     }
 
     override val compilationContextDescriptor: DeclarationDescriptor
-        get() = callElement.descriptor
+        get() = callElement.symbol.descriptor
 
     override val compilationContextFunctionDescriptor: FunctionDescriptor
-        get() = callElement.descriptor as FunctionDescriptor
+        get() = callElement.symbol.descriptor as FunctionDescriptor
 
     override fun getContextLabels(): Set<String> {
         val name = codegen.irFunction.name.asString()

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt

@@ -203,7 +203,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class
                     irCall(referenceKind.wrapper).apply {
                         putValueArgument(0, irCall(referenceKind.reflectedSymbol.constructors.single()).apply {
                             putValueArgument(0, buildReflectedContainerReference(expression))
-                            putValueArgument(1, irString(expression.descriptor.name.asString()))
+                            putValueArgument(1, irString(expression.symbol.descriptor.name.asString()))
                             putValueArgument(2, irString(expression.signature))
                         })
                     }
@@ -262,7 +262,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class
                 val invoke = superClass.functions.find { it.name.asString() == "invoke" }
 
                 referenceClass.addSimpleDelegatingConstructor(superConstructor, context.irBuiltIns, isPrimary = true)
-                referenceClass.addOverride(getName) { irString(expression.descriptor.name.asString()) }
+                referenceClass.addOverride(getName) { irString(expression.symbol.descriptor.name.asString()) }
                 referenceClass.addOverride(getOwner) { buildReflectedContainerReference(expression) }
                 referenceClass.addOverride(getSignature) { irString(expression.signature) }
 

compiler/ir/ir.ir2cfg/src/org/jetbrains/kotlin/ir2cfg/generators/FunctionGenerator.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.ir2cfg.generators
 
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrFunction
@@ -176,7 +177,8 @@ class FunctionGenerator(val function: IrFunction) {
         override fun visitMemberAccess(expression: IrMemberAccessExpression, data: Boolean): IrStatement? {
             expression.dispatchReceiver?.process()
             expression.extensionReceiver?.process()
-            for (valueParameter in expression.descriptor.valueParameters) {
+            val descriptor = expression.symbol.descriptor as CallableDescriptor
+            for (valueParameter in descriptor.valueParameters) {
                 expression.getValueArgument(valueParameter)?.process()
             }
             if (data) {

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt

@@ -130,12 +130,12 @@ open class InsertImplicitCasts(
 
     override fun visitSetVariable(expression: IrSetVariable): IrExpression =
         expression.transformPostfix {
-            value = value.cast(expression.descriptor.type)
+            value = value.cast(expression.symbol.descriptor.type)
         }
 
     override fun visitSetField(expression: IrSetField): IrExpression =
         expression.transformPostfix {
-            value = value.cast(expression.descriptor.type)
+            value = value.cast(expression.symbol.descriptor.type)
         }
 
     override fun visitVariable(declaration: IrVariable): IrVariable =

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt

@@ -16,21 +16,15 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
 import org.jetbrains.kotlin.ir.symbols.*
 
-interface IrCallableReference : IrMemberAccessExpression {
+interface IrCallableReference : IrMemberAccessExpression
-}
 
 interface IrFunctionReference : IrCallableReference {
-    override val descriptor: FunctionDescriptor
     override val symbol: IrFunctionSymbol
 }
 
 interface IrPropertyReference : IrCallableReference {
-    override val descriptor: PropertyDescriptor
     override val symbol: IrPropertySymbol
     val field: IrFieldSymbol?
     val getter: IrSimpleFunctionSymbol?
@@ -38,7 +32,6 @@ interface IrPropertyReference : IrCallableReference {
 }
 
 interface IrLocalDelegatedPropertyReference : IrCallableReference {
-    override val descriptor: VariableDescriptorWithAccessors
     override val symbol: IrLocalDelegatedPropertySymbol
     val delegate: IrVariableSymbol
     val getter: IrSimpleFunctionSymbol

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrClassReference.kt

@@ -16,13 +16,11 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 
 
 interface IrClassReference : IrDeclarationReference {
-    override val descriptor: ClassifierDescriptor
     override val symbol: IrClassifierSymbol
     val classType: IrType
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrConstructorCall.kt

@@ -5,12 +5,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.types.IrType
 
 interface IrConstructorCall : IrFunctionAccessExpression {
-    override val descriptor: ClassConstructorDescriptor
     override val symbol: IrConstructorSymbol
 
     val constructorTypeArgumentsCount: Int

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDeclarationReference.kt

@@ -16,21 +16,16 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-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
 
 
 interface IrDeclarationReference : IrExpression {
-    val descriptor: DeclarationDescriptor
     val symbol: IrSymbol
 }
 
-interface IrGetSingletonValue : IrDeclarationReference {
+interface IrGetSingletonValue : IrDeclarationReference
-    override val descriptor: ClassDescriptor
-}
 
 interface IrGetObjectValue : IrGetSingletonValue {
     override val symbol: IrClassSymbol

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrDelegatingConstructorCall.kt

@@ -16,11 +16,9 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 
 interface IrDelegatingConstructorCall : IrFunctionAccessExpression {
-    override val descriptor: ClassConstructorDescriptor
     override val symbol: IrConstructorSymbol
 }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrEnumConstructorCall.kt

@@ -16,11 +16,9 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 
 
 interface IrEnumConstructorCall : IrFunctionAccessExpression {
-    override val descriptor: ClassConstructorDescriptor
     override val symbol: IrConstructorSymbol
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrFieldAccessExpression.kt

@@ -16,16 +16,12 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-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
 
 interface IrFieldAccessExpression : IrDeclarationReference {
-    override val descriptor: PropertyDescriptor
     override val symbol: IrFieldSymbol
 
-    val superQualifier: ClassDescriptor?
     val superQualifierSymbol: IrClassSymbol?
 
     var receiver: IrExpression?

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt

@@ -19,7 +19,6 @@ interface IrMemberAccessExpression : IrExpression, IrDeclarationReference {
     var dispatchReceiver: IrExpression?
     var extensionReceiver: IrExpression?
 
-    override val descriptor: CallableDescriptor
     override val symbol: IrSymbol
 
     val origin: IrStatementOrigin?
@@ -67,7 +66,6 @@ fun IrMemberAccessExpression.getTypeArgumentOrDefault(irTypeParameter: IrTypePar
     getTypeArgument(irTypeParameter.index) ?: irTypeParameter.defaultType
 
 interface IrFunctionAccessExpression : IrMemberAccessExpression {
-    override val descriptor: FunctionDescriptor
     override val symbol: IrFunctionSymbol
 }
 
@@ -84,6 +82,7 @@ fun IrMemberAccessExpression.removeValueArgument(valueParameterDescriptor: Value
 
 inline fun <T : IrMemberAccessExpression> T.mapTypeParameters(transform: (TypeParameterDescriptor) -> IrType) : T =
     apply {
+        val descriptor = symbol.descriptor as CallableDescriptor
         descriptor.typeParameters.forEach {
             putTypeArgument(it.index, transform(it))
         }
@@ -91,6 +90,7 @@ inline fun <T : IrMemberAccessExpression> T.mapTypeParameters(transform: (TypePa
 
 inline fun <T : IrMemberAccessExpression> T.mapValueParameters(transform: (ValueParameterDescriptor) -> IrExpression?): T =
     apply {
+        val descriptor = symbol.descriptor as CallableDescriptor
         descriptor.valueParameters.forEach {
             putValueArgument(it.index, transform(it))
         }
@@ -98,6 +98,7 @@ inline fun <T : IrMemberAccessExpression> T.mapValueParameters(transform: (Value
 
 inline fun <T : IrMemberAccessExpression> T.mapValueParametersIndexed(transform: (Int, ValueParameterDescriptor) -> IrExpression?): T =
     apply {
+        val descriptor = symbol.descriptor as CallableDescriptor
         descriptor.valueParameters.forEach {
             putValueArgument(it.index, transform(it.index, it))
         }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrValueAccessExpression.kt

@@ -16,13 +16,10 @@
 
 package org.jetbrains.kotlin.ir.expressions
 
-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
 
 interface IrValueAccessExpression : IrDeclarationReference {
-    override val descriptor: ValueDescriptor
     override val symbol: IrValueSymbol
     val origin: IrStatementOrigin?
 }
@@ -32,7 +29,6 @@ interface IrGetValue : IrValueAccessExpression, IrExpressionWithCopy {
 }
 
 interface IrSetVariable : IrValueAccessExpression {
-    override val descriptor: VariableDescriptor
     override val symbol: IrVariableSymbol
     var value: IrExpression
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.expressions.typeParametersCount
@@ -50,8 +49,6 @@ class IrCallImpl(
         }
     }
 
-    override val descriptor: FunctionDescriptor get() = symbol.descriptor
-
     constructor(
         startOffset: Int,
         endOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrClassReferenceImpl.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrClassReference
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -28,14 +27,7 @@ class IrClassReferenceImpl(
     type: IrType,
     symbol: IrClassifierSymbol,
     override val classType: IrType
-) :
+) : IrTerminalDeclarationReferenceBase<IrClassifierSymbol>(startOffset, endOffset, type, symbol), IrClassReference {
-    IrTerminalDeclarationReferenceBase<IrClassifierSymbol, ClassifierDescriptor>(
-        startOffset, endOffset, type,
-        symbol, symbol.descriptor
-    ),
-    IrClassReference {
-
-    override val descriptor: ClassifierDescriptor get() = symbol.descriptor
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitClassReference(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt

@@ -30,8 +30,6 @@ class IrConstructorCallImpl(
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitConstructorCall(this, data)
 
-    override val descriptor: ClassConstructorDescriptor get() = symbol.descriptor
-
     companion object {
 
         fun fromSymbolDescriptor(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDeclarationReferenceBase.kt

@@ -16,17 +16,15 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 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 : IrSymbol>(
     startOffset: Int,
     endOffset: Int,
     type: IrType,
-    override val symbol: S,
+    override val symbol: S
-    override val descriptor: D
 ) :
     IrExpressionBase(startOffset, endOffset, type),
     IrDeclarationReference

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt

@@ -55,8 +55,6 @@ class IrDelegatingConstructorCallImpl(
         typeArgumentsCount: Int
     ) : this(startOffset, endOffset, type, symbol, typeArgumentsCount, symbol.descriptor.valueParameters.size)
 
-    override val descriptor: ClassConstructorDescriptor get() = symbol.descriptor
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitDelegatingConstructorCall(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
 import org.jetbrains.kotlin.ir.expressions.typeParametersCount
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
@@ -55,8 +54,6 @@ class IrEnumConstructorCallImpl(
         typeArgumentsCount: Int
     ) : this(startOffset, endOffset, type, symbol, typeArgumentsCount, symbol.descriptor.valueParameters.size)
 
-    override val descriptor: ClassConstructorDescriptor get() = symbol.descriptor
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitEnumConstructorCall(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFieldExpressionBase.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
@@ -35,8 +33,5 @@ abstract class IrFieldExpressionBase(
     IrExpressionBase(startOffset, endOffset, type),
     IrFieldAccessExpression {
 
-    override val descriptor: PropertyDescriptor get() = symbol.descriptor
-    override val superQualifier: ClassDescriptor? get() = superQualifierSymbol?.descriptor
-
     final override var receiver: IrExpression? = null
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
@@ -51,8 +50,6 @@ class IrFunctionReferenceImpl(
         origin: IrStatementOrigin? = null
     ) : this(startOffset, endOffset, type, symbol, typeArgumentsCount, symbol.descriptor.valueParameters.size, origin)
 
-    override val descriptor: FunctionDescriptor get() = symbol.descriptor
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitFunctionReference(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetEnumValueImpl.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
 import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -27,9 +26,7 @@ class IrGetEnumValueImpl(
     endOffset: Int,
     type: IrType,
     symbol: IrEnumEntrySymbol
-) :
+) : IrTerminalDeclarationReferenceBase<IrEnumEntrySymbol>(startOffset, endOffset, type, symbol), IrGetEnumValue {
-    IrTerminalDeclarationReferenceBase<IrEnumEntrySymbol, ClassDescriptor>(startOffset, endOffset, type, symbol, symbol.descriptor),
-    IrGetEnumValue {
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitGetEnumValue(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetObjectValueImpl.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -27,9 +26,7 @@ class IrGetObjectValueImpl(
     endOffset: Int,
     type: IrType,
     symbol: IrClassSymbol
-) :
+) : IrTerminalDeclarationReferenceBase<IrClassSymbol>(startOffset, endOffset, type, symbol), IrGetObjectValue {
-    IrTerminalDeclarationReferenceBase<IrClassSymbol, ClassDescriptor>(startOffset, endOffset, type, symbol, symbol.descriptor),
-    IrGetObjectValue {
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitGetObjectValue(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetValueImpl.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.ValueDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
@@ -19,12 +18,11 @@ class IrGetValueImpl(
     symbol: IrValueSymbol,
     override val origin: IrStatementOrigin? = null
 ) :
-    IrTerminalDeclarationReferenceBase<IrValueSymbol, ValueDescriptor>(
+    IrTerminalDeclarationReferenceBase<IrValueSymbol>(
         startOffset,
         endOffset,
         type,
-        symbol,
+        symbol
-        symbol.descriptor
     ),
     IrGetValue {
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt

@@ -38,9 +38,6 @@ class IrLocalDelegatedPropertyReferenceImpl(
     IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, 0, origin),
     IrLocalDelegatedPropertyReference {
 
-    override val descriptor: VariableDescriptorWithAccessors
-        get() = symbol.descriptor
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitLocalDelegatedPropertyReference(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrNoArgumentsCallableReferenceBase.kt

@@ -32,7 +32,7 @@ abstract class IrNoArgumentsCallableReferenceBase(
     IrCallableReference {
 
     private fun throwNoValueArguments(): Nothing {
-        throw UnsupportedOperationException("Property reference $descriptor has no value arguments")
+        throw UnsupportedOperationException("Property reference ${symbol.descriptor} has no value arguments")
     }
 
     override fun getValueArgument(index: Int): IrExpression? = throwNoValueArguments()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt

@@ -57,8 +57,6 @@ class IrPropertyReferenceImpl(
         typeArgumentsCount, field, getter, setter, origin
     )
 
-    override val descriptor: PropertyDescriptor get() = symbol.descriptor
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitPropertyReference(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetVariableImpl.kt

@@ -46,8 +46,6 @@ class IrSetVariableImpl(
         this.value = value
     }
 
-    override val descriptor: VariableDescriptor get() = symbol.descriptor
-
     override lateinit var value: IrExpression
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalDeclarationReferenceBase.kt

@@ -16,21 +16,19 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 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 : IrSymbol>(
     startOffset: Int,
     endOffset: Int,
     type: IrType,
-    symbol: S,
+    symbol: S
-    descriptor: D
 ) :
-    IrDeclarationReferenceBase<S, D>(startOffset, endOffset, type, symbol, descriptor),
+    IrDeclarationReferenceBase<S>(startOffset, endOffset, type, symbol),
     IrDeclarationReference {
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.utils.DFS
  */
 fun IrMemberAccessExpression.getArguments(): List<Pair<ParameterDescriptor, IrExpression>> {
     val res = mutableListOf<Pair<ParameterDescriptor, IrExpression>>()
-    val descriptor = descriptor
+    val descriptor = symbol.descriptor as CallableDescriptor
 
     // TODO: ensure the order below corresponds to the one defined in Kotlin specs.
 
@@ -119,6 +119,7 @@ fun IrMemberAccessExpression.getArgumentsWithIr(): List<Pair<IrValueParameter, I
  * Sets arguments that are specified by given mapping of parameters.
  */
 fun IrMemberAccessExpression.addArguments(args: Map<ParameterDescriptor, IrExpression>) {
+    val descriptor = symbol.descriptor as CallableDescriptor
     descriptor.dispatchReceiverParameter?.let {
         val arg = args[it]
         if (arg != null) {
@@ -177,7 +178,7 @@ fun IrExpression.coerceToUnitIfNeeded(valueType: IrType, irBuiltIns: IrBuiltIns)
 }
 
 fun IrMemberAccessExpression.usesDefaultArguments(): Boolean =
-    this.descriptor.valueParameters.any { this.getValueArgument(it) == null }
+    (symbol.descriptor as CallableDescriptor).valueParameters.any { this.getValueArgument(it) == null }
 
 val DeclarationDescriptorWithSource.startOffset: Int? get() = (this.source as? PsiSourceElement)?.psi?.startOffset
 val DeclarationDescriptorWithSource.endOffset: Int? get() = (this.source as? PsiSourceElement)?.psi?.endOffset
@@ -383,7 +384,7 @@ fun IrDeclaration.isEffectivelyExternal(): Boolean {
 
     fun IrFunction.effectiveParentDeclaration(): IrDeclaration? =
         when (this) {
-            is IrSimpleFunction -> correspondingProperty ?: parent as? IrDeclaration
+            is IrSimpleFunction -> correspondingPropertySymbol?.owner ?: parent as? IrDeclaration
             else -> parent as? IrDeclaration
         }
 

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt

@@ -424,7 +424,7 @@ interface IrBuilderExtension {
             val irExpression =
                 if (i is IrGetValueImpl && i.origin == IrStatementOrigin.INITIALIZE_PROPERTY_FROM_PARAMETER) {
                     // this is a primary constructor property, use corresponding default of value parameter
-                    defaultsMap.getValue(i.descriptor as ParameterDescriptor)
+                    defaultsMap.getValue(i.symbol.descriptor as ParameterDescriptor)
                 } else {
                     i
                 }

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt

@@ -149,7 +149,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
         method: IrFunctionSymbol
     ) {
         annotations.forEach { annotationCall ->
-            if ((annotationCall.descriptor as? ClassConstructorDescriptor)?.constructedClass?.isSerialInfoAnnotation == true)
+            if ((annotationCall.symbol.descriptor as? ClassConstructorDescriptor)?.constructedClass?.isSerialInfoAnnotation == true)
                 +irInvoke(irGet(receiver), method, annotationCall.deepCopyWithVariables())
         }
     }
@@ -394,7 +394,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
                                         }
                                 val typeArgs =
                                     if (decodeFuncToCall.owner.typeParameters.isNotEmpty()) listOf(property.type.toIrType()) else listOf()
-                                val args = mutableListOf(localSerialDesc.get(), irInt(index))
+                                val args = mutableListOf<IrExpression>(localSerialDesc.get(), irInt(index))
                                 if (innerSerial != null)
                                     args.add(innerSerial)
                                 // local$i = localInput.decode...(...)
@@ -457,7 +457,7 @@ open class SerializerIrGenerator(val irClass: IrClass, final override val compil
             context: BackendContext,
             bindingContext: BindingContext
         ) {
-            val serializableDesc = getSerializableClassDescriptorBySerializer(irClass.descriptor) ?: return
+            val serializableDesc = getSerializableClassDescriptorBySerializer(irClass.symbol.descriptor) ?: return
             if (serializableDesc.isSerializableEnum()) {
                 SerializerForEnumsGenerator(irClass, context, bindingContext).generate()
             } else {