[IR] Adjust code to generic IrFunctionAccessExpression WIP

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 5e97705..b4d4b4d 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

@@ -291,7 +291,7 @@
         }
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>) {
         super.visitFunctionAccess(expression)
 
         expression.symbol.ensureBound(expression)

diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/NoInlineFunctionUseSitesValidator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/NoInlineFunctionUseSitesValidator.kt
index 51485e8..08db6c3 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/NoInlineFunctionUseSitesValidator.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/NoInlineFunctionUseSitesValidator.kt

@@ -26,7 +26,7 @@
         parentChain.pop()
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>) {
         super.visitFunctionAccess(expression)
         checkFunctionUseSite(expression)
     }
@@ -36,7 +36,7 @@
         checkFunctionUseSite(expression)
     }
 
-    private fun checkFunctionUseSite(expression: IrMemberAccessExpression<IrFunctionSymbol>) {
+    private fun checkFunctionUseSite(expression: IrFunctionAccessExpression<IrFunctionSymbol>) {
         val function = expression.symbol.owner
         if (!function.isInline || inlineFunctionUseSiteChecker.isPermitted(expression)) return
         reportError(function, expression)

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 679513b..03805eb 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

@@ -50,14 +50,14 @@
     protected open fun IrExpression.useAsArgument(parameter: IrValueParameter): IrExpression =
         this.useAsValue(parameter)
 
-    protected open fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression): IrExpression =
+    protected open fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression<*>): IrExpression =
         this.useAsArgument(expression.symbol.owner.dispatchReceiverParameter!!)
 
-    protected open fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression): IrExpression =
+    protected open fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression<*>): IrExpression =
         this.useAsArgument(expression.symbol.owner.extensionReceiverParameter!!)
 
     protected open fun IrExpression.useAsValueArgument(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         parameter: IrValueParameter
     ): IrExpression =
         this.useAsArgument(parameter)
@@ -92,7 +92,7 @@
   //      TODO()
   //  }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         expression.transformChildrenVoid(this)
 
         with(expression) {

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 7487402..45441ac 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

@@ -281,7 +281,7 @@
             super.visitVariable(declaration, data)
         }
 
-        override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: ClosureBuilder?) {
+        override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: ClosureBuilder?) {
             super.visitFunctionAccess(expression, data)
             processScriptCapturing(expression.dispatchReceiver, expression.symbol.owner, data)
             processMemberAccess(expression.symbol.owner, data)

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 06b6cd3..3249ee7 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

@@ -269,11 +269,11 @@
         declarationStack.pop()
     }
 
-    protected open fun shouldReplaceWithSyntheticFunction(functionAccess: IrFunctionAccessExpression): Boolean {
+    protected open fun shouldReplaceWithSyntheticFunction(functionAccess: IrFunctionAccessExpression<*>): Boolean {
         return (0 until functionAccess.valueArgumentsCount).count { functionAccess.getValueArgument(it) != null } != functionAccess.symbol.owner.valueParameters.size
     }
 
-    private fun <T : IrFunctionAccessExpression> visitFunctionAccessExpression(expression: T, builder: (IrFunctionSymbol) -> T): IrExpression {
+    private fun <T : IrFunctionAccessExpression<*>> visitFunctionAccessExpression(expression: T, builder: (IrFunctionSymbol) -> T): IrExpression {
         if (!shouldReplaceWithSyntheticFunction(expression))
             return expression
 
@@ -373,7 +373,7 @@
         }
     }
 
-    private fun createStubFunction(expression: IrFunctionAccessExpression): IrFunctionSymbol? {
+    private fun createStubFunction(expression: IrFunctionAccessExpression<*>): IrFunctionSymbol? {
         val declaration = expression.symbol.owner
 
         // We *have* to find the actual function here since on the JVM, a default stub for a function implemented
@@ -396,7 +396,7 @@
         return stubFunction.symbol
     }
 
-    protected open fun IrBlockBuilder.argumentsForCall(expression: IrFunctionAccessExpression, stubFunction: IrFunction): Map<IrValueParameter, IrExpression?> {
+    protected open fun IrBlockBuilder.argumentsForCall(expression: IrFunctionAccessExpression<*>, stubFunction: IrFunction): Map<IrValueParameter, IrExpression?> {
         val startOffset = expression.startOffset
         val endOffset = expression.endOffset
         val declaration = expression.symbol.owner

diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/SyntheticAccessorGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/SyntheticAccessorGenerator.kt
index 7e4500c..52fbb72 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/SyntheticAccessorGenerator.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/SyntheticAccessorGenerator.kt

@@ -58,7 +58,7 @@
         private var IrField.setterSyntheticAccessors: MutableMap<AccessorKey, IrSimpleFunction>? by irAttribute(followAttributeOwner = false)
     }
 
-    fun getSyntheticFunctionAccessor(expression: IrFunctionAccessExpression, scopeInfo: ScopeInfo): IrFunction {
+    fun getSyntheticFunctionAccessor(expression: IrFunctionAccessExpression<*>, scopeInfo: ScopeInfo): IrFunction {
         return if (expression is IrCall)
             createAccessor(expression.symbol, scopeInfo, expression.dispatchReceiver?.type, expression.superQualifierSymbol)
         else
@@ -305,7 +305,7 @@
     }
 
     protected fun copyAllParamsToArgs(
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         syntheticFunction: IrFunction
     ) {
         var typeArgumentOffset = 0
@@ -407,9 +407,9 @@
      * ```
      */
     fun modifyFunctionAccessExpression(
-        oldExpression: IrFunctionAccessExpression,
+        oldExpression: IrFunctionAccessExpression<*>,
         accessorSymbol: IrFunctionSymbol
-    ): IrFunctionAccessExpression {
+    ): IrFunctionAccessExpression<*> {
         val newExpression = when {
             oldExpression is IrDelegatingConstructorCall -> accessorSymbol.produceCallToSyntheticDelegatingConstructor(oldExpression)
             oldExpression is IrEnumConstructorCall -> compilationException(
@@ -431,7 +431,7 @@
     }
 
     private fun IrFunctionSymbol.produceCallToSyntheticFunction(
-        oldExpression: IrFunctionAccessExpression
+        oldExpression: IrFunctionAccessExpression<*>
     ): IrCall {
         return IrCallImpl.fromSymbolOwner(
             oldExpression.startOffset, oldExpression.endOffset,
@@ -442,7 +442,7 @@
     }
 
     private fun IrFunctionSymbol.produceCallToSyntheticDelegatingConstructor(
-        oldExpression: IrFunctionAccessExpression
+        oldExpression: IrFunctionAccessExpression<*>
     ): IrDelegatingConstructorCall {
         return IrDelegatingConstructorCallImpl.fromSymbolOwner(
             oldExpression.startOffset, oldExpression.endOffset,
@@ -452,8 +452,8 @@
     }
 
     private fun IrFunctionSymbol.produceCallToSyntheticConstructor(
-        oldExpression: IrFunctionAccessExpression
-    ): IrFunctionAccessExpression {
+        oldExpression: IrFunctionAccessExpression<*>
+    ): IrFunctionAccessExpression<*> {
         return IrConstructorCallImpl.fromSymbolOwner(
             oldExpression.startOffset, oldExpression.endOffset,
             oldExpression.type,

diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/dce/UsefulDeclarationProcessor.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/dce/UsefulDeclarationProcessor.kt
index 1f66147..7d2d4af 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/dce/UsefulDeclarationProcessor.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/dce/UsefulDeclarationProcessor.kt

@@ -42,7 +42,7 @@
             element.acceptChildren(this, data)
         }
 
-        override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: IrDeclaration) {
+        override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: IrDeclaration) {
             super.visitFunctionAccess(expression, data)
             expression.symbol.owner.enqueue(data, "function access")
         }

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 9a467d1..49933e5 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

@@ -82,7 +82,7 @@
 
     override fun IrExpression.useAs(type: IrType): IrExpression = useExpressionAsType(getActualType(), type)
 
-    private val IrFunctionAccessExpression.target: IrFunction
+    private val IrFunctionAccessExpression<*>.target: IrFunction
         get() = when (this) {
             is IrConstructorCall -> this.symbol.owner
             is IrDelegatingConstructorCall -> this.symbol.owner
@@ -94,19 +94,19 @@
         get() = symbol.owner.realOverrideTarget
 
 
-    override fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression): IrExpression {
+    override fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression<*>): IrExpression {
         return if (expression.symbol.owner.dispatchReceiverParameter?.let { icUtils.shouldValueParameterBeBoxed(it) } == true)
             this.useAs(irBuiltIns.anyType)
         else
             this.useAsArgument(expression.target.dispatchReceiverParameter!!)
     }
 
-    override fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression): IrExpression {
+    override fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression<*>): IrExpression {
         return this.useAsArgument(expression.target.extensionReceiverParameter!!)
     }
 
     override fun IrExpression.useAsValueArgument(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         parameter: IrValueParameter
     ): IrExpression {
 

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 4803b83..e5a3fca 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

@@ -306,7 +306,7 @@
             return countImpl(parent)
         }
 
-        private fun IrSimpleFunction.buildInvoke(): IrFunctionAccessExpression {
+        private fun IrSimpleFunction.buildInvoke(): IrFunctionAccessExpression<*> {
             val callee = function
             val irCall = reference.run {
                 when (callee) {

diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ES6ConstructorLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ES6ConstructorLowering.kt
index df49d56..4bbf948 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ES6ConstructorLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/ES6ConstructorLowering.kt

@@ -43,13 +43,13 @@
 val IrDeclaration.isEs6PrimaryConstructorReplacement: Boolean
     get() = origin == ES6_PRIMARY_CONSTRUCTOR_REPLACEMENT
 
-val IrFunctionAccessExpression.isSyntheticDelegatingReplacement: Boolean
+val IrFunctionAccessExpression<*>.isSyntheticDelegatingReplacement: Boolean
     get() = origin == ES6_DELEGATING_CONSTRUCTOR_REPLACEMENT
 
 val IrDeclaration.isInitFunction: Boolean
     get() = origin == ES6_INIT_FUNCTION
 
-val IrFunctionAccessExpression.isInitCall: Boolean
+val IrFunctionAccessExpression<*>.isInitCall: Boolean
     get() = origin == ES6_INIT_CALL
 
 val IrDeclaration.isSyntheticConstructorForExport: Boolean

diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultParameterInjector.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultParameterInjector.kt
index 5e90577..dcde75c 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultParameterInjector.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultParameterInjector.kt

@@ -38,7 +38,7 @@
             context.getVoid()
         }
 
-    override fun shouldReplaceWithSyntheticFunction(functionAccess: IrFunctionAccessExpression): Boolean {
+    override fun shouldReplaceWithSyntheticFunction(functionAccess: IrFunctionAccessExpression<*>): Boolean {
         return super.shouldReplaceWithSyntheticFunction(functionAccess) || functionAccess.symbol.owner.run {
             origin == JsLoweredDeclarationOrigin.JS_SHADOWED_EXPORT &&
                     !isTopLevel &&
@@ -47,7 +47,7 @@
         }
     }
 
-    override fun IrBlockBuilder.argumentsForCall(expression: IrFunctionAccessExpression, stubFunction: IrFunction): Map<IrValueParameter, IrExpression?> {
+    override fun IrBlockBuilder.argumentsForCall(expression: IrFunctionAccessExpression<*>, stubFunction: IrFunction): Map<IrValueParameter, IrExpression?> {
         val startOffset = expression.startOffset
         val endOffset = expression.endOffset
 

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 c682c24..e9abb09 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

@@ -305,7 +305,7 @@
     }
 
     private fun replaceSecondaryConstructorWithFactoryFunction(
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         newTarget: IrSimpleFunctionSymbol
     ): IrCall {
         val irClass = call.symbol.owner.parentAsClass

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 08d38d5..5bba497 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

@@ -38,7 +38,7 @@
         }
     }
 
-    private fun IrFunctionAccessExpression.extractThrowableArguments(): ThrowableArguments =
+    private fun IrFunctionAccessExpression<*>.extractThrowableArguments(): ThrowableArguments =
         when (valueArgumentsCount) {
             0 -> ThrowableArguments(undefinedValue(), undefinedValue())
             2 -> ThrowableArguments(

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 cdf27e7..1d34424 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

@@ -144,7 +144,7 @@
         } else segment
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         expression.transformChildrenVoid()
 
         if (expression.symbol.owner.isExternal) {

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 8a569c0..6ad2037 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

@@ -16,7 +16,7 @@
 class BuiltInConstructorCalls(val context: JsIrBackendContext) : CallsTransformer {
     val intrinsics = context.intrinsics
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression =
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression =
         if (call is IrConstructorCall) {
             // Do not transform Delegation calls
             when (call.symbol) {

diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLowering.kt
index 345d5a5..63a0428 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLowering.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLowering.kt

@@ -38,10 +38,10 @@
                 return super.visitFunction(declaration, declaration)
             }
 
-            override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: IrDeclaration): IrElement {
+            override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: IrDeclaration): IrElement {
                 val call = super.visitFunctionAccess(expression, data)
                 val doNotIntrinsify = data.hasAnnotation(context.intrinsics.doNotIntrinsifyAnnotationSymbol)
-                if (call is IrFunctionAccessExpression) {
+                if (call is IrFunctionAccessExpression<*>) {
                     for (transformer in transformers) {
                         val newCall = transformer.transformFunctionAccess(call, doNotIntrinsify)
                         if (newCall !== call) {
@@ -56,5 +56,5 @@
 }
 
 interface CallsTransformer {
-    fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression
+    fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression
 }

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 4fe7bb0..290997f 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

@@ -15,7 +15,7 @@
 import org.jetbrains.kotlin.ir.util.irCall
 import org.jetbrains.kotlin.name.Name
 
-typealias SymbolToTransformer = MutableMap<IrFunctionSymbol, (IrFunctionAccessExpression) -> IrExpression>
+typealias SymbolToTransformer = MutableMap<IrFunctionSymbol, (IrFunctionAccessExpression<*>) -> IrExpression>
 
 internal fun SymbolToTransformer.add(from: Map<IrClassifierSymbol, IrFunctionSymbol>, to: IrSimpleFunctionSymbol) {
     from.forEach { _, func ->
@@ -23,13 +23,13 @@
     }
 }
 
-internal fun SymbolToTransformer.add(from: Map<IrClassifierSymbol, IrFunctionSymbol>, to: (IrFunctionAccessExpression) -> IrExpression) {
+internal fun SymbolToTransformer.add(from: Map<IrClassifierSymbol, IrFunctionSymbol>, to: (IrFunctionAccessExpression<*>) -> IrExpression) {
     from.forEach { _, func ->
         add(func, to)
     }
 }
 
-internal fun SymbolToTransformer.add(from: IrFunctionSymbol, to: (IrFunctionAccessExpression) -> IrExpression) {
+internal fun SymbolToTransformer.add(from: IrFunctionSymbol, to: (IrFunctionAccessExpression<*>) -> IrExpression) {
     put(from, to)
 }
 
@@ -37,15 +37,15 @@
     put(from) { call -> irCall(call, to, dispatchReceiverAsFirstArgument) }
 }
 
-internal fun <K> MutableMap<K, (IrFunctionAccessExpression) -> IrExpression>.addWithPredicate(
+internal fun <K> MutableMap<K, (IrFunctionAccessExpression<*>) -> IrExpression>.addWithPredicate(
     from: K,
-    predicate: (IrFunctionAccessExpression) -> Boolean,
-    action: (IrFunctionAccessExpression) -> IrExpression
+    predicate: (IrFunctionAccessExpression<*>) -> Boolean,
+    action: (IrFunctionAccessExpression<*>) -> IrExpression
 ) {
-    put(from) { call: IrFunctionAccessExpression -> if (predicate(call)) action(call) else call }
+    put(from) { call: IrFunctionAccessExpression<*> -> if (predicate(call)) action(call) else call }
 }
 
-internal typealias MemberToTransformer = HashMap<SimpleMemberKey, (IrFunctionAccessExpression) -> IrExpression>
+internal typealias MemberToTransformer = HashMap<SimpleMemberKey, (IrFunctionAccessExpression<*>) -> IrExpression>
 
 internal fun MemberToTransformer.add(type: IrType, name: Name, v: IrSimpleFunctionSymbol) {
     add(type, name) { irCall(it, v, receiversAsArguments = true) }
@@ -55,7 +55,7 @@
     add(type, name, v.symbol)
 }
 
-internal fun MemberToTransformer.add(type: IrType, name: Name, v: (IrFunctionAccessExpression) -> IrExpression) {
+internal fun MemberToTransformer.add(type: IrType, name: Name, v: (IrFunctionAccessExpression<*>) -> IrExpression) {
     put(SimpleMemberKey(type, name), v)
 }
 

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 42abb64..beefede 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

@@ -21,7 +21,7 @@
 
 object EnumIntrinsicsUtils {
     private fun transformEnumTopLevelIntrinsic(
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         staticMethodPredicate: (IrSimpleFunction) -> Boolean
     ): IrExpression {
         val enum = call.getTypeArgument(0)?.getClass() ?: return call
@@ -36,23 +36,23 @@
         return irCall(call, staticMethod.symbol)
     }
 
-    fun transformEnumValueOfIntrinsic(call: IrFunctionAccessExpression) = transformEnumTopLevelIntrinsic(call) {
+    fun transformEnumValueOfIntrinsic(call: IrFunctionAccessExpression<*>) = transformEnumTopLevelIntrinsic(call) {
         it.name == Name.identifier("valueOf") &&
                 it.valueParameters.count() == 1 &&
                 it.valueParameters[0].type.isString()
     }
 
-    fun transformEnumValuesIntrinsic(call: IrFunctionAccessExpression) = transformEnumTopLevelIntrinsic(call) {
+    fun transformEnumValuesIntrinsic(call: IrFunctionAccessExpression<*>) = transformEnumTopLevelIntrinsic(call) {
         it.name == Name.identifier("values") && it.valueParameters.count() == 0
     }
 
-    fun transformEnumEntriesIntrinsic(call: IrFunctionAccessExpression) = transformEnumTopLevelIntrinsic(call) {
+    fun transformEnumEntriesIntrinsic(call: IrFunctionAccessExpression<*>) = transformEnumTopLevelIntrinsic(call) {
         it.name == Name.special("<get-entries>")
     }
 }
 
 class EnumIntrinsicsTransformer(private val context: JsIrBackendContext) : CallsTransformer {
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean) = when (call.symbol) {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean) = when (call.symbol) {
         context.intrinsics.enumValueOfIntrinsic -> EnumIntrinsicsUtils.transformEnumValueOfIntrinsic(call)
         context.intrinsics.enumValuesIntrinsic -> EnumIntrinsicsUtils.transformEnumValuesIntrinsic(call)
         context.intrinsics.enumEntriesIntrinsic -> EnumIntrinsicsUtils.transformEnumEntriesIntrinsic(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 d4ce51e..0cfafb2 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

@@ -47,7 +47,7 @@
         }
     }
 
-    private fun transformLongComparison(comparator: IrSimpleFunctionSymbol): (IrFunctionAccessExpression) -> IrExpression = { call ->
+    private fun transformLongComparison(comparator: IrSimpleFunctionSymbol): (IrFunctionAccessExpression<*>) -> IrExpression = { call ->
         IrCallImpl(
             call.startOffset,
             call.endOffset,
@@ -61,7 +61,7 @@
         }
     }
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         val symbol = call.symbol
         symbolToTransformer[symbol]?.let {
             return it(call)
@@ -74,7 +74,7 @@
         }
     }
 
-    private fun transformEqeqeqOperator(call: IrFunctionAccessExpression): IrExpression {
+    private fun transformEqeqeqOperator(call: IrFunctionAccessExpression<*>): IrExpression {
         val lhs = call.getValueArgument(0)!!
         val rhs = call.getValueArgument(1)!!
 
@@ -89,7 +89,7 @@
         return this is IrCall && symbol == intrinsics.jsBoxIntrinsic && getValueArgument(0)!!.type.isChar()
     }
 
-    private fun transformEqeqOperator(call: IrFunctionAccessExpression): IrExpression {
+    private fun transformEqeqOperator(call: IrFunctionAccessExpression<*>): IrExpression {
         val lhs = call.getValueArgument(0)!!
         val rhs = call.getValueArgument(1)!!
 
@@ -122,17 +122,17 @@
         }
     }
 
-    private fun chooseEqualityOperatorForPrimitiveTypes(call: IrFunctionAccessExpression): IrExpression = when {
+    private fun chooseEqualityOperatorForPrimitiveTypes(call: IrFunctionAccessExpression<*>): IrExpression = when {
         call.allValueArgumentsAreNullable() ->
             irCall(call, intrinsics.jsEqeq)
         else ->
             irCall(call, intrinsics.jsEqeqeq)
     }
 
-    private fun IrFunctionAccessExpression.allValueArgumentsAreNullable() =
+    private fun IrFunctionAccessExpression<*>.allValueArgumentsAreNullable() =
         (0 until valueArgumentsCount).all { getValueArgument(it)!!.type.isNullable() }
 
-    private fun transformCompareToMethodCall(call: IrFunctionAccessExpression): IrExpression {
+    private fun transformCompareToMethodCall(call: IrFunctionAccessExpression<*>): IrExpression {
         val function = call.symbol.owner as IrSimpleFunction
         if (function.parent !is IrClass) return call
 
@@ -206,14 +206,14 @@
         this is IrCall && symbol == icUtils.boxIntrinsic
 
     private fun IrExpression.unboxParamWithInlinedClass(): Pair<IrExpression, IrClass?> {
-        val unboxed = (this as IrFunctionAccessExpression).getValueArgument(0)
+        val unboxed = (this as IrFunctionAccessExpression<*>).getValueArgument(0)
             ?: irError("Boxed expression is expected") {
                 withIrEntry("this", this@unboxParamWithInlinedClass)
             }
         return Pair(unboxed, icUtils.getInlinedClass(unboxed.type))
     }
 
-    private fun optimizeInlineClassEquality(call: IrFunctionAccessExpression, lhs: IrExpression, rhs: IrExpression): IrExpression {
+    private fun optimizeInlineClassEquality(call: IrFunctionAccessExpression<*>, lhs: IrExpression, rhs: IrExpression): IrExpression {
         val (lhsUnboxed, lhsClassType) = lhs.unboxParamWithInlinedClass()
         val (rhsUnboxed, rhsClassType) = rhs.unboxParamWithInlinedClass()
         if (lhsClassType !== null && lhsClassType === rhsClassType && lhsUnboxed.type.isDefaultEqualsMethod()) {

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 585d0c3..2c880c0 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

@@ -31,6 +31,6 @@
         context.irBuiltIns.linkageErrorSymbol to context.intrinsics.linkageErrorSymbol
     )
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean) =
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean) =
         helperMapping[call.symbol]?.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 cc311dd..80f4317 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

@@ -13,7 +13,7 @@
 
 // TODO use nativeX annotations on kotlin.js.Json instead
 class JsonIntrinsics(context: JsIrBackendContext) : NativeGetterSetterTransformer(context) {
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         return when (call.symbol.owner.fqNameWhenAvailable) {
             FqName("kotlin.js.Json.get") -> call.transformToIndexedRead()
             FqName("kotlin.js.Json.set") -> call.transformToIndexedWrite()

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 67fb02c..5a30468 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

@@ -20,7 +20,7 @@
 
 class MethodsOfAnyCallsTransformer(context: JsIrBackendContext) : CallsTransformer {
     private val intrinsics = context.intrinsics
-    private val nameToTransformer: Map<Name, (IrFunctionAccessExpression) -> IrExpression>
+    private val nameToTransformer: Map<Name, (IrFunctionAccessExpression<*>) -> IrExpression>
 
     init {
         nameToTransformer = hashMapOf()
@@ -52,7 +52,7 @@
     }
 
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         val symbol = call.symbol
         nameToTransformer[symbol.owner.name]?.let {
             return it(call)
@@ -61,7 +61,7 @@
         return call
     }
 
-    private fun shouldReplaceToStringWithRuntimeCall(call: IrFunctionAccessExpression): Boolean {
+    private fun shouldReplaceToStringWithRuntimeCall(call: IrFunctionAccessExpression<*>): Boolean {
         val function = call.symbol.owner
         if (function.valueParameters.isNotEmpty() && function.name.asString() != "toString" )
             return false

diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NativeGetterSetterTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NativeGetterSetterTransformer.kt
index ff5f7f5..c0d7a57 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NativeGetterSetterTransformer.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/NativeGetterSetterTransformer.kt

@@ -15,7 +15,7 @@
 
 
 open class NativeGetterSetterTransformer(val context: JsIrBackendContext) : CallsTransformer {
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         val callee = call.symbol.owner
 
         return when {
@@ -29,7 +29,7 @@
         }
     }
 
-    protected fun IrFunctionAccessExpression.transformToIndexedRead(): IrExpression {
+    protected fun IrFunctionAccessExpression<*>.transformToIndexedRead(): IrExpression {
         val obj = dispatchReceiver ?: extensionReceiver!!
         val propertyName = getValueArgument(0)!!
         return IrDynamicOperatorExpressionImpl(
@@ -43,7 +43,7 @@
         }
     }
 
-    protected fun IrFunctionAccessExpression.transformToIndexedWrite(): IrExpression {
+    protected fun IrFunctionAccessExpression<*>.transformToIndexedWrite(): IrExpression {
         val value = getValueArgument(1)!!
 
         return IrDynamicOperatorExpressionImpl(startOffset, endOffset, type, IrDynamicOperator.EQ).also {

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 053d415..eb103c0 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

@@ -74,7 +74,7 @@
         }
     }
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         val function = call.symbol.owner
         function.dispatchReceiverParameter?.also {
             val key = SimpleMemberKey(it.type, function.name)
@@ -85,7 +85,7 @@
         return call
     }
 
-    private fun useDispatchReceiver(call: IrFunctionAccessExpression): IrExpression {
+    private fun useDispatchReceiver(call: IrFunctionAccessExpression<*>): IrExpression {
         return JsIrBuilder.buildReinterpretCast(call.dispatchReceiver!!, call.type)
     }
 }

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 2dcc273..ef9a7b8 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

@@ -82,7 +82,7 @@
         }
     }
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         val function = call.symbol.owner
         function.dispatchReceiverParameter?.also {
             val key = SimpleMemberKey(it.type, function.name)
@@ -93,7 +93,7 @@
         return call
     }
 
-    private fun transformRangeTo(call: IrFunctionAccessExpression): IrExpression {
+    private fun transformRangeTo(call: IrFunctionAccessExpression<*>): IrExpression {
         if (call.valueArgumentsCount != 1) return call
         return with(call.symbol.owner.valueParameters[0].type) {
             when {
@@ -106,7 +106,7 @@
         }
     }
 
-    private fun transformRangeUntil(call: IrFunctionAccessExpression): IrExpression {
+    private fun transformRangeUntil(call: IrFunctionAccessExpression<*>): IrExpression {
         if (call.valueArgumentsCount != 1) return call
         with(call.symbol.owner) {
             val function = intrinsics.rangeUntilFunctions[dispatchReceiverParameter!!.type to valueParameters[0].type]
@@ -120,7 +120,7 @@
         }
     }
 
-    private fun transformHashCode(call: IrFunctionAccessExpression): IrExpression {
+    private fun transformHashCode(call: IrFunctionAccessExpression<*>): IrExpression {
         return with(call.symbol.owner.dispatchReceiverParameter!!.type) {
             when {
                 isByte() || isShort() || isInt() ->
@@ -134,7 +134,7 @@
     }
 
     private fun irBinaryOp(
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         intrinsic: IrSimpleFunctionSymbol,
         toInt32: Boolean = false
     ): IrExpression {
@@ -144,7 +144,7 @@
         return newCall
     }
 
-    class BinaryOp(call: IrFunctionAccessExpression) {
+    class BinaryOp(call: IrFunctionAccessExpression<*>) {
         val function = call.symbol.owner
         val name = function.name
         val lhs = function.dispatchReceiverParameter!!.type
@@ -155,13 +155,13 @@
             result.isInt() && (lhs.isInt() || rhs.isInt())
     }
 
-    private fun transformAdd(call: IrFunctionAccessExpression) =
+    private fun transformAdd(call: IrFunctionAccessExpression<*>) =
         irBinaryOp(call, intrinsics.jsPlus, toInt32 = BinaryOp(call).canAddOrSubOverflow())
 
-    private fun transformSub(call: IrFunctionAccessExpression) =
+    private fun transformSub(call: IrFunctionAccessExpression<*>) =
         irBinaryOp(call, intrinsics.jsMinus, toInt32 = BinaryOp(call).canAddOrSubOverflow())
 
-    private fun transformMul(call: IrFunctionAccessExpression) = BinaryOp(call).run {
+    private fun transformMul(call: IrFunctionAccessExpression<*>) = BinaryOp(call).run {
         when {
             result.isInt() -> when {
 
@@ -176,19 +176,19 @@
         }
     }
 
-    private fun transformDiv(call: IrFunctionAccessExpression) =
+    private fun transformDiv(call: IrFunctionAccessExpression<*>) =
         irBinaryOp(call, intrinsics.jsDiv, toInt32 = BinaryOp(call).result.isInt())
 
-    private fun transformRem(call: IrFunctionAccessExpression) =
+    private fun transformRem(call: IrFunctionAccessExpression<*>) =
         irBinaryOp(call, intrinsics.jsMod, toInt32 = BinaryOp(call).result.isInt())
 
-    private fun transformIncrement(call: IrFunctionAccessExpression) =
+    private fun transformIncrement(call: IrFunctionAccessExpression<*>) =
         transformCrement(call, intrinsics.jsPlus)
 
-    private fun transformDecrement(call: IrFunctionAccessExpression) =
+    private fun transformDecrement(call: IrFunctionAccessExpression<*>) =
         transformCrement(call, intrinsics.jsMinus)
 
-    private fun transformCrement(call: IrFunctionAccessExpression, correspondingBinaryOp: IrSimpleFunctionSymbol): IrExpression {
+    private fun transformCrement(call: IrFunctionAccessExpression<*>, correspondingBinaryOp: IrSimpleFunctionSymbol): IrExpression {
         val operation = irCall(call, correspondingBinaryOp, receiversAsArguments = true).apply {
             putValueArgument(1, buildInt(1))
         }
@@ -196,7 +196,7 @@
         return convertResultToPrimitiveType(operation, call.type)
     }
 
-    private fun transformUnaryMinus(call: IrFunctionAccessExpression) =
+    private fun transformUnaryMinus(call: IrFunctionAccessExpression<*>) =
         convertResultToPrimitiveType(
             irCall(call, intrinsics.jsUnaryMinus, receiversAsArguments = true),
             call.type
@@ -209,7 +209,7 @@
         else -> e
     }
 
-    private fun withLongCoercion(default: (IrFunctionAccessExpression) -> IrExpression): (IrFunctionAccessExpression) -> IrExpression =
+    private fun withLongCoercion(default: (IrFunctionAccessExpression<*>) -> IrExpression): (IrFunctionAccessExpression<*>) -> IrExpression =
         { call ->
             assert(call.valueArgumentsCount == 1)
             val arg = call.getValueArgument(0)!!

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 2429923..21604d2 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

@@ -59,7 +59,7 @@
         }
     }
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         if (doNotIntrinsify) return call
         symbolToTransformer[call.symbol]?.let {
             return it(call)

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 66d586a..35280a9 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

@@ -16,9 +16,9 @@
 
 
 class ReflectionCallsTransformer(private val context: JsIrBackendContext) : CallsTransformer {
-    private val nameToTransformer: Map<Name, (IrFunctionAccessExpression) -> IrExpression>
+    private val nameToTransformer: Map<Name, (IrFunctionAccessExpression<*>) -> IrExpression>
 
-    private fun buildDynamicCall(name: String, call: IrFunctionAccessExpression): IrExpression {
+    private fun buildDynamicCall(name: String, call: IrFunctionAccessExpression<*>): IrExpression {
         val reference = IrDynamicMemberExpressionImpl(call.startOffset, call.endOffset, context.dynamicType, name, call.dispatchReceiver!!)
 
         return IrDynamicOperatorExpressionImpl(call.startOffset, call.endOffset, call.type, IrDynamicOperator.INVOKE).apply {
@@ -66,7 +66,7 @@
         }
     }
 
-    override fun transformFunctionAccess(call: IrFunctionAccessExpression, doNotIntrinsify: Boolean): IrExpression {
+    override fun transformFunctionAccess(call: IrFunctionAccessExpression<*>, doNotIntrinsify: Boolean): IrExpression {
         val symbol = call.symbol
         nameToTransformer[symbol.owner.name]?.let {
             return it(call)

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 2dd7f0b..e1999df 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

@@ -326,7 +326,7 @@
 }
 
 fun argumentsWithVarargAsSingleArray(
-    expression: IrFunctionAccessExpression,
+    expression: IrFunctionAccessExpression<*>,
     context: JsGenerationContext,
     additionalReceiver: JsExpression?,
     arguments: List<JsExpression>,
@@ -453,7 +453,7 @@
     }
 
 private fun IrMemberAccessExpression<*>.validWithNullArgs() =
-    this is IrFunctionAccessExpression && symbol.owner.isExternalOrInheritedFromExternal()
+    this is IrFunctionAccessExpression<*> && symbol.owner.isExternalOrInheritedFromExternal()
 
 fun JsStatement.asBlock() = this as? JsBlock ?: JsBlock(this)
 

diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/IrJsUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/IrJsUtils.kt
index 36388e9..f52bb06 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/IrJsUtils.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/IrJsUtils.kt

@@ -76,10 +76,10 @@
     return (parent as? IrFile)?.getJsQualifier()?.let { FqName(it) } ?: parent.packageFqName.takeIf { shouldIncludePackage }
 }
 
-val IrFunctionAccessExpression.typeArguments: List<IrType?>
+val IrFunctionAccessExpression<*>.typeArguments: List<IrType?>
     get() = List(typeArgumentsCount) { getTypeArgument(it) }
 
-val IrFunctionAccessExpression.valueArguments: List<IrExpression?>
+val IrFunctionAccessExpression<*>.valueArguments: List<IrExpression?>
     get() = List(valueArgumentsCount) { getValueArgument(it) }
 
 val IrClass.isInstantiableEnum: Boolean

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
index 0a588aa..1e080de 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt

@@ -665,7 +665,7 @@
         }
     }
 
-    private fun IrFunctionAccessExpression.getSuspensionPointKind(): SuspensionPointKind =
+    private fun IrFunctionAccessExpression<*>.getSuspensionPointKind(): SuspensionPointKind =
         when {
             !symbol.owner.isSuspend || !irFunction.shouldContainSuspendMarkers() ->
                 SuspensionPointKind.NEVER
@@ -730,7 +730,7 @@
         return MaterialValue(this, owner, expression.type)
     }
 
-    private fun generateConstructorArguments(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, data: BlockInfo) {
+    private fun generateConstructorArguments(expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, data: BlockInfo) {
         expression.symbol.owner.valueParameters.forEachIndexed { i, irParameter ->
             val arg = expression.getValueArgument(i)
                 ?: error("Null argument in ExpressionCodegen for parameter ${irParameter.render()}")
@@ -1547,7 +1547,7 @@
     }
 
     private fun getOrCreateCallGenerator(
-        element: IrFunctionAccessExpression,
+        element: IrFunctionAccessExpression<*>,
         data: BlockInfo,
         signature: JvmMethodSignature
     ): IrCallGenerator {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrCallGenerator.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrCallGenerator.kt
index c1d923f..5a53145 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrCallGenerator.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrCallGenerator.kt

@@ -26,7 +26,7 @@
     fun genCall(
         callableMethod: IrCallableMethod,
         codegen: ExpressionCodegen,
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         isInsideIfCondition: Boolean,
     ) {
         with(callableMethod) {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCallGenerator.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCallGenerator.kt
index 5942c61..6f222ba 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCallGenerator.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCallGenerator.kt

@@ -20,7 +20,7 @@
     override fun genCall(
         callableMethod: IrCallableMethod,
         codegen: ExpressionCodegen,
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         isInsideIfCondition: Boolean,
     ) {
         val element = IrInlineFunctionSource(expression)
@@ -42,7 +42,7 @@
     fun genInlineCall(
         callableMethod: IrCallableMethod,
         codegen: ExpressionCodegen,
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         isInsideIfCondition: Boolean,
     )
 

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt
index bfd711e..9c4ec78 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt

@@ -157,7 +157,7 @@
     override fun genInlineCall(
         callableMethod: IrCallableMethod,
         codegen: ExpressionCodegen,
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         isInsideIfCondition: Boolean,
     ) {
         performInline(isInsideIfCondition, function.isInlineOnly())

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineDefaultCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineDefaultCodegen.kt
index a224fd7..69ac5da 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineDefaultCodegen.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineDefaultCodegen.kt

@@ -39,7 +39,7 @@
     override fun genInlineCall(
         callableMethod: IrCallableMethod,
         codegen: ExpressionCodegen,
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         isInsideIfCondition: Boolean
     ) {
         val function = expression.symbol.owner

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt
index d0ba363..836e37b 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt

@@ -31,7 +31,7 @@
 
 class IrSourceCompilerForInline(
     override val state: GenerationState,
-    override val callElement: IrFunctionAccessExpression,
+    override val callElement: IrFunctionAccessExpression<*>,
     private val callee: IrFunction,
     internal val codegen: ExpressionCodegen,
     private val data: BlockInfo

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/AndAnd.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/AndAnd.kt
index fabe5db..7e83add 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/AndAnd.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/AndAnd.kt

@@ -51,7 +51,7 @@
         }
     }
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val (left, right) = expression.receiverAndArgs()
         return BooleanConjunction(left, right, codegen, data)
     }

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayGet.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayGet.kt
index ba72a12..838381d 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayGet.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayGet.kt

@@ -22,7 +22,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object ArrayGet : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val dispatchReceiver = expression.dispatchReceiver!!
         val receiver = dispatchReceiver.accept(codegen, data).materializedAt(dispatchReceiver.type)
         val elementType = AsmUtil.correctElementType(receiver.type)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt
index 9b6dbed..264c985 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt

@@ -25,7 +25,7 @@
 
 object ArrayIterator : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen,
     ): IntrinsicFunction {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySet.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySet.kt
index aa5df23..0454275 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySet.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySet.kt

@@ -23,7 +23,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object ArraySet : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val dispatchReceiver = expression.dispatchReceiver!!
         val receiver = dispatchReceiver.accept(codegen, data).materializedAt(dispatchReceiver.type)
         val elementType = AsmUtil.correctElementType(receiver.type)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt
index 5d1a4e2..2f90eba 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt

@@ -22,7 +22,7 @@
 
 object ArraySize : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             it.arraylength()

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt
index 588704a..8f5f82f 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt

@@ -32,7 +32,7 @@
         opcode == ISHL || opcode == ISHR || opcode == IUSHR
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt
index 832724e..a4c8f29 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt

@@ -29,7 +29,7 @@
     private val CLONEABLE_TYPE = Type.getObjectType("java/lang/Cloneable")
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt
index 2513d4d..1674e81 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt

@@ -52,7 +52,7 @@
     }
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction {
@@ -87,7 +87,7 @@
 }
 
 class BooleanComparison(
-    val expression: IrFunctionAccessExpression,
+    val expression: IrFunctionAccessExpression<*>,
     val op: IElementType,
     val a: MaterialValue,
     val b: MaterialValue
@@ -119,7 +119,7 @@
 }
 
 class NonIEEE754FloatComparison(
-    private val expression: IrFunctionAccessExpression,
+    private val expression: IrFunctionAccessExpression<*>,
     op: IElementType,
     private val a: MaterialValue,
     private val b: MaterialValue
@@ -154,7 +154,7 @@
 }
 
 class PrimitiveToObjectComparison(
-    private val expression: IrFunctionAccessExpression,
+    private val expression: IrFunctionAccessExpression<*>,
     private val op: IElementType,
     private val leftIsPrimitive: Boolean,
     private val left: MaterialValue,
@@ -214,7 +214,7 @@
     private val primitiveNumberType: PrimitiveType,
     private val operatorToken: KtSingleValueToken
 ) : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
         val parameterType = Type.getType(JvmPrimitiveType.get(primitiveNumberType).desc)
         val (left, right) = expression.receiverAndArgs()
         val a = left.accept(codegen, data).materializedAt(parameterType, left.type)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/EnumIntrinsics.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/EnumIntrinsics.kt
index 89d9903..29778a7 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/EnumIntrinsics.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/EnumIntrinsics.kt

@@ -15,7 +15,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object EnumValueOf : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
         val type = expression.getTypeArgument(0)!!
         val result = expression.getValueArgument(0)!!.accept(this, data)
             .materializedAt(AsmTypes.JAVA_STRING_TYPE, codegen.context.irBuiltIns.stringType)
@@ -44,7 +44,7 @@
 }
 
 object EnumValues : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
         val type = expression.getTypeArgument(0)!!
         if (type.isReifiedTypeParameter) {
             // Note that the inliner expects exactly the following sequence of instructions.
@@ -68,7 +68,7 @@
 }
 
 object EnumEntries : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
         val type = expression.getTypeArgument(0)!!
         if (type.isReifiedTypeParameter) {
             // Note that the inliner expects exactly the following sequence of instructions.

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt
index c4557f4..b8b6780 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt

@@ -37,7 +37,7 @@
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
 class ExplicitEquals : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val (a, b) = expression.receiverAndArgs()
 
         // TODO use specialized boxed type - this might require types like 'java.lang.Integer' in IR
@@ -57,7 +57,7 @@
 
 class Equals(val operator: IElementType) : IntrinsicMethod() {
 
-    private class BooleanNullCheck(val expression: IrFunctionAccessExpression, val value: PromisedValue) : BooleanValue(value.codegen) {
+    private class BooleanNullCheck(val expression: IrFunctionAccessExpression<*>, val value: PromisedValue) : BooleanValue(value.codegen) {
         override fun jumpIfFalse(target: Label) {
             value.materialize()
             markLineNumber(expression)
@@ -76,7 +76,7 @@
         }
     }
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val (a, b) = expression.receiverAndArgs()
         if (a.isNullConst() || b.isNullConst()) {
             val irValue = if (a.isNullConst()) b else a
@@ -142,7 +142,7 @@
     }
 
     private fun referenceEquals(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         left: IrExpression,
         right: IrExpression,
         leftType: Type,
@@ -172,7 +172,7 @@
     private val boxedOperandType = AsmUtil.boxType(operandType)
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetClassByDescriptor.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetClassByDescriptor.kt
index 5e15c1b..5545aa5 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetClassByDescriptor.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetClassByDescriptor.kt

@@ -15,7 +15,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object GetClassByDescriptor : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val type = Type.getType(expression.getStringConstArgument(0))
         require(type.sort != Type.VOID) { "Unexpected VOID type descriptor" }
         if (AsmUtil.isPrimitive(type)) {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaObjectType.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaObjectType.kt
index e0335ae..c4d53f2 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaObjectType.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaObjectType.kt

@@ -23,7 +23,7 @@
 
 object GetJavaObjectType : IntrinsicMethod() {
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
         when (val receiver = expression.extensionReceiver) {
             is IrClassReference -> {
                 val symbol = receiver.symbol

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaPrimitiveType.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaPrimitiveType.kt
index 9b1ffd7..1893d7d 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaPrimitiveType.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/GetJavaPrimitiveType.kt

@@ -26,7 +26,7 @@
 
 object GetJavaPrimitiveType : IntrinsicMethod() {
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
         val receiver = expression.extensionReceiver ?: return null
 
         val argumentType =

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HandleResultOfReflectiveAccess.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HandleResultOfReflectiveAccess.kt
index 4c6d940..122c778 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HandleResultOfReflectiveAccess.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HandleResultOfReflectiveAccess.kt

@@ -21,7 +21,7 @@
  */
 
 object HandleResultOfReflectiveAccess : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val typeMapper = codegen.typeMapper
         val mv = codegen.mv
         val type = expression.getTypeArgument(0)!!

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt
index 9c38c15..341f232 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt

@@ -27,7 +27,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object HashCode : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
         val receiver = expression.dispatchReceiver ?: error("No receiver for hashCode: ${expression.render()}")
         val receiverIrType = receiver.type
         val receiverJvmType = typeMapper.mapType(receiverIrType)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt
index 4eda182..f98e5eb 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt

@@ -23,7 +23,7 @@
 
 class Increment(private val myDelta: Int) : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             genIncrement(signature.returnType, myDelta, it)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntIncr.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntIncr.kt
index 371f49d..16bb44e 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntIncr.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntIncr.kt

@@ -12,7 +12,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 class IntIncr(private val isPrefix: Boolean) : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val irGetValue = expression.getValueArgument(0) as? IrGetValue
             ?: error("IrGetValue expected as valueArgument #0: ${expression.dump()}")
         val irDelta = expression.getValueArgument(1) as? IrConst

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicFunction.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicFunction.kt
index a6283db..e860180 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicFunction.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicFunction.kt

@@ -23,7 +23,7 @@
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
 abstract class IntrinsicFunction(
-    val expression: IrFunctionAccessExpression,
+    val expression: IrFunctionAccessExpression<*>,
     val signature: JvmMethodSignature,
     val classCodegen: ClassCodegen,
     val argsTypes: List<Type>,
@@ -34,7 +34,7 @@
         v: InstructionAdapter,
         codegen: ExpressionCodegen,
         data: BlockInfo,
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
     ): StackValue {
         loadArguments(codegen, data)
         with(codegen) { expression.markLineNumber(startOffset = true) }
@@ -70,12 +70,12 @@
         codegen.gen(expression, argsTypes[index], expression.type, data)
     }
 
-    private val IrFunctionAccessExpression.typeArguments: List<IrType>
+    private val IrFunctionAccessExpression<*>.typeArguments: List<IrType>
         get() = (0 until typeArgumentsCount).map { getTypeArgument(it)!! }
 
     companion object {
         fun create(
-            expression: IrFunctionAccessExpression,
+            expression: IrFunctionAccessExpression<*>,
             signature: JvmMethodSignature,
             classCodegen: ClassCodegen,
             argsTypes: List<Type> = expression.argTypes(classCodegen),
@@ -87,7 +87,7 @@
     }
 }
 
-internal fun IrFunctionAccessExpression.argTypes(classCodegen: ClassCodegen): List<Type> {
+internal fun IrFunctionAccessExpression<*>.argTypes(classCodegen: ClassCodegen): List<Type> {
     val callee = symbol.owner
     val signature = classCodegen.methodSignatureMapper.mapSignatureSkipGeneric(callee)
     return arrayListOf<Type>().apply {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt
index 912512e..7172fd9 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt

@@ -14,12 +14,12 @@
 
 abstract class IntrinsicMethod : IntrinsicMarker {
     open fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction = TODO("implement toCallable() or invoke() of $this")
 
-    open fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
+    open fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
         with(codegen) {
             val descriptor = methodSignatureMapper.mapSignatureSkipGeneric(expression.symbol.owner)
             val stackValue = toCallable(expression, descriptor, codegen.classCodegen).invoke(mv, codegen, data, expression)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt
index 12e7961..9f2d9be 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt

@@ -12,7 +12,7 @@
 
 object IntrinsicShouldHaveBeenLowered : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt
index 705a04b..31ab02e 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt

@@ -24,7 +24,7 @@
 
 object Inv : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         val returnType = signature.returnType
         val type = numberFunctionOperandType(returnType)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt
index 860381d..71be750 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt

@@ -17,7 +17,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object IrCheckNotNull : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val arg0 = expression.getValueArgument(0)!!.accept(codegen, data)
         if (AsmUtil.isPrimitive(arg0.type)) return arg0
         return object : PromisedValue(codegen, arg0.type, arg0.irType) {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt
index f6b9f99..0fb78ae 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt

@@ -12,7 +12,7 @@
 import org.jetbrains.kotlin.ir.util.isPrimitiveArray
 
 object IrDataClassArrayMemberHashCode : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue =
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue =
         with(codegen) {
             val arrayType = expression.getValueArgument(0)!!.type
             val asmArrayType = codegen.typeMapper.mapType(arrayType)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt
index 898927f..4b151fa 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt

@@ -12,7 +12,7 @@
 import org.jetbrains.kotlin.ir.util.isPrimitiveArray
 
 object IrDataClassArrayMemberToString : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue =
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue =
         with(codegen) {
             val arrayType = expression.getValueArgument(0)!!.type
             val asmArrayType = codegen.typeMapper.mapType(arrayType)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt
index 1f7b2ca..43dbcf4 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt

@@ -30,7 +30,7 @@
     val exceptionTypeDescriptor = Type.getType(IllegalArgumentException::class.java)!!
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction {
@@ -49,7 +49,7 @@
                 v: InstructionAdapter,
                 codegen: ExpressionCodegen,
                 data: BlockInfo,
-                expression: IrFunctionAccessExpression
+                expression: IrFunctionAccessExpression<*>
             ): StackValue {
                 with(codegen) { expression.markLineNumber(startOffset = true) }
                 v.anew(exceptionTypeDescriptor)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt
index 174f207..83e55f6 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt

@@ -23,7 +23,7 @@
 
 object IrNoWhenBranchMatchedException : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             genThrow(it, "kotlin/NoWhenBranchMatchedException", null)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt
index d7dfb50..0c88eea 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt

@@ -12,7 +12,7 @@
 
 object IsArrayOf : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction = IntrinsicFunction.create(expression, signature, classCodegen) { v ->

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt
index 7c8445b..407c738 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt

@@ -28,7 +28,7 @@
 
 object IteratorNext : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         // If the array element type is unboxed primitive, do not unbox. Otherwise AsmUtil.unbox throws exception
         val type = if (AsmUtil.isBoxedPrimitiveType(signature.returnType)) AsmUtil.unboxType(signature.returnType) else signature.returnType

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JavaClassProperty.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JavaClassProperty.kt
index 62aea51..8d80fcd 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JavaClassProperty.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JavaClassProperty.kt

@@ -48,7 +48,7 @@
                 invokeGetClass(value.materialized())
         }
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         invokeWith(expression.extensionReceiver!!.accept(codegen, data), wrapPrimitives = false)
         return with(codegen) { expression.onStack }
     }

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmDebuggerInvokeSpecial.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmDebuggerInvokeSpecial.kt
index f717e5d..f87ed26 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmDebuggerInvokeSpecial.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmDebuggerInvokeSpecial.kt

@@ -28,7 +28,7 @@
 // lowering straight through to JVM codegen without interference from
 // lowerings in between.
 object JvmDebuggerInvokeSpecial : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val owner = expression.getStringConstArgument(0)
         val name = expression.getStringConstArgument(1)
         val descriptor = expression.getStringConstArgument(2)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt
index e0d6fac..092376d 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt

@@ -17,7 +17,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object JvmInvokeDynamic : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         fun fail(message: String): Nothing =
             throw AssertionError("$message; expression:\n${expression.dump()}")
 

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/KClassJavaProperty.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/KClassJavaProperty.kt
index ee53825..4c2ddc2 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/KClassJavaProperty.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/KClassJavaProperty.kt

@@ -24,7 +24,7 @@
 import org.jetbrains.kotlin.ir.expressions.IrGetClass
 
 object KClassJavaProperty : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
         val extensionReceiver = expression.extensionReceiver
         if (extensionReceiver !is IrClassReference && extensionReceiver !is IrGetClass)
             return null

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt
index fc8fd02..e42aa74 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt

@@ -32,7 +32,7 @@
     }
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen, listOf(OBJECT_TYPE)) {
             it.visitInsn(opcode)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NewArray.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NewArray.kt
index 3a548be..9c7018c 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NewArray.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NewArray.kt

@@ -17,7 +17,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 object NewArray : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         codegen.gen(expression.getValueArgument(0)!!, Type.INT_TYPE, codegen.context.irBuiltIns.intType, data)
         return with(codegen) {
             val elementIrType = expression.type.getArrayElementType(context.irBuiltIns)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Not.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Not.kt
index b2db2c8..35c5bd0 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Not.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Not.kt

@@ -25,7 +25,7 @@
 import kotlin.math.exp
 
 object Not : IntrinsicMethod() {
-    class BooleanNegation(val expression: IrFunctionAccessExpression, val value: BooleanValue) : BooleanValue(value.codegen) {
+    class BooleanNegation(val expression: IrFunctionAccessExpression<*>, val value: BooleanValue) : BooleanValue(value.codegen) {
         override fun jumpIfFalse(target: Label) {
             markLineNumber(expression)
             value.jumpIfTrue(target)
@@ -42,6 +42,6 @@
         }
     }
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo) =
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo) =
         BooleanNegation(expression, expression.dispatchReceiver!!.accept(codegen, data).coerceToBoolean())
 }

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt
index 7f02d99..6b34aa4 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt

@@ -23,7 +23,7 @@
 
 object NumberCast : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             StackValue.coerce(argsTypes[0], signature.returnType, it)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/OrOr.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/OrOr.kt
index 7291a25..662b95e 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/OrOr.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/OrOr.kt

@@ -49,7 +49,7 @@
         }
     }
 
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val (left, right) = expression.receiverAndArgs()
         return BooleanDisjunction(left, right, codegen, data)
     }

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt
index 3b9ea26..9466424 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt

@@ -16,7 +16,7 @@
 
 object RangeTo : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         val argType = mapRangeTypeToPrimitiveType(signature.returnType)
         return object : IntrinsicFunction(
@@ -35,7 +35,7 @@
                 v: InstructionAdapter,
                 codegen: ExpressionCodegen,
                 data: BlockInfo,
-                expression: IrFunctionAccessExpression,
+                expression: IrFunctionAccessExpression<*>,
             ): StackValue {
                 with(codegen) { expression.markLineNumber(startOffset = true) }
                 v.anew(signature.returnType)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt
index 0e00ba0..fbdb503 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt

@@ -13,7 +13,7 @@
 
 object RangeUntil : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen
     ): IntrinsicFunction {
         return object : IntrinsicFunction(expression, signature, classCodegen, expression.argTypes(classCodegen)) {
             override fun genInvokeInstruction(v: InstructionAdapter) {

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt
index f11a317..8c02fd8 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt

@@ -23,7 +23,7 @@
  * to the single argument of the intrinsic.
  */
 object SignatureString : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val argument = generateSequence(expression.getValueArgument(0) as IrStatement) { (it as? IrBlock)?.statements?.lastOrNull() }
             .filterIsInstance<IrFunctionReference>().single()
         val function = argument.symbol.owner

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SingleArgumentInlineFunctionIntrinsic.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SingleArgumentInlineFunctionIntrinsic.kt
index 1db8349..41f9e40 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SingleArgumentInlineFunctionIntrinsic.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SingleArgumentInlineFunctionIntrinsic.kt

@@ -10,7 +10,7 @@
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
 
 object SingleArgumentInlineFunctionIntrinsic : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val sourceCompiler = IrSourceCompilerForInline(codegen.state, expression, expression.symbol.owner, codegen, data)
         val argumentExpression = expression.getValueArgument(0)!!
         val inlineLambda = argumentExpression.unwrapInlineLambda()

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt
index b27341a..99a56e0 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt

@@ -22,7 +22,7 @@
 
 object StringGetChar : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             it.invokevirtual("java/lang/String", "charAt", "(I)C", false)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt
index e3f99da..027272d 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt

@@ -15,7 +15,7 @@
 object StringPlus : IntrinsicMethod() {
 
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction =

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowIntrinsics.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowIntrinsics.kt
index c8a39d2..c488cb6 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowIntrinsics.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowIntrinsics.kt

@@ -13,7 +13,7 @@
 import org.jetbrains.org.objectweb.asm.Type
 
 class ThrowException(private val exceptionClass: Type) : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? {
         with(codegen) {
             mv.anew(exceptionClass)
             mv.dup()

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt
index 3bc8002..e0ee866 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt

@@ -12,7 +12,7 @@
 
 object ThrowKotlinNothingValueException : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         signature: JvmMethodSignature,
         classCodegen: ClassCodegen
     ): IntrinsicFunction =

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt
index 5f81857..0b2e07e 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt

@@ -14,7 +14,7 @@
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
 
 object TypeOf : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo) = with(codegen) {
         val type = expression.getTypeArgument(0)!!
         val support = IrInlineIntrinsicsSupport(codegen.classCodegen, expression, codegen.irFunction.fileParent)
         typeMapper.typeSystem.generateTypeOf(mv, type, support)

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt
index 604a277..7a0add4 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt

@@ -23,7 +23,7 @@
 
 object UnaryMinus : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             it.neg(numberFunctionOperandType(signature.returnType))

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt
index f7ffc7e..c15f5c5 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt

@@ -22,7 +22,7 @@
 
 object UnaryPlus : IntrinsicMethod() {
     override fun toCallable(
-        expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen,
+        expression: IrFunctionAccessExpression<*>, signature: JvmMethodSignature, classCodegen: ClassCodegen,
     ): IntrinsicFunction {
         return IntrinsicFunction.create(expression, signature, classCodegen) {
             // Do nothing.

diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnsafeCoerce.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnsafeCoerce.kt
index c91d376..7cf0b08 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnsafeCoerce.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnsafeCoerce.kt

@@ -18,7 +18,7 @@
  * addition to the underlying asmType.
  */
 object UnsafeCoerce : IntrinsicMethod() {
-    override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
+    override fun invoke(expression: IrFunctionAccessExpression<*>, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue {
         val from = expression.getTypeArgument(0)!!
         val to = expression.getTypeArgument(1)!!
         val fromType = codegen.typeMapper.mapType(from)

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/DirectInvokeLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/DirectInvokeLowering.kt
index 57baa28..f77d69b 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/DirectInvokeLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/DirectInvokeLowering.kt

@@ -108,9 +108,9 @@
                 }
         }
 
-    private fun IrFunctionAccessExpression.copyReceiverAndValueArgumentsForDirectInvoke(
+    private fun IrFunctionAccessExpression<*>.copyReceiverAndValueArgumentsForDirectInvoke(
         irFunRef: IrFunctionReference,
-        irInvokeCall: IrFunctionAccessExpression
+        irInvokeCall: IrFunctionAccessExpression<*>
     ) {
         val irFun = irFunRef.symbol.owner
         var invokeArgIndex = 0

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt
index a2391de..edb1170 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt

@@ -297,8 +297,8 @@
             }
 
             private fun IrBuilderWithScope.passConstructorArguments(
-                call: IrFunctionAccessExpression,
-                original: IrFunctionAccessExpression,
+                call: IrFunctionAccessExpression<*>,
+                original: IrFunctionAccessExpression<*>,
                 enumEntry: IrEnumEntry? = null
             ) {
                 call.copyTypeArgumentsFrom(original)

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt
index 4f6ff0a..71df82f 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionNVarargBridgeLowering.kt

@@ -44,7 +44,7 @@
     override fun lower(irFile: IrFile) = irFile.transformChildrenVoid(this)
 
     // Change calls to big arity invoke functions to vararg calls.
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         if (expression.valueArgumentsCount < BuiltInFunctionArity.BIG_ARITY ||
             !(expression.symbol.owner.parentAsClass.defaultType.isFunctionOrKFunction() ||
                     expression.symbol.owner.parentAsClass.defaultType.isSuspendFunctionOrKFunction()) ||

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt
index 5da3edc..e40fe21 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt

@@ -237,7 +237,7 @@
 
         val temporaryVals = ArrayList<IrVariable>()
 
-        val targetCall: IrFunctionAccessExpression =
+        val targetCall: IrFunctionAccessExpression<*> =
             when (targetFun) {
                 is IrSimpleFunction ->
                     IrCallImpl.fromSymbolOwner(startOffset, endOffset, targetFun.symbol)
@@ -470,7 +470,7 @@
             functionSuperClass.owner.getSingleAbstractMethod()
                 ?: throw AssertionError("Not a SAM class: ${functionSuperClass.owner.render()}")
 
-        private val adapteeCall: IrFunctionAccessExpression? =
+        private val adapteeCall: IrFunctionAccessExpression<*>? =
             if (callee.origin == IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE) {
                 // The body of a callable reference adapter contains either only a call, or an IMPLICIT_COERCION_TO_UNIT type operator
                 // applied to a call. That call's target is the original function which we need to get owner/name/signature.
@@ -484,7 +484,7 @@
                     is IrReturn -> statement.value
                     else -> statement
                 }
-                if (call !is IrFunctionAccessExpression) {
+                if (call !is IrFunctionAccessExpression<*>) {
                     throw UnsupportedOperationException("Unknown structure of ADAPTER_FOR_CALLABLE_REFERENCE: ${callee.render()}")
                 }
                 call
@@ -664,7 +664,7 @@
             }
 
         private fun JvmIrBuilder.generateConstructorCallArguments(
-            call: IrFunctionAccessExpression,
+            call: IrFunctionAccessExpression<*>,
             generateBoundReceiver: IrBuilder.() -> IrExpression,
         ) {
             if (isFunInterfaceConstructorReference) {
@@ -814,7 +814,7 @@
         }
 
         private fun inlineAdapterCallIfPossible(
-            expression: IrFunctionAccessExpression,
+            expression: IrFunctionAccessExpression<*>,
             invokeMethod: IrSimpleFunction,
         ): IrExpression {
             val irCall = expression as? IrCall

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt
index bbb26023..450548f 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultParameterInjector.kt

@@ -56,7 +56,7 @@
 
 
     override fun IrBlockBuilder.argumentsForCall(
-        expression: IrFunctionAccessExpression, stubFunction: IrFunction
+        expression: IrFunctionAccessExpression<*>, stubFunction: IrFunction
     ): Map<IrValueParameter, IrExpression?> {
         val startOffset = expression.startOffset
         val endOffset = expression.endOffset

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
index 59360b8..9347b53 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt

@@ -235,7 +235,7 @@
         }.copyAttributes(expression)
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         val function = expression.symbol.owner
         val replacement = context.inlineClassReplacements.getReplacementFunction(function)
             ?: return super.visitFunctionAccess(expression)

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt
index 6c57d7c..4d3995f 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt

@@ -870,7 +870,7 @@
         }
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         val function = expression.symbol.owner
         val currentScope = currentScope!!.irElement as IrDeclaration
         val replacement = replacements.getReplacementFunction(function)
@@ -905,7 +905,7 @@
                 val newConstructor = (function as? IrConstructor)
                     ?.let { replacements.getReplacementForRegularClassConstructor(it) }
                     ?: return super.visitFunctionAccess(expression)
-                val callFactory: (IrConstructorSymbol) -> IrFunctionAccessExpression = when (expression) {
+                val callFactory: (IrConstructorSymbol) -> IrFunctionAccessExpression<*> = when (expression) {
                     is IrConstructorCall -> { constructorSymbol ->
                         IrConstructorCallImpl.fromSymbolOwner(
                             expression.startOffset, expression.endOffset, expression.type, constructorSymbol, expression.origin

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt
index 7685a87..ac169de 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt

@@ -344,7 +344,7 @@
     }
 
     private fun JvmIrBuilder.fillReflectedPropertyArguments(
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         expression: IrCallableReference<*>,
         receiver: IrExpression?,
     ) {

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/RecordEnclosingMethodsLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/RecordEnclosingMethodsLowering.kt
index ce68518..7332223 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/RecordEnclosingMethodsLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/RecordEnclosingMethodsLowering.kt

@@ -33,7 +33,7 @@
             override fun visitElement(element: IrElement, data: IrFunction?) =
                 element.acceptChildren(this, element as? IrFunction ?: data)
 
-            override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: IrFunction?) {
+            override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: IrFunction?) {
                 require(data != null) { "function call not in a method: ${expression.render()}" }
                 when {
                     expression.symbol == context.ir.symbols.indyLambdaMetafactoryIntrinsic -> {

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SpecialAccess.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SpecialAccess.kt
index c019ee2..0ab1726 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SpecialAccess.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SpecialAccess.kt

@@ -319,7 +319,7 @@
             putValueArgument(0, expression)
         }
 
-    private fun IrFunctionAccessExpression.getValueArguments(): List<IrExpression> =
+    private fun IrFunctionAccessExpression<*>.getValueArguments(): List<IrExpression> =
         (0 until valueArgumentsCount).map { getValueArgument(it)!! }
 
     private fun generateReflectiveMethodInvocation(call: IrCall): IrExpression {

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt
index a684241..c6de23f 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt

@@ -151,7 +151,7 @@
             isAccessible(context, currentScope, inlineScopeResolver, withSuper, thisObjReference)
         }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         if (expression.usesDefaultArguments()) {
             return super.visitFunctionAccess(expression)
         }
@@ -182,7 +182,7 @@
     }
 
     private fun shouldGenerateSpecialAccessWithoutSyntheticAccessor(
-        expression: IrFunctionAccessExpression,
+        expression: IrFunctionAccessExpression<*>,
         withSuper: Boolean,
         thisObjReference: IrClassSymbol?,
     ): Boolean =

diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt
index 32d1858..d4bb369 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/VarargLowering.kt

@@ -42,7 +42,7 @@
         return super.visitConstructorCall(expression)
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         expression.transformChildrenVoid()
         val function = expression.symbol
 
@@ -71,7 +71,7 @@
                 is IrExpression -> +element.transform(this@VarargLowering, null)
                 is IrSpreadElement -> {
                     val spread = element.expression
-                    if (spread is IrFunctionAccessExpression && spread.symbol.owner.isArrayOf()) {
+                    if (spread is IrFunctionAccessExpression<*> && spread.symbol.owner.isArrayOf()) {
                         // Skip empty arrays and don't copy immediately created arrays
                         val argument = spread.getValueArgument(0) ?: continue@loop
                         if (argument is IrVararg) {

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 698bac5..9ee06c3 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

@@ -96,7 +96,7 @@
     // 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.symbol == builder.irSymbols.arrayOfNulls))
             return spread
 
         return builder.irBlock {

diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt
index 28666aa..420fd6b 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt

@@ -22,7 +22,7 @@
     override fun visitElement(element: IrElement, data: IrDeclaration?) =
         element.acceptChildren(this, if (element is IrDeclaration && element !is IrVariable) element else data)
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: IrDeclaration?) {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: IrDeclaration?) {
         val function = expression.symbol.owner
         if (function.isInlineFunctionCall(context)) {
             for (parameter in function.valueParameters) {

diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt
index 09c9643..5ad0be3 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt

@@ -621,7 +621,7 @@
         body.commentPreviousInstr { "box" }
     }
 
-    private fun generateCall(call: IrFunctionAccessExpression) {
+    private fun generateCall(call: IrFunctionAccessExpression<*>) {
         val location = call.getSourceLocation()
 
         // Box intrinsic has an additional klass ID argument.
@@ -771,7 +771,7 @@
     // Return true if generated.
     // Assumes call arguments are already on the stack
     private fun tryToGenerateIntrinsicCall(
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         function: IrFunction,
     ): Boolean {
         if (tryToGenerateWasmOpIntrinsicCall(call, function)) {
@@ -1210,7 +1210,7 @@
     }
 
     // Return true if function is recognized as intrinsic.
-    private fun tryToGenerateWasmOpIntrinsicCall(call: IrFunctionAccessExpression, function: IrFunction): Boolean {
+    private fun tryToGenerateWasmOpIntrinsicCall(call: IrFunctionAccessExpression<*>, function: IrFunction): Boolean {
         if (function.hasWasmNoOpCastAnnotation()) {
             return true
         }

diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/ComplexExternalDeclarationsToTopLevelFunctionsLowering.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/ComplexExternalDeclarationsToTopLevelFunctionsLowering.kt
index 68d8d0b..fd48cc4 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/ComplexExternalDeclarationsToTopLevelFunctionsLowering.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/ComplexExternalDeclarationsToTopLevelFunctionsLowering.kt

@@ -509,7 +509,7 @@
             )
         }
 
-        fun transformCall(call: IrFunctionAccessExpression): IrExpression {
+        fun transformCall(call: IrFunctionAccessExpression<*>): IrExpression {
             val oldFun = call.symbol.owner.realOverrideTarget
             val newFun: IrSimpleFunction = nestedExternalToNewTopLevelFunctions[oldFun] ?: return call
 

diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmVarargExpressionLowering.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmVarargExpressionLowering.kt
index e30c9cd..4cea552 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmVarargExpressionLowering.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmVarargExpressionLowering.kt

@@ -248,10 +248,10 @@
         }
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression) =
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>) =
         transformFunctionAccessExpression(expression)
 
-    private fun transformFunctionAccessExpression(expression: IrFunctionAccessExpression): IrExpression {
+    private fun transformFunctionAccessExpression(expression: IrFunctionAccessExpression<*>): IrExpression {
         expression.transformChildrenVoid()
         val builder by lazy { context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol) }
 
@@ -283,7 +283,7 @@
 
     private fun isImmediatelyCreatedArray(expr: IrExpression): Boolean =
         when (expr) {
-            is IrFunctionAccessExpression -> {
+            is IrFunctionAccessExpression<*> -> {
                 val arrDescr = ArrayDescr(expr.type, context)
                 expr.symbol.owner in arrDescr.constructors || expr.symbol == context.wasmSymbols.arrayOfNulls
             }

diff --git a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt
index a0ae98e..59ffaa4 100644
--- a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt
+++ b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt

@@ -121,7 +121,7 @@
 
     fun inline(irModule: IrModuleFragment) = irModule.accept(this, data = null)
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         expression.transformChildrenVoid(this)
         val calleeSymbol = when (expression) {
             is IrCall -> expression.symbol
@@ -180,7 +180,7 @@
     }
 
     private class CallInlining(
-        val callSite: IrFunctionAccessExpression,
+        val callSite: IrFunctionAccessExpression<*>,
         val callee: IrFunction,
         val currentScope: ScopeWithIr,
         val parent: IrDeclarationParent?,
@@ -209,7 +209,7 @@
         fun inline() = inlineFunction(callSite, callee, callee.originalFunction)
 
         private fun inlineFunction(
-            callSite: IrFunctionAccessExpression,
+            callSite: IrFunctionAccessExpression<*>,
             callee: IrFunction,
             originalInlinedElement: IrElement,
         ): IrReturnableBlock {
@@ -543,7 +543,7 @@
         }
 
         // callee might be a copied version of callsite.symbol.owner
-        private fun buildParameterToArgument(callSite: IrFunctionAccessExpression, callee: IrFunction): List<ParameterToArgument> {
+        private fun buildParameterToArgument(callSite: IrFunctionAccessExpression<*>, callee: IrFunction): List<ParameterToArgument> {
 
             val parameterToArgument = mutableListOf<ParameterToArgument>()
 
@@ -681,7 +681,7 @@
             return newVariable
         }
 
-        private fun evaluateArguments(callSite: IrFunctionAccessExpression, callee: IrFunction): List<IrStatement> {
+        private fun evaluateArguments(callSite: IrFunctionAccessExpression<*>, callee: IrFunction): List<IrStatement> {
             val arguments = buildParameterToArgument(callSite, callee)
             val evaluationStatements = mutableListOf<IrVariable>()
             val evaluationStatementsFromDefault = mutableListOf<IrVariable>()

diff --git a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineCallableReferenceToLambda.kt b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineCallableReferenceToLambda.kt
index 5557ad2..5843e07 100644
--- a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineCallableReferenceToLambda.kt
+++ b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineCallableReferenceToLambda.kt

@@ -53,7 +53,7 @@
     override fun visitDeclaration(declaration: IrDeclarationBase, data: IrDeclarationParent?) =
         super.visitDeclaration(declaration, declaration as? IrDeclarationParent ?: data)
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: IrDeclarationParent?): IrElement {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: IrDeclarationParent?): IrElement {
         expression.transformChildren(this, data)
         val function = expression.symbol.owner
         if (inlineFunctionResolver.needsInlining(function)) {

diff --git a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/SyntheticAccessorLowering.kt b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/SyntheticAccessorLowering.kt
index 9cb07fb..b47324f 100644
--- a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/SyntheticAccessorLowering.kt
+++ b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/SyntheticAccessorLowering.kt

@@ -168,7 +168,7 @@
             }
         }
 
-        override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: TransformerData?): IrElement {
+        override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>, data: TransformerData?): IrElement {
             if (data == null || !expression.symbol.owner.isRequiredToGenerateAccessor())
                 return super.visitFunctionAccess(expression, data)
 

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/CallInterceptor.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/CallInterceptor.kt
index 9a40700..d503bf1 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/CallInterceptor.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/CallInterceptor.kt

@@ -36,7 +36,7 @@
 
     fun interceptProxy(irFunction: IrFunction, valueArguments: List<State>, expectedResultClass: Class<*> = Any::class.java): Any?
     fun interceptCall(call: IrCall, irFunction: IrFunction, args: List<State>, defaultAction: () -> Unit)
-    fun interceptConstructor(constructorCall: IrFunctionAccessExpression, args: List<State>, defaultAction: () -> Unit)
+    fun interceptConstructor(constructorCall: IrFunctionAccessExpression<*>, args: List<State>, defaultAction: () -> Unit)
     fun interceptGetObjectValue(expression: IrGetObjectValue, defaultAction: () -> Unit)
     fun interceptEnumEntry(enumEntry: IrEnumEntry, defaultAction: () -> Unit)
     fun interceptJavaStaticField(expression: IrGetField)
@@ -74,7 +74,7 @@
         }
     }
 
-    override fun interceptConstructor(constructorCall: IrFunctionAccessExpression, args: List<State>, defaultAction: () -> Unit) {
+    override fun interceptConstructor(constructorCall: IrFunctionAccessExpression<*>, args: List<State>, defaultAction: () -> Unit) {
         val receiver = callStack.loadState(constructorCall.getThisReceiver())
         val irConstructor = constructorCall.symbol.owner
         val irClass = irConstructor.parentAsClass

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/InstructionsUnfolder.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/InstructionsUnfolder.kt
index 1b8a275..91fd513 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/InstructionsUnfolder.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/InstructionsUnfolder.kt

@@ -110,7 +110,7 @@
     }
 }
 
-private fun unfoldValueParameters(expression: IrFunctionAccessExpression, environment: IrInterpreterEnvironment) {
+private fun unfoldValueParameters(expression: IrFunctionAccessExpression<*>, environment: IrInterpreterEnvironment) {
     val callStack = environment.callStack
     val irFunction = expression.symbol.owner
 

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrInterpreter.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrInterpreter.kt
index ae85328..d9c7ab7 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrInterpreter.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrInterpreter.kt

@@ -221,7 +221,7 @@
         callStack.dropFrameAndCopyResult()
     }
 
-    private fun interpretConstructorCall(constructorCall: IrFunctionAccessExpression) {
+    private fun interpretConstructorCall(constructorCall: IrFunctionAccessExpression<*>) {
         val constructor = constructorCall.symbol.owner
         val valueArguments = constructor.valueParameters.map { callStack.popState() }.reversed()
         val irClass = constructor.parentAsClass
@@ -251,9 +251,9 @@
 
         val superReceiver = when (val irStatement = constructor.body?.statements?.getOrNull(0)) {
             null -> null // for jvm
-            is IrTypeOperatorCall -> (irStatement.argument as IrFunctionAccessExpression).getThisReceiver() // for enums
-            is IrFunctionAccessExpression -> irStatement.getThisReceiver()
-            is IrBlock -> (irStatement.statements.last() as IrFunctionAccessExpression).getThisReceiver()
+            is IrTypeOperatorCall -> (irStatement.argument as IrFunctionAccessExpression<*>).getThisReceiver() // for enums
+            is IrFunctionAccessExpression<*> -> irStatement.getThisReceiver()
+            is IrBlock -> (irStatement.statements.last() as IrFunctionAccessExpression<*>).getThisReceiver()
             else -> TODO("${irStatement::class.java} is not supported as first statement in constructor call")
         }
         superReceiver?.let { callStack.storeState(it, objectState) }

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrTreeBuildUtils.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrTreeBuildUtils.kt
index d8a949d..9c466ba 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrTreeBuildUtils.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrTreeBuildUtils.kt

@@ -115,7 +115,7 @@
     return IrFactoryImpl.createBlockBody(SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, this)
 }
 
-internal fun IrFunctionAccessExpression.shallowCopy(copyTypeArguments: Boolean = true): IrFunctionAccessExpression {
+internal fun IrFunctionAccessExpression<*>.shallowCopy(copyTypeArguments: Boolean = true): IrFunctionAccessExpression<*> {
     return when (this) {
         is IrCall -> symbol.owner.createCall()
         is IrConstructorCall -> symbol.owner.createConstructorCall()
@@ -129,7 +129,7 @@
     }
 }
 
-internal fun IrBuiltIns.copyArgs(from: IrFunctionAccessExpression, into: IrFunctionAccessExpression) {
+internal fun IrBuiltIns.copyArgs(from: IrFunctionAccessExpression<*>, into: IrFunctionAccessExpression<*>) {
     into.dispatchReceiver = from.dispatchReceiver
     into.extensionReceiver = from.extensionReceiver
     (0 until from.valueArgumentsCount)

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/Utils.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/Utils.kt
index ec1d6e0..2146d9b 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/Utils.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/Utils.kt

@@ -47,7 +47,7 @@
 
 internal fun IrFunction.getReceiver(): IrSymbol? = this.getDispatchReceiver() ?: this.getExtensionReceiver()
 
-internal fun IrFunctionAccessExpression.getThisReceiver(): IrValueSymbol = this.symbol.owner.parentAsClass.thisReceiver!!.symbol
+internal fun IrFunctionAccessExpression<*>.getThisReceiver(): IrValueSymbol = this.symbol.owner.parentAsClass.thisReceiver!!.symbol
 
 internal fun IrConst.toPrimitive(): Primitive = when {
     type.isByte() -> Primitive((value as Number).toByte(), type)
@@ -122,7 +122,7 @@
     }
 }
 
-fun IrFunctionAccessExpression.getVarargType(index: Int): IrType? {
+fun IrFunctionAccessExpression<*>.getVarargType(index: Int): IrType? {
     val varargType = this.symbol.owner.valueParameters[index].varargElementType ?: return null
     varargType.classOrNull?.let { return this.symbol.owner.valueParameters[index].type }
     val type = this.symbol.owner.valueParameters[index].type as? IrSimpleType ?: return null
@@ -231,7 +231,7 @@
     return property.getter!!.getLastOverridden().property!!
 }
 
-internal fun IrFunctionAccessExpression.getFunctionThatContainsDefaults(): IrFunction {
+internal fun IrFunctionAccessExpression<*>.getFunctionThatContainsDefaults(): IrFunction {
     val irFunction = this.symbol.owner
     fun IrValueParameter.lookup(): IrFunction? {
         return defaultValue?.let { this.parent as IrFunction }
@@ -290,7 +290,7 @@
     }
 }
 
-internal fun IrInterpreterEnvironment.loadReifiedTypeArguments(expression: IrFunctionAccessExpression): Map<IrTypeParameterSymbol, KTypeState> {
+internal fun IrInterpreterEnvironment.loadReifiedTypeArguments(expression: IrFunctionAccessExpression<*>): Map<IrTypeParameterSymbol, KTypeState> {
     return expression.symbol.owner.typeParameters.filter { it.isReified }.map { it.symbol }.keysToMap {
         val reifiedType = expression.getTypeArgument(it.owner.index)!!.getTypeIfReified(callStack)
         KTypeState(reifiedType, this.kTypeClass.owner)

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/IrInterpreterCommonChecker.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/IrInterpreterCommonChecker.kt
index f8a2715..294285dd 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/IrInterpreterCommonChecker.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/IrInterpreterCommonChecker.kt

@@ -38,7 +38,7 @@
         return statements.all { it.accept(this, data) }
     }
 
-    private fun visitConstructor(expression: IrFunctionAccessExpression, data: IrInterpreterCheckerData): Boolean {
+    private fun visitConstructor(expression: IrFunctionAccessExpression<*>, data: IrInterpreterCheckerData): Boolean {
         val constructor = expression.symbol.owner
 
         if (!data.mode.canEvaluateFunction(constructor)) return false
@@ -77,7 +77,7 @@
         return declaration.initializer?.accept(this, data) ?: true
     }
 
-    private fun visitValueArguments(expression: IrFunctionAccessExpression, data: IrInterpreterCheckerData): Boolean {
+    private fun visitValueArguments(expression: IrFunctionAccessExpression<*>, data: IrInterpreterCheckerData): Boolean {
         return (0 until expression.valueArgumentsCount)
             .map { expression.getValueArgument(it) }
             .none { it?.accept(this, data) == false }

diff --git a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/proxy/reflection/KFunctionProxy.kt b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/proxy/reflection/KFunctionProxy.kt
index 06f99e1..197b94d 100644
--- a/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/proxy/reflection/KFunctionProxy.kt
+++ b/compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/proxy/reflection/KFunctionProxy.kt

@@ -111,7 +111,7 @@
             is IrReturn -> statement.value
             else -> statement
         }
-        return (call as? IrFunctionAccessExpression)?.symbol
+        return (call as? IrFunctionAccessExpression<*>)?.symbol
     }
 
     private fun IrFunction.equalsByAdapteeCall(other: IrFunction): Boolean {
@@ -132,7 +132,7 @@
             else -> Pair(statement, otherStatement)
         }
 
-        if (thisArg !is IrFunctionAccessExpression || otherArg !is IrFunctionAccessExpression) return false
+        if (thisArg !is IrFunctionAccessExpression<*> || otherArg !is IrFunctionAccessExpression<*>) return false
         if (thisArg.symbol != otherArg.symbol) return false
 
         return true

diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt
index c1fc509..39bcbaa 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt

@@ -401,7 +401,7 @@
         startOffset: Int,
         endOffset: Int,
         call: CallBuilder,
-        irCall: IrFunctionAccessExpression,
+        irCall: IrFunctionAccessExpression<*>,
         irResultType: IrType,
         contextReceivers: List<IrExpression>
     ): IrExpression {
@@ -418,7 +418,7 @@
     }
 
     private fun generateCallWithArgumentReordering(
-        irCall: IrFunctionAccessExpression,
+        irCall: IrFunctionAccessExpression<*>,
         startOffset: Int,
         endOffset: Int,
         call: CallBuilder,

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 b2b294e..6514a48 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

@@ -349,7 +349,7 @@
     private fun putAdaptedValueArguments(
         startOffset: Int,
         endOffset: Int,
-        irAdapteeCall: IrFunctionAccessExpression,
+        irAdapteeCall: IrFunctionAccessExpression<*>,
         irAdapterFun: IrSimpleFunction,
         resolvedCall: ResolvedCall<*>
     ) {

diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/IrFunctionAccessExpression.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/IrFunctionAccessExpression.kt
index abe8f20..acc355e 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/IrFunctionAccessExpression.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/IrFunctionAccessExpression.kt

@@ -14,5 +14,7 @@
  * Generated from: [org.jetbrains.kotlin.ir.generator.IrTree.functionAccessExpression]
  */
 sealed class IrFunctionAccessExpression<S : IrFunctionSymbol> : IrMemberAccessExpression<S>() {
+    abstract override var symbol: S
+
     abstract var contextReceiversCount: Int
 }

diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt
index 64e50c1..26f2926 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt

@@ -24,10 +24,10 @@
     override val startOffset: Int,
     override val endOffset: Int,
     override var type: IrType,
-    override val symbol: IrSimpleFunctionSymbol,
     override var origin: IrStatementOrigin?,
     protected override val valueArguments: Array<IrExpression?>,
     protected override val typeArguments: Array<IrType?>,
+    override var symbol: IrSimpleFunctionSymbol,
     override var superQualifierSymbol: IrClassSymbol?,
 ) : IrCall() {
     override var attributeOwnerId: IrAttributeContainer = this

diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt
index 4870148..5e89becd 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt

@@ -26,10 +26,10 @@
     override val startOffset: Int,
     override val endOffset: Int,
     override var type: IrType,
-    override val symbol: IrConstructorSymbol,
     override var origin: IrStatementOrigin?,
     protected override val valueArguments: Array<IrExpression?>,
     protected override val typeArguments: Array<IrType?>,
+    override var symbol: IrConstructorSymbol,
     override var source: SourceElement,
     override var constructorTypeArgumentsCount: Int,
 ) : IrConstructorCall() {

diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
index 7bb1e82..01e2dba 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt

@@ -23,10 +23,10 @@
     override val startOffset: Int,
     override val endOffset: Int,
     override var type: IrType,
-    override val symbol: IrConstructorSymbol,
     override var origin: IrStatementOrigin?,
     protected override val valueArguments: Array<IrExpression?>,
     protected override val typeArguments: Array<IrType?>,
+    override var symbol: IrConstructorSymbol,
 ) : IrDelegatingConstructorCall() {
     override var attributeOwnerId: IrAttributeContainer = this
 

diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt
index eb4fb99..8371378 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt

@@ -23,10 +23,10 @@
     override val startOffset: Int,
     override val endOffset: Int,
     override var type: IrType,
-    override val symbol: IrConstructorSymbol,
     override var origin: IrStatementOrigin?,
     protected override val valueArguments: Array<IrExpression?>,
     protected override val typeArguments: Array<IrType?>,
+    override var symbol: IrConstructorSymbol,
 ) : IrEnumConstructorCall() {
     override var attributeOwnerId: IrAttributeContainer = this
 

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 3715d99..981583a 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

@@ -265,7 +265,7 @@
         constructorTypeArgumentsCount = callee.owner.typeParameters.size
     )
 
-fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol, type: IrType): IrFunctionAccessExpression =
+fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol, type: IrType): IrFunctionAccessExpression<*> =
     when (callee) {
         is IrConstructorSymbol -> irCall(callee, type)
         is IrSimpleFunctionSymbol -> irCall(callee, type)
@@ -277,10 +277,10 @@
 fun IrBuilderWithScope.irCall(callee: IrConstructorSymbol): IrConstructorCall =
     irCall(callee, callee.owner.returnType)
 
-fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol): IrFunctionAccessExpression =
+fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol): IrFunctionAccessExpression<*> =
     irCall(callee, callee.owner.returnType)
 
-fun IrBuilderWithScope.irCall(callee: IrFunction): IrFunctionAccessExpression =
+fun IrBuilderWithScope.irCall(callee: IrFunction): IrFunctionAccessExpression<*> =
     irCall(callee.symbol)
 
 fun IrBuilderWithScope.irCall(callee: IrFunction, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null): IrCall =

diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrExpressions.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrExpressions.kt
index 391dd27..6dc8e30 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrExpressions.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrExpressions.kt

@@ -35,7 +35,7 @@
             arguments[0] = value
     }
 
-fun IrFunctionAccessExpression.putArgument(parameter: IrValueParameter, argument: IrExpression): Unit =
+fun IrFunctionAccessExpression<*>.putArgument(parameter: IrValueParameter, argument: IrExpression): Unit =
     putArgument(symbol.owner, parameter, argument)
 
 fun IrVararg.putElement(i: Int, element: IrVarargElement) {

diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrInlineUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrInlineUtils.kt
index 662adc5..4a2fae0 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrInlineUtils.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrInlineUtils.kt

@@ -24,7 +24,7 @@
 annotation class JvmIrInlineExperimental
 
 @JvmIrInlineExperimental
-var IrInlinedFunctionBlock.inlineCall: IrFunctionAccessExpression? by irAttribute(followAttributeOwner = true)
+var IrInlinedFunctionBlock.inlineCall: IrFunctionAccessExpression<*>? by irAttribute(followAttributeOwner = true)
 @JvmIrInlineExperimental
 var IrInlinedFunctionBlock.inlinedElement: IrElement? by irAttribute(followAttributeOwner = true)
 

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 2fb1e04..fa89379 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

@@ -69,7 +69,7 @@
  */
 @ObsoleteDescriptorBasedAPI
 @Suppress("unused") // Used in kotlin-native
-fun IrFunctionAccessExpression.getArgumentsWithSymbols(): List<Pair<IrValueParameterSymbol, IrExpression>> {
+fun IrFunctionAccessExpression<*>.getArgumentsWithSymbols(): List<Pair<IrValueParameterSymbol, IrExpression>> {
     val res = mutableListOf<Pair<IrValueParameterSymbol, IrExpression>>()
     val irFunction = symbol.owner
 
@@ -97,7 +97,7 @@
  */
 fun IrMemberAccessExpression<*>.getAllArgumentsWithIr(): List<Pair<IrValueParameter, IrExpression?>> {
     val irFunction = when (this) {
-        is IrFunctionAccessExpression -> this.symbol.owner
+        is IrFunctionAccessExpression<*> -> this.symbol.owner
         is IrFunctionReference -> this.symbol.owner
         is IrPropertyReference -> {
             assert(this.field == null) { "Field should be null to use `getArgumentsWithIr` on IrPropertyReference: ${this.dump()}}" }
@@ -197,7 +197,7 @@
     else
         IrTypeOperatorCallImpl(startOffset, endOffset, type, IrTypeOperator.IMPLICIT_CAST, type, this)
 
-fun IrFunctionAccessExpression.usesDefaultArguments(): Boolean =
+fun IrFunctionAccessExpression<*>.usesDefaultArguments(): Boolean =
     symbol.owner.valueParameters.any { this.getValueArgument(it.index) == null && (!it.isVararg || it.defaultValue != null) }
 
 fun IrValueParameter.createStubDefaultValue(): IrExpressionBody =
@@ -505,7 +505,7 @@
  * [argumentsAsDispatchers]: optionally convert static call to call with dispatch receiver
  */
 fun irConstructorCall(
-    call: IrFunctionAccessExpression,
+    call: IrFunctionAccessExpression<IrFunctionSymbol>,
     newSymbol: IrConstructorSymbol,
     receiversAsArguments: Boolean = false,
     argumentsAsDispatchers: Boolean = false
@@ -530,7 +530,7 @@
     }
 
 fun irCall(
-    call: IrFunctionAccessExpression,
+    call: IrFunctionAccessExpression<IrFunctionSymbol>,
     newFunction: IrSimpleFunction,
     receiversAsArguments: Boolean = false,
     argumentsAsReceivers: Boolean = false,
@@ -547,7 +547,7 @@
     )
 
 fun irCall(
-    call: IrFunctionAccessExpression,
+    call: IrFunctionAccessExpression<IrFunctionSymbol>,
     newSymbol: IrSimpleFunctionSymbol,
     receiversAsArguments: Boolean = false,
     argumentsAsReceivers: Boolean = false,
@@ -692,7 +692,7 @@
 val IrFunctionReference.typeSubstitutionMap: Map<IrTypeParameterSymbol, IrType>
     get() = getTypeSubstitutionMap(symbol.owner)
 
-val IrFunctionAccessExpression.typeSubstitutionMap: Map<IrTypeParameterSymbol, IrType>
+val IrFunctionAccessExpression<*>.typeSubstitutionMap: Map<IrTypeParameterSymbol, IrType>
     get() = getTypeSubstitutionMap(symbol.owner)
 
 val IrDeclaration.isFileClass: Boolean
@@ -1084,7 +1084,7 @@
     }
 }
 
-fun IrFunctionAccessExpression.passTypeArgumentsFrom(irFunction: IrTypeParametersContainer, offset: Int = 0) {
+fun IrFunctionAccessExpression<*>.passTypeArgumentsFrom(irFunction: IrTypeParametersContainer, offset: Int = 0) {
     irFunction.typeParameters.forEachIndexed { i, param ->
         putTypeArgument(i + offset, param.defaultType)
     }
@@ -1626,7 +1626,7 @@
     file.module = this
 }
 
-fun IrFunctionAccessExpression.receiverAndArgs(): List<IrExpression> {
+fun IrFunctionAccessExpression<*>.receiverAndArgs(): List<IrExpression> {
     return (arrayListOf(this.dispatchReceiver, this.extensionReceiver) +
             symbol.owner.valueParameters.mapIndexed { i, _ -> getValueArgument(i) }).filterNotNull()
 }

diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/dumpKotlinLike.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/dumpKotlinLike.kt
index fbf55ee..8975c0b 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/dumpKotlinLike.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/dumpKotlinLike.kt

@@ -1217,7 +1217,7 @@
         expression.printConstructorCallWithNoIndent(data)
     }
 
-    private fun IrFunctionAccessExpression.printConstructorCallWithNoIndent(
+    private fun IrFunctionAccessExpression<*>.printConstructorCallWithNoIndent(
         data: IrDeclaration?
     ) {
         // TODO flag to omit comment block?

diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/IrTree.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/IrTree.kt
index 6ced66b..c062afe 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/IrTree.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/IrTree.kt

@@ -675,6 +675,7 @@
 
         parent(memberAccessExpression.withArgs("S" to s))
 
+        +referencedSymbol(s)
         +field("contextReceiversCount", int)
     }
     val constructorCall: Element by element(Expression) {

diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/linkage/partial/PartiallyLinkedIrTreePatcher.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/linkage/partial/PartiallyLinkedIrTreePatcher.kt
index 515bd4f..9f64a39 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/linkage/partial/PartiallyLinkedIrTreePatcher.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/linkage/partial/PartiallyLinkedIrTreePatcher.kt

@@ -766,7 +766,7 @@
                 )
 
             when (this) {
-                is IrFunctionAccessExpression -> {
+                is IrFunctionAccessExpression<*> -> {
                     if (function.isExternal) {
                         // External functions may have the default arguments declared in native implementations,
                         // which are not available from Kotlin.
@@ -1043,7 +1043,7 @@
         ) { super.visitBlockBody(body) }
 
         // Allows visiting any type of call: IrCall, IrConstructorCall, IrEnumConstructorCall, IrDelegatingConstructorCall.
-        override fun visitFunctionAccess(expression: IrFunctionAccessExpression) = withContext(
+        override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>) = withContext(
             { oldContext ->
                 val functionSymbol = expression.symbol
                 val function = if (functionSymbol.isBound) functionSymbol.owner else return@withContext oldContext

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt
index 1f42d40..20b2c76 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt

@@ -50,13 +50,13 @@
     protected open fun IrExpression.useAsArgument(parameter: IrValueParameter): IrExpression =
             this.useAsValue(parameter)
 
-    protected open fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression): IrExpression =
+    protected open fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression<*>): IrExpression =
             this.useAsArgument(expression.symbol.owner.dispatchReceiverParameter!!)
 
-    protected open fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression): IrExpression =
+    protected open fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression<*>): IrExpression =
             this.useAsArgument(expression.symbol.owner.extensionReceiverParameter!!)
 
-    protected open fun IrExpression.useAsValueArgument(expression: IrFunctionAccessExpression,
+    protected open fun IrExpression.useAsValueArgument(expression: IrFunctionAccessExpression<*>,
                                                        parameter: IrValueParameter
     ): IrExpression =
             this.useAsArgument(parameter)
@@ -92,7 +92,7 @@
         TODO()
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
         expression.transformChildrenVoid(this)
 
         with(expression) {

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt
index aecc7c1..456d41a 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt

@@ -308,7 +308,7 @@
         isStret: Boolean,
         selector: String,
         directSymbolName: String?,
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         superQualifier: IrClassSymbol?,
         receiver: ObjCCallReceiver,
         arguments: List<IrExpression?>

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt
index f36fe7d..6b89c75 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt

@@ -74,7 +74,7 @@
         return (this.superQualifierSymbol?.owner?.getOverridingOf(callee) ?: callee).target
     }
 
-internal val IrFunctionAccessExpression.isVirtualCall: Boolean
+internal val IrFunctionAccessExpression<*>.isVirtualCall: Boolean
     get() = this is IrCall && this.superQualifierSymbol == null && this.symbol.owner.isOverridable
 
 private fun IrClass.getOverridingOf(function: IrFunction) = (function as? IrSimpleFunction)?.let {

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt
index 95999b7..5b7638a 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt

@@ -128,7 +128,7 @@
 
     fun calculateLifetime(element: IrElement): Lifetime
 
-    fun evaluateExplicitArgs(expression: IrFunctionAccessExpression): List<LLVMValueRef>
+    fun evaluateExplicitArgs(expression: IrFunctionAccessExpression<*>): List<LLVMValueRef>
 
     fun evaluateExpression(value: IrExpression, resultSlot: LLVMValueRef?): LLVMValueRef
 
@@ -137,13 +137,13 @@
     fun getStaticFieldPointer(field: IrField): LLVMValueRef
 }
 
-internal fun tryGetIntrinsicType(callSite: IrFunctionAccessExpression): IntrinsicType? =
+internal fun tryGetIntrinsicType(callSite: IrFunctionAccessExpression<*>): IntrinsicType? =
         tryGetIntrinsicType(callSite.symbol.owner)
 
 internal fun tryGetIntrinsicType(function: IrFunction): IntrinsicType? =
         if (function.isTypedIntrinsic) getIntrinsicType(function) else null
 
-private fun getIntrinsicType(callSite: IrFunctionAccessExpression) = getIntrinsicType(callSite.symbol.owner)
+private fun getIntrinsicType(callSite: IrFunctionAccessExpression<*>) = getIntrinsicType(callSite.symbol.owner)
 
 private fun getIntrinsicType(function: IrFunction): IntrinsicType {
     val annotation = function.annotations.findAnnotation(RuntimeNames.typedIntrinsicAnnotation)!!
@@ -179,7 +179,7 @@
      * processes it. Otherwise, it returns null.
      */
     @Suppress("UNUSED_PARAMETER")
-    fun tryEvaluateSpecialCall(callSite: IrFunctionAccessExpression, resultSlot: LLVMValueRef?): LLVMValueRef? {
+    fun tryEvaluateSpecialCall(callSite: IrFunctionAccessExpression<*>, resultSlot: LLVMValueRef?): LLVMValueRef? {
         val function = callSite.symbol.owner
         if (!function.isTypedIntrinsic) {
             return null

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt
index eefe9a5..9a28458 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt

@@ -245,7 +245,7 @@
         override val exceptionHandler: ExceptionHandler
             get() = currentCodeContext.exceptionHandler
 
-        override fun evaluateExplicitArgs(expression: IrFunctionAccessExpression): List<LLVMValueRef> =
+        override fun evaluateExplicitArgs(expression: IrFunctionAccessExpression<*>): List<LLVMValueRef> =
                 this@CodeGeneratorVisitor.evaluateExplicitArgs(expression)
 
         override fun evaluateExpression(value: IrExpression, resultSlot: LLVMValueRef?): LLVMValueRef =
@@ -2310,7 +2310,7 @@
      * Returns results in the same order as LLVM function expects, assuming that all explicit arguments
      * exactly correspond to a tail of LLVM parameters.
      */
-    private fun evaluateExplicitArgs(expression: IrFunctionAccessExpression): List<LLVMValueRef> {
+    private fun evaluateExplicitArgs(expression: IrFunctionAccessExpression<*>): List<LLVMValueRef> {
         val result = expression.getArgumentsWithIr().map { (_, argExpr) ->
             evaluateExpression(argExpr)
         }

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt
index c509f70..b09c3f4 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt

@@ -122,7 +122,7 @@
             this.adaptIfNecessary(actualType, type, skipTypeCheck)
     }
 
-    private val IrFunctionAccessExpression.target: IrFunction
+    private val IrFunctionAccessExpression<*>.target: IrFunction
         get() = when (this) {
             is IrCall -> this.callTarget
             is IrDelegatingConstructorCall -> this.symbol.owner
@@ -137,18 +137,18 @@
             symbol.owner.target
         }
 
-    override fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression): IrExpression {
+    override fun IrExpression.useAsDispatchReceiver(expression: IrFunctionAccessExpression<*>): IrExpression {
         val target = expression.target
         return useAs(target.dispatchReceiverParameter!!.type,
                 // A bridge cannot be called on an improper receiver.
                 forceSkipTypeCheck = (currentFunction as? IrSimpleFunction)?.bridgeTarget == target)
     }
 
-    override fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression): IrExpression {
+    override fun IrExpression.useAsExtensionReceiver(expression: IrFunctionAccessExpression<*>): IrExpression {
         return this.useAsArgument(expression.target.extensionReceiverParameter!!)
     }
 
-    override fun IrExpression.useAsValueArgument(expression: IrFunctionAccessExpression,
+    override fun IrExpression.useAsValueArgument(expression: IrFunctionAccessExpression<*>,
                                                  parameter: IrValueParameter): IrExpression {
         return this.useAsArgument(expression.target.valueParameters[parameter.index])
     }

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ConstructorsLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ConstructorsLowering.kt
index 3615888..f26a1c4 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ConstructorsLowering.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ConstructorsLowering.kt

@@ -215,7 +215,7 @@
         }
     }
 
-    private fun IrFunctionAccessExpression.fillArgumentsFrom(callSite: IrFunctionAccessExpression) {
+    private fun IrFunctionAccessExpression<*>.fillArgumentsFrom(callSite: IrFunctionAccessExpression<*>) {
         val constructedClass = callSite.symbol.owner.parentAsClass
         val outerReceiver = callSite.dispatchReceiver
         if (outerReceiver == null && constructedClass.isInner)

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt
index 4cbfd17..45b4fe7 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt

@@ -549,7 +549,7 @@
             superQualifier: IrClassSymbol?,
             receiver: IrExpression,
             arguments: List<IrExpression?>,
-            call: IrFunctionAccessExpression,
+            call: IrFunctionAccessExpression<*>,
             method: IrSimpleFunction
     ): IrExpression = genLoweredObjCMethodCall(
             info = info,
@@ -565,7 +565,7 @@
             superQualifier: IrClassSymbol?,
             receiver: ObjCCallReceiver,
             arguments: List<IrExpression?>,
-            call: IrFunctionAccessExpression,
+            call: IrFunctionAccessExpression<*>,
             method: IrSimpleFunction
     ): IrExpression = generateWithStubs(call) {
         if (method.parent !is IrClass) {
@@ -759,7 +759,7 @@
             classPtr: IrExpression,
             initMethodInfo: ObjCMethodInfo,
             arguments: List<IrExpression?>,
-            call: IrFunctionAccessExpression,
+            call: IrFunctionAccessExpression<*>,
             initMethod: IrSimpleFunction
     ): IrExpression = genLoweredObjCMethodCall(
             initMethodInfo,
@@ -961,7 +961,7 @@
         return irBlock
     }
 
-    private fun IrBuilderWithScope.transformManagedArguments(oldCall: IrFunctionAccessExpression, oldFunction: IrFunction, newCall: IrFunctionAccessExpression, newFunction: IrFunction) {
+    private fun IrBuilderWithScope.transformManagedArguments(oldCall: IrFunctionAccessExpression<*>, oldFunction: IrFunction, newCall: IrFunctionAccessExpression<*>, newFunction: IrFunction) {
         for (index in 0 until oldCall.valueArgumentsCount) {
             val newArgument = irBlock {
                 val oldArgument = irTemporary(oldCall.getValueArgument(index)!!)

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt
index b629be9..0b5cd6c 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt

@@ -686,7 +686,7 @@
 
 private fun BackendChecker.checkCanGenerateObjCCall(
         method: IrSimpleFunction,
-        call: IrFunctionAccessExpression,
+        call: IrFunctionAccessExpression<*>,
         arguments: List<IrExpression?>
 ) {
     checkCanAddArguments(arguments, method, isObjCMethod = true)
@@ -762,7 +762,7 @@
 
 private sealed class TypeLocation(val element: IrElement) {
     class FunctionArgument(val argument: IrExpression) : TypeLocation(argument)
-    class FunctionCallResult(val call: IrFunctionAccessExpression) : TypeLocation(call)
+    class FunctionCallResult(val call: IrFunctionAccessExpression<*>) : TypeLocation(call)
 
     class FunctionPointerParameter(val index: Int, element: IrElement) : TypeLocation(element)
     class FunctionPointerReturnValue(element: IrElement) : TypeLocation(element)

diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/VarargLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/VarargLowering.kt
index dae889e..8d46bbc 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/VarargLowering.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/VarargLowering.kt

@@ -69,7 +69,7 @@
 
             val transformer = this
 
-            private fun replaceEmptyParameterWithEmptyArray(expression: IrFunctionAccessExpression) {
+            private fun replaceEmptyParameterWithEmptyArray(expression: IrFunctionAccessExpression<*>) {
                 val callee = expression.symbol.owner
                 log { "call of: ${callee.fqNameForIrSerialization}" }
                 context.createIrBuilder(owner, expression.startOffset, expression.endOffset).apply {
@@ -93,7 +93,7 @@
                 expression.transformChildrenVoid(this)
             }
 
-            override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
+            override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>): IrExpression {
                 replaceEmptyParameterWithEmptyArray(expression)
                 return expression
             }

diff --git a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuIrBuilder.kt b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuIrBuilder.kt
index 4c5e999..1ef8d71 100644
--- a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuIrBuilder.kt
+++ b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuIrBuilder.kt

@@ -135,7 +135,7 @@
         atomicArrayClass: IrClassSymbol,
         size: IrExpression,
         dispatchReceiver: IrExpression?
-    ): IrFunctionAccessExpression
+    ): IrFunctionAccessExpression<*>
 
     // atomicArr.compareAndSet(index, expect, update)
     fun callAtomicArray(

diff --git a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuTransformer.kt b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuTransformer.kt
index 6972c76..7ed4743 100644
--- a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuTransformer.kt
+++ b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/common/AbstractAtomicfuTransformer.kt

@@ -328,7 +328,7 @@
                     atomicArrayField.isStatic,
                     atomicArrayField.annotations,
                     arraySize,
-                    (atomicFactoryCall as IrFunctionAccessExpression).dispatchReceiver,
+                    (atomicFactoryCall as IrFunctionAccessExpression<*>).dispatchReceiver,
                     parentContainer
                 ).also {
                     val initExpr = it.initializer?.expression
@@ -344,7 +344,7 @@
                     atomicArrayField.isStatic,
                     atomicArrayField.annotations,
                     arraySize,
-                    (initializer as IrFunctionAccessExpression).dispatchReceiver,
+                    (initializer as IrFunctionAccessExpression<*>).dispatchReceiver,
                     parentContainer
                 )
             }
@@ -1051,7 +1051,7 @@
 
     // AtomicIntArray(size = 10) -> 10
     protected fun IrExpression.getArraySizeArgument(): IrExpression {
-        require(this is IrFunctionAccessExpression) {
+        require(this is IrFunctionAccessExpression<*>) {
             "Expected atomic array factory invocation, but found: ${this.render()}."
         }
         return getValueArgument(0)?.deepCopyWithSymbols()

diff --git a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/js/TransformerUtil.kt b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/js/TransformerUtil.kt
index 51d681a..3009dc5 100644
--- a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/js/TransformerUtil.kt
+++ b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/js/TransformerUtil.kt

@@ -122,7 +122,7 @@
 internal fun IrField.getterName() = "<get-${name.asString()}>"
 internal fun IrField.setterName() = "<set-${name.asString()}>"
 
-internal fun IrFunctionAccessExpression.getValueArguments() =
+internal fun IrFunctionAccessExpression<*>.getValueArguments() =
     (0 until valueArgumentsCount).map { i ->
         getValueArgument(i)
     }

diff --git a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/jvm/JvmAtomicfuIrBuilder.kt b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/jvm/JvmAtomicfuIrBuilder.kt
index d9f56b1..26cfc87 100644
--- a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/jvm/JvmAtomicfuIrBuilder.kt
+++ b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/jvm/JvmAtomicfuIrBuilder.kt

@@ -79,7 +79,7 @@
         atomicArrayClass: IrClassSymbol,
         size: IrExpression,
         dispatchReceiver: IrExpression?
-    ): IrFunctionAccessExpression = irCall(atomicSymbols.getAtomicArrayConstructor(atomicArrayClass)).apply {
+    ): IrFunctionAccessExpression<*> = irCall(atomicSymbols.getAtomicArrayConstructor(atomicArrayClass)).apply {
         putValueArgument(0, size) // size
         this.dispatchReceiver = dispatchReceiver
     }

diff --git a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/native/NativeAtomicfuIrBuilder.kt b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/native/NativeAtomicfuIrBuilder.kt
index 689ad9e..0161a19 100644
--- a/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/native/NativeAtomicfuIrBuilder.kt
+++ b/plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/backend/native/NativeAtomicfuIrBuilder.kt

@@ -373,7 +373,7 @@
         atomicArrayClass: IrClassSymbol,
         size: IrExpression,
         dispatchReceiver: IrExpression?
-    ): IrFunctionAccessExpression =
+    ): IrFunctionAccessExpression<*> =
         when (atomicArrayClass) {
             atomicSymbols.atomicIntArrayClassSymbol, atomicSymbols.atomicLongArrayClassSymbol -> {
                 irCall(atomicSymbols.getAtomicArrayConstructor(atomicArrayClass)).apply {

diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/analysis/ComposeWritableSlices.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/analysis/ComposeWritableSlices.kt
index e18f037..6636aa5 100644
--- a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/analysis/ComposeWritableSlices.kt
+++ b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/analysis/ComposeWritableSlices.kt

@@ -10,7 +10,7 @@
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 
 object ComposeWritableSlices {
-    val IS_SYNTHETIC_COMPOSABLE_CALL: WritableSlice<IrFunctionAccessExpression, Boolean> =
+    val IS_SYNTHETIC_COMPOSABLE_CALL: WritableSlice<IrFunctionAccessExpression<*>, Boolean> =
         BasicWritableSlice(RewritePolicy.DO_NOTHING)
     val IS_STATIC_FUNCTION_EXPRESSION: WritableSlice<IrExpression, Boolean> =
         BasicWritableSlice(RewritePolicy.DO_NOTHING)

diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ComposableFunctionBodyTransformer.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ComposableFunctionBodyTransformer.kt
index c3873f3..88c1b13e 100644
--- a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ComposableFunctionBodyTransformer.kt
+++ b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ComposableFunctionBodyTransformer.kt

@@ -191,7 +191,7 @@
         exactName: Boolean = false
     ): IrChangedBitMaskVariable
     fun putAsValueArgumentInWithLowBit(
-        fn: IrFunctionAccessExpression,
+        fn: IrFunctionAccessExpression<*>,
         startIndex: Int,
         lowBit: Boolean
     )
@@ -202,7 +202,7 @@
 interface IrDefaultBitMaskValue {
     fun irIsolateBitAtIndex(index: Int): IrExpression
     fun irHasAnyProvidedAndUnstable(unstable: BooleanArray): IrExpression
-    fun putAsValueArgumentIn(fn: IrFunctionAccessExpression, startIndex: Int)
+    fun putAsValueArgumentIn(fn: IrFunctionAccessExpression<*>, startIndex: Int)
 }
 
 @JvmDefaultWithCompatibility
@@ -4434,7 +4434,7 @@
                 expressions.reduce { lhs, rhs -> irOrOr(lhs, rhs) }
         }
 
-        override fun putAsValueArgumentIn(fn: IrFunctionAccessExpression, startIndex: Int) {
+        override fun putAsValueArgumentIn(fn: IrFunctionAccessExpression<*>, startIndex: Int) {
             params.fastForEachIndexed { i, param ->
                 fn.putValueArgument(
                     startIndex + i,
@@ -4607,7 +4607,7 @@
         }
 
         override fun putAsValueArgumentInWithLowBit(
-            fn: IrFunctionAccessExpression,
+            fn: IrFunctionAccessExpression<*>,
             startIndex: Int,
             lowBit: Boolean
         ) {

diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrInlineReferenceLocator.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrInlineReferenceLocator.kt
index afd8341..e2eb7a6 100644
--- a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrInlineReferenceLocator.kt
+++ b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrInlineReferenceLocator.kt

@@ -83,7 +83,7 @@
                 }
             }
 
-            override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
+            override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>) {
                 expression.acceptChildrenVoid(this)
                 val function = expression.symbol.owner
                 if (function.isInlineFunctionCall(context)) {

diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrSourcePrinter.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrSourcePrinter.kt
index caa074f..cfbab62 100644
--- a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrSourcePrinter.kt
+++ b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/IrSourcePrinter.kt

@@ -518,7 +518,7 @@
         }
     }
 
-    private fun IrFunctionAccessExpression.printArgumentList(
+    private fun IrFunctionAccessExpression<*>.printArgumentList(
         forceParameterNames: Boolean = false,
         forceSingleLine: Boolean = false
     ) {
@@ -836,7 +836,7 @@
     // Map local return targets to the corresponding function call.
     // This is used to print qualified returns.
     private val returnTargetToCall =
-        mutableMapOf<IrReturnTargetSymbol, IrFunctionAccessExpression>()
+        mutableMapOf<IrReturnTargetSymbol, IrFunctionAccessExpression<*>>()
 
     private val IrFunction.isLambda: Boolean
         get() = name.asString() == SpecialNames.ANONYMOUS_STRING ||
@@ -1273,7 +1273,7 @@
         print("::class")
     }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression<*>) {
         super.visitFunctionAccess(expression)
     }
 

diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializationJvmIrIntrinsicSupport.kt b/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializationJvmIrIntrinsicSupport.kt
index e1086cc..f827b09 100644
--- a/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializationJvmIrIntrinsicSupport.kt
+++ b/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializationJvmIrIntrinsicSupport.kt

@@ -78,7 +78,7 @@
 
     inner class ReifiedSerializerMethod(private val withModule: Boolean) : IntrinsicMethod() {
         override fun invoke(
-            expression: IrFunctionAccessExpression,
+            expression: IrFunctionAccessExpression<*>,
             codegen: ExpressionCodegen,
             data: BlockInfo
         ): PromisedValue {