Introduce IrDynamicExpression and children

Dynamic expressions are represented as either operator expressions -
e.g., `d1 + d2`, `d[e]`, `d(e1, e2, e3)`, `d += e` -
where "operator" is a one of the known operators,
or as member reference expressions - e.g., `d.memberName` - where
member name is some arbitrary name (unresolved at compile-time and
represented as String).

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.expressions
+
+interface IrDynamicExpression : IrExpression
+
+interface IrDynamicOperatorExpression : IrDynamicExpression {
+    val operator: IrDynamicOperator
+
+    val valueArgumentsCount: Int
+    fun getValueArgument(index: Int): IrExpression?
+    fun putValueArgument(index: Int, valueArgument: IrExpression?)
+    fun removeValueArgument(index: Int)
+}
+
+interface IrDynamicMemberExpression : IrDynamicExpression {
+    val memberName: String
+    var receiver: IrExpression
+}
+
+enum class IrDynamicOperator(val image: String, val isAssignmentOperator: Boolean = false) {
+    UNARY_PLUS("+"),
+    UNARY_MINUS("-"),
+    EXCL("!"),
+    PREFIX_INCREMENT("++", isAssignmentOperator = true),
+    POSTFIX_INCREMENT("++", isAssignmentOperator = true),
+    PREFIX_DECREMENT("--", isAssignmentOperator = true),
+    POSTFIX_DECREMENT("--", isAssignmentOperator = true),
+
+    BINARY_PLUS("+"),
+    BINARY_MINUS("-"),
+    MUL("*"),
+    DIV("/"),
+    MOD("%"),
+    GT(">"),
+    LT("<"),
+    GE(">="),
+    LE("<="),
+    EQEQ("=="),
+    EXCLEQ("!="),
+    EQEQEQ("==="),
+    EXCLEQEQ("!=="),
+    ANDAND("&&"),
+    OROR("||"),
+
+    EQ("=", isAssignmentOperator = true),
+    PLUSEQ("+=", isAssignmentOperator = true),
+    MINUSEQ("-=", isAssignmentOperator = true),
+    MULEQ("*=", isAssignmentOperator = true),
+    DIVEQ("/=", isAssignmentOperator = true),
+    MODEQ("%=", isAssignmentOperator = true),
+
+    ARRAY_ACCESS("[]"),
+    INVOKE("()")
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.expressions.impl
+
+import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
+
+class IrDynamicMemberExpressionImpl(
+    startOffset: Int,
+    endOffset: Int,
+    type: IrType,
+    override val memberName: String,
+    override var receiver: IrExpression
+) :
+    IrExpressionBase(startOffset, endOffset, type),
+    IrDynamicMemberExpression {
+
+    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
+        visitor.visitDynamicMemberExpression(this, data)
+
+    override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
+        receiver.accept(visitor, data)
+    }
+
+    override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
+        receiver = receiver.transform(transformer, data)
+    }
+}

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.expressions.impl
+
+import org.jetbrains.kotlin.ir.expressions.IrDynamicOperator
+import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
+
+class IrDynamicOperatorExpressionImpl(
+    startOffset: Int,
+    endOffset: Int,
+    type: IrType,
+    override val operator: IrDynamicOperator,
+    override val valueArgumentsCount: Int
+) :
+    IrExpressionBase(startOffset, endOffset, type),
+    IrDynamicOperatorExpression {
+
+    private val valueArguments = arrayOfNulls<IrExpression>(valueArgumentsCount)
+
+    override fun getValueArgument(index: Int): IrExpression? {
+        if (index >= valueArgumentsCount) {
+            throw AssertionError("$this: No such value argument slot: $index")
+        }
+        return valueArguments[index]
+    }
+
+    override fun putValueArgument(index: Int, valueArgument: IrExpression?) {
+        if (index >= valueArgumentsCount) {
+            throw AssertionError("$this: No such value argument slot: $index")
+        }
+        valueArguments[index] = valueArgument
+    }
+
+    override fun removeValueArgument(index: Int) {
+        putValueArgument(index, null)
+    }
+
+
+    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
+        visitor.visitDynamicOperatorExpression(this, data)
+
+    override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
+        for (valueArgument in valueArguments) {
+            valueArgument?.accept(visitor, data)
+        }
+    }
+
+    override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
+        for (i in 0 until valueArgumentsCount) {
+            valueArguments[i] = valueArguments[i]?.transform(transformer, data)
+        }
+    }
+}

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

@@ -28,10 +28,12 @@ import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.*
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 
+@Suppress("DEPRECATION")
 inline fun <reified T : IrElement> T.deepCopyOld(): T =
     transform(DeepCopyIrTree(), null).patchDeclarationParents() as T
 
 @Deprecated("Creates unbound symbols")
+@Suppress("DEPRECATION")
 open class DeepCopyIrTree : IrElementTransformerVoid() {
 
     protected open fun mapDeclarationOrigin(declarationOrigin: IrDeclarationOrigin) = declarationOrigin
@@ -646,6 +648,26 @@ open class DeepCopyIrTree : IrElementTransformerVoid() {
             expression.value.transform()
         )
 
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression): IrDynamicOperatorExpression =
+        IrDynamicOperatorExpressionImpl(
+            expression.startOffset, expression.endOffset,
+            expression.type,
+            expression.operator,
+            expression.valueArgumentsCount
+        ).apply {
+            for (i in 0 until expression.valueArgumentsCount) {
+                putValueArgument(i, expression.getValueArgument(i)?.transform())
+            }
+        }
+
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression): IrDynamicMemberExpression =
+        IrDynamicMemberExpressionImpl(
+            expression.startOffset, expression.endOffset,
+            expression.type,
+            expression.memberName,
+            expression.receiver.transform()
+        )
+
     override fun visitErrorDeclaration(declaration: IrErrorDeclaration): IrErrorDeclaration =
         IrErrorDeclarationImpl(
             declaration.startOffset, declaration.endOffset,

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

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.ir.util
 
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
@@ -714,6 +712,26 @@ open class DeepCopyIrTreeWithSymbols(
             expression.value.transform()
         )
 
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression): IrDynamicOperatorExpression =
+        IrDynamicOperatorExpressionImpl(
+            expression.startOffset, expression.endOffset,
+            expression.type.remapType(),
+            expression.operator,
+            expression.valueArgumentsCount
+        ).apply {
+            for (i in 0 until expression.valueArgumentsCount) {
+                putValueArgument(i, expression.getValueArgument(i)?.transform())
+            }
+        }
+
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression): IrDynamicMemberExpression =
+        IrDynamicMemberExpressionImpl(
+            expression.startOffset, expression.endOffset,
+            expression.type.remapType(),
+            expression.memberName,
+            expression.receiver.transform()
+        )
+
     override fun visitErrorDeclaration(declaration: IrErrorDeclaration): IrErrorDeclaration =
         IrErrorDeclarationImpl(declaration.startOffset, declaration.endOffset, declaration.descriptor)
 

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

@@ -346,6 +346,12 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
     override fun visitCatch(aCatch: IrCatch, data: Nothing?): String =
         "CATCH parameter=${aCatch.parameter.ref()}"
 
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: Nothing?): String =
+        "DYN_OP operator=${expression.operator} type=${expression.type.render()}"
+
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: Nothing?): String =
+        "DYN_MEMBER memberName='${expression.memberName}' type=${expression.type.render()}"
+
     override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?): String =
         "ERROR_DECL ${declaration.descriptor::class.java.simpleName} ${declaration.descriptor.ref()}"
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt

@@ -133,6 +133,10 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
     override fun visitReturn(expression: IrReturn, data: D) = visitExpression(expression, data)
     override fun visitThrow(expression: IrThrow, data: D) = visitExpression(expression, data)
 
+    override fun visitDynamicExpression(expression: IrDynamicExpression, data: D) = visitExpression(expression, data)
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D) = visitDynamicExpression(expression, data)
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D) = visitDynamicExpression(expression, data)
+
     override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D) = visitDeclaration(declaration, data)
     override fun visitErrorExpression(expression: IrErrorExpression, data: D) = visitExpression(expression, data)
     override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D) = visitErrorExpression(expression, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt

@@ -20,22 +20,23 @@ import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
+import kotlin.math.exp
 
 abstract class IrElementTransformerVoid : IrElementTransformer<Nothing?> {
     protected fun <T : IrElement> T.transformChildren() = apply { transformChildrenVoid() }
 
     open fun visitElement(element: IrElement): IrElement = element.transformChildren()
-    override final fun visitElement(element: IrElement, data: Nothing?): IrElement = visitElement(element)
+    final override fun visitElement(element: IrElement, data: Nothing?): IrElement = visitElement(element)
 
     open fun visitModuleFragment(declaration: IrModuleFragment): IrModuleFragment = declaration.transformChildren()
-    override final fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?): IrModuleFragment =
+    final override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?): IrModuleFragment =
         visitModuleFragment(declaration)
 
     open fun visitPackageFragment(declaration: IrPackageFragment): IrPackageFragment = declaration.transformChildren()
     override fun visitPackageFragment(declaration: IrPackageFragment, data: Nothing?): IrElement = visitPackageFragment(declaration)
 
     open fun visitFile(declaration: IrFile): IrFile = visitPackageFragment(declaration) as IrFile
-    override final fun visitFile(declaration: IrFile, data: Nothing?): IrFile = visitFile(declaration)
+    final override fun visitFile(declaration: IrFile, data: Nothing?): IrFile = visitFile(declaration)
 
     open fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) =
         visitPackageFragment(declaration) as IrExternalPackageFragment
@@ -44,213 +45,224 @@ abstract class IrElementTransformerVoid : IrElementTransformer<Nothing?> {
         visitExternalPackageFragment(declaration)
 
     open fun visitDeclaration(declaration: IrDeclaration): IrStatement = declaration.transformChildren()
-    override final fun visitDeclaration(declaration: IrDeclaration, data: Nothing?): IrStatement = visitDeclaration(declaration)
+    final override fun visitDeclaration(declaration: IrDeclaration, data: Nothing?): IrStatement = visitDeclaration(declaration)
 
     open fun visitClass(declaration: IrClass) = visitDeclaration(declaration)
-    override final fun visitClass(declaration: IrClass, data: Nothing?) = visitClass(declaration)
+    final override fun visitClass(declaration: IrClass, data: Nothing?) = visitClass(declaration)
 
     open fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration)
-    override final fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration)
+    final override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration)
 
     open fun visitFunction(declaration: IrFunction) = visitDeclaration(declaration)
-    override final fun visitFunction(declaration: IrFunction, data: Nothing?) = visitFunction(declaration)
+    final override fun visitFunction(declaration: IrFunction, data: Nothing?) = visitFunction(declaration)
 
     open fun visitSimpleFunction(declaration: IrSimpleFunction) = visitFunction(declaration)
-    override final fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?) = visitSimpleFunction(declaration)
+    final override fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?) = visitSimpleFunction(declaration)
 
     open fun visitConstructor(declaration: IrConstructor) = visitFunction(declaration)
-    override final fun visitConstructor(declaration: IrConstructor, data: Nothing?) = visitConstructor(declaration)
+    final override fun visitConstructor(declaration: IrConstructor, data: Nothing?) = visitConstructor(declaration)
 
     open fun visitProperty(declaration: IrProperty) = visitDeclaration(declaration)
-    override final fun visitProperty(declaration: IrProperty, data: Nothing?) = visitProperty(declaration)
+    final override fun visitProperty(declaration: IrProperty, data: Nothing?) = visitProperty(declaration)
 
     open fun visitField(declaration: IrField) = visitDeclaration(declaration)
-    override final fun visitField(declaration: IrField, data: Nothing?) = visitField(declaration)
+    final override fun visitField(declaration: IrField, data: Nothing?) = visitField(declaration)
 
     open fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) = visitDeclaration(declaration)
-    override final fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?) =
+    final override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?) =
         visitLocalDelegatedProperty(declaration)
 
     open fun visitEnumEntry(declaration: IrEnumEntry) = visitDeclaration(declaration)
-    override final fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) = visitEnumEntry(declaration)
+    final override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) = visitEnumEntry(declaration)
 
     open fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) = visitDeclaration(declaration)
-    override final fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Nothing?) =
+    final override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Nothing?) =
         visitAnonymousInitializer(declaration)
 
     open fun visitTypeParameter(declaration: IrTypeParameter) = visitDeclaration(declaration)
-    override final fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?): IrStatement = visitTypeParameter(declaration)
+    final override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?): IrStatement = visitTypeParameter(declaration)
 
     open fun visitValueParameter(declaration: IrValueParameter) = visitDeclaration(declaration)
-    override final fun visitValueParameter(declaration: IrValueParameter, data: Nothing?): IrStatement = visitValueParameter(declaration)
+    final override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?): IrStatement = visitValueParameter(declaration)
 
     open fun visitVariable(declaration: IrVariable) = visitDeclaration(declaration)
-    override final fun visitVariable(declaration: IrVariable, data: Nothing?) = visitVariable(declaration)
+    final override fun visitVariable(declaration: IrVariable, data: Nothing?) = visitVariable(declaration)
 
     open fun visitBody(body: IrBody): IrBody = body.transformChildren()
-    override final fun visitBody(body: IrBody, data: Nothing?): IrBody = visitBody(body)
+    final override fun visitBody(body: IrBody, data: Nothing?): IrBody = visitBody(body)
 
     open fun visitExpressionBody(body: IrExpressionBody) = visitBody(body)
-    override final fun visitExpressionBody(body: IrExpressionBody, data: Nothing?) = visitExpressionBody(body)
+    final override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?) = visitExpressionBody(body)
 
     open fun visitBlockBody(body: IrBlockBody) = visitBody(body)
-    override final fun visitBlockBody(body: IrBlockBody, data: Nothing?) = visitBlockBody(body)
+    final override fun visitBlockBody(body: IrBlockBody, data: Nothing?) = visitBlockBody(body)
 
     open fun visitSyntheticBody(body: IrSyntheticBody) = visitBody(body)
-    override final fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?) = visitSyntheticBody(body)
+    final override fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?) = visitSyntheticBody(body)
 
     open fun visitSuspendableExpression(expression: IrSuspendableExpression) = visitExpression(expression)
-    override final fun visitSuspendableExpression(expression: IrSuspendableExpression, data: Nothing?) =
+    final override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: Nothing?) =
         visitSuspendableExpression(expression)
 
     open fun visitSuspensionPoint(expression: IrSuspensionPoint) = visitExpression(expression)
-    override final fun visitSuspensionPoint(expression: IrSuspensionPoint, data: Nothing?) = visitSuspensionPoint(expression)
+    final override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: Nothing?) = visitSuspensionPoint(expression)
 
     open fun visitExpression(expression: IrExpression): IrExpression = expression.transformChildren()
-    override final fun visitExpression(expression: IrExpression, data: Nothing?): IrExpression = visitExpression(expression)
+    final override fun visitExpression(expression: IrExpression, data: Nothing?): IrExpression = visitExpression(expression)
 
     open fun <T> visitConst(expression: IrConst<T>) = visitExpression(expression)
-    override final fun <T> visitConst(expression: IrConst<T>, data: Nothing?) = visitConst(expression)
+    final override fun <T> visitConst(expression: IrConst<T>, data: Nothing?) = visitConst(expression)
 
     open fun visitVararg(expression: IrVararg) = visitExpression(expression)
-    override final fun visitVararg(expression: IrVararg, data: Nothing?) = visitVararg(expression)
+    final override fun visitVararg(expression: IrVararg, data: Nothing?) = visitVararg(expression)
 
     open fun visitSpreadElement(spread: IrSpreadElement) = spread.transformChildren()
-    override final fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?): IrSpreadElement = visitSpreadElement(spread)
+    final override fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?): IrSpreadElement = visitSpreadElement(spread)
 
     open fun visitContainerExpression(expression: IrContainerExpression) = visitExpression(expression)
-    override final fun visitContainerExpression(expression: IrContainerExpression, data: Nothing?) = visitContainerExpression(expression)
+    final override fun visitContainerExpression(expression: IrContainerExpression, data: Nothing?) = visitContainerExpression(expression)
 
     open fun visitBlock(expression: IrBlock) = visitContainerExpression(expression)
-    override final fun visitBlock(expression: IrBlock, data: Nothing?) = visitBlock(expression)
+    final override fun visitBlock(expression: IrBlock, data: Nothing?) = visitBlock(expression)
 
     open fun visitComposite(expression: IrComposite) = visitContainerExpression(expression)
-    override final fun visitComposite(expression: IrComposite, data: Nothing?) = visitComposite(expression)
+    final override fun visitComposite(expression: IrComposite, data: Nothing?) = visitComposite(expression)
 
     open fun visitStringConcatenation(expression: IrStringConcatenation) = visitExpression(expression)
-    override final fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?) = visitStringConcatenation(expression)
+    final override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?) = visitStringConcatenation(expression)
 
     open fun visitDeclarationReference(expression: IrDeclarationReference) = visitExpression(expression)
-    override final fun visitDeclarationReference(expression: IrDeclarationReference, data: Nothing?) = visitDeclarationReference(expression)
+    final override fun visitDeclarationReference(expression: IrDeclarationReference, data: Nothing?) = visitDeclarationReference(expression)
 
     open fun visitSingletonReference(expression: IrGetSingletonValue) = visitDeclarationReference(expression)
-    override final fun visitSingletonReference(expression: IrGetSingletonValue, data: Nothing?) = visitSingletonReference(expression)
+    final override fun visitSingletonReference(expression: IrGetSingletonValue, data: Nothing?) = visitSingletonReference(expression)
 
     open fun visitGetObjectValue(expression: IrGetObjectValue) = visitSingletonReference(expression)
-    override final fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?) = visitGetObjectValue(expression)
+    final override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?) = visitGetObjectValue(expression)
 
     open fun visitGetEnumValue(expression: IrGetEnumValue) = visitSingletonReference(expression)
-    override final fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?) = visitGetEnumValue(expression)
+    final override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?) = visitGetEnumValue(expression)
 
     open fun visitValueAccess(expression: IrValueAccessExpression) = visitDeclarationReference(expression)
-    override final fun visitValueAccess(expression: IrValueAccessExpression, data: Nothing?) = visitValueAccess(expression)
+    final override fun visitValueAccess(expression: IrValueAccessExpression, data: Nothing?) = visitValueAccess(expression)
 
     open fun visitGetValue(expression: IrGetValue) = visitValueAccess(expression)
-    override final fun visitGetValue(expression: IrGetValue, data: Nothing?) = visitGetValue(expression)
+    final override fun visitGetValue(expression: IrGetValue, data: Nothing?) = visitGetValue(expression)
 
     open fun visitSetVariable(expression: IrSetVariable) = visitValueAccess(expression)
-    override final fun visitSetVariable(expression: IrSetVariable, data: Nothing?) = visitSetVariable(expression)
+    final override fun visitSetVariable(expression: IrSetVariable, data: Nothing?) = visitSetVariable(expression)
 
     open fun visitFieldAccess(expression: IrFieldAccessExpression) = visitDeclarationReference(expression)
-    override final fun visitFieldAccess(expression: IrFieldAccessExpression, data: Nothing?) = visitFieldAccess(expression)
+    final override fun visitFieldAccess(expression: IrFieldAccessExpression, data: Nothing?) = visitFieldAccess(expression)
 
     open fun visitGetField(expression: IrGetField) = visitFieldAccess(expression)
-    override final fun visitGetField(expression: IrGetField, data: Nothing?) = visitGetField(expression)
+    final override fun visitGetField(expression: IrGetField, data: Nothing?) = visitGetField(expression)
 
     open fun visitSetField(expression: IrSetField) = visitFieldAccess(expression)
-    override final fun visitSetField(expression: IrSetField, data: Nothing?) = visitSetField(expression)
+    final override fun visitSetField(expression: IrSetField, data: Nothing?) = visitSetField(expression)
 
     open fun visitMemberAccess(expression: IrMemberAccessExpression) = visitExpression(expression)
-    override final fun visitMemberAccess(expression: IrMemberAccessExpression, data: Nothing?) = visitMemberAccess(expression)
+    final override fun visitMemberAccess(expression: IrMemberAccessExpression, data: Nothing?) = visitMemberAccess(expression)
 
     open fun visitFunctionAccess(expression: IrFunctionAccessExpression) = visitMemberAccess(expression)
     override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: Nothing?) = visitFunctionAccess(expression)
 
     open fun visitCall(expression: IrCall) = visitFunctionAccess(expression)
-    override final fun visitCall(expression: IrCall, data: Nothing?) = visitCall(expression)
+    final override fun visitCall(expression: IrCall, data: Nothing?) = visitCall(expression)
 
     open fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) = visitFunctionAccess(expression)
-    override final fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?) =
+    final override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?) =
         visitDelegatingConstructorCall(expression)
 
     open fun visitEnumConstructorCall(expression: IrEnumConstructorCall) = visitMemberAccess(expression)
-    override final fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?) = visitEnumConstructorCall(expression)
+    final override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?) = visitEnumConstructorCall(expression)
 
     open fun visitGetClass(expression: IrGetClass) = visitExpression(expression)
-    override final fun visitGetClass(expression: IrGetClass, data: Nothing?) = visitGetClass(expression)
+    final override fun visitGetClass(expression: IrGetClass, data: Nothing?) = visitGetClass(expression)
 
     open fun visitCallableReference(expression: IrCallableReference) = visitMemberAccess(expression)
-    override final fun visitCallableReference(expression: IrCallableReference, data: Nothing?) = visitCallableReference(expression)
+    final override fun visitCallableReference(expression: IrCallableReference, data: Nothing?) = visitCallableReference(expression)
 
     open fun visitFunctionReference(expression: IrFunctionReference) = visitCallableReference(expression)
-    override final fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?): IrElement =
+    final override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?): IrElement =
         visitFunctionReference(expression)
 
     open fun visitPropertyReference(expression: IrPropertyReference) = visitCallableReference(expression)
-    override final fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?): IrElement =
+    final override fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?): IrElement =
         visitPropertyReference(expression)
 
     open fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference) = visitCallableReference(expression)
-    override final fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: Nothing?) =
+    final override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: Nothing?) =
         visitLocalDelegatedPropertyReference(expression)
 
     open fun visitClassReference(expression: IrClassReference) = visitDeclarationReference(expression)
-    override final fun visitClassReference(expression: IrClassReference, data: Nothing?) = visitClassReference(expression)
+    final override fun visitClassReference(expression: IrClassReference, data: Nothing?) = visitClassReference(expression)
 
     open fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall) = visitExpression(expression)
-    override final fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?) =
+    final override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?) =
         visitInstanceInitializerCall(expression)
 
     open fun visitTypeOperator(expression: IrTypeOperatorCall) = visitExpression(expression)
-    override final fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?) = visitTypeOperator(expression)
+    final override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?) = visitTypeOperator(expression)
 
     open fun visitWhen(expression: IrWhen) = visitExpression(expression)
-    override final fun visitWhen(expression: IrWhen, data: Nothing?) = visitWhen(expression)
+    final override fun visitWhen(expression: IrWhen, data: Nothing?) = visitWhen(expression)
 
     open fun visitBranch(branch: IrBranch) = branch.transformChildren()
-    override final fun visitBranch(branch: IrBranch, data: Nothing?): IrBranch = visitBranch(branch)
+    final override fun visitBranch(branch: IrBranch, data: Nothing?): IrBranch = visitBranch(branch)
 
     open fun visitElseBranch(branch: IrElseBranch) = branch.transformChildren()
-    override final fun visitElseBranch(branch: IrElseBranch, data: Nothing?): IrElseBranch = visitElseBranch(branch)
+    final override fun visitElseBranch(branch: IrElseBranch, data: Nothing?): IrElseBranch = visitElseBranch(branch)
 
     open fun visitLoop(loop: IrLoop) = visitExpression(loop)
-    override final fun visitLoop(loop: IrLoop, data: Nothing?) = visitLoop(loop)
+    final override fun visitLoop(loop: IrLoop, data: Nothing?) = visitLoop(loop)
 
     open fun visitWhileLoop(loop: IrWhileLoop) = visitLoop(loop)
-    override final fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?) = visitWhileLoop(loop)
+    final override fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?) = visitWhileLoop(loop)
 
     open fun visitDoWhileLoop(loop: IrDoWhileLoop) = visitLoop(loop)
-    override final fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?) = visitDoWhileLoop(loop)
+    final override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?) = visitDoWhileLoop(loop)
 
     open fun visitTry(aTry: IrTry) = visitExpression(aTry)
-    override final fun visitTry(aTry: IrTry, data: Nothing?) = visitTry(aTry)
+    final override fun visitTry(aTry: IrTry, data: Nothing?) = visitTry(aTry)
 
     open fun visitCatch(aCatch: IrCatch): IrCatch = aCatch.apply { transformChildrenVoid() }
-    override final fun visitCatch(aCatch: IrCatch, data: Nothing?): IrCatch = visitCatch(aCatch)
+    final override fun visitCatch(aCatch: IrCatch, data: Nothing?): IrCatch = visitCatch(aCatch)
 
     open fun visitBreakContinue(jump: IrBreakContinue) = visitExpression(jump)
-    override final fun visitBreakContinue(jump: IrBreakContinue, data: Nothing?) = visitBreakContinue(jump)
+    final override fun visitBreakContinue(jump: IrBreakContinue, data: Nothing?) = visitBreakContinue(jump)
 
     open fun visitBreak(jump: IrBreak) = visitBreakContinue(jump)
-    override final fun visitBreak(jump: IrBreak, data: Nothing?) = visitBreak(jump)
+    final override fun visitBreak(jump: IrBreak, data: Nothing?) = visitBreak(jump)
 
     open fun visitContinue(jump: IrContinue) = visitBreakContinue(jump)
-    override final fun visitContinue(jump: IrContinue, data: Nothing?) = visitContinue(jump)
+    final override fun visitContinue(jump: IrContinue, data: Nothing?) = visitContinue(jump)
 
     open fun visitReturn(expression: IrReturn) = visitExpression(expression)
-    override final fun visitReturn(expression: IrReturn, data: Nothing?) = visitReturn(expression)
+    final override fun visitReturn(expression: IrReturn, data: Nothing?) = visitReturn(expression)
 
     open fun visitThrow(expression: IrThrow) = visitExpression(expression)
-    override final fun visitThrow(expression: IrThrow, data: Nothing?) = visitThrow(expression)
+    final override fun visitThrow(expression: IrThrow, data: Nothing?) = visitThrow(expression)
+
+    open fun visitDynamicExpression(expression: IrDynamicExpression) = visitExpression(expression)
+    final override fun visitDynamicExpression(expression: IrDynamicExpression, data: Nothing?) = visitDynamicExpression(expression)
+
+    open fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression) = visitDynamicExpression(expression)
+    final override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: Nothing?) =
+        visitDynamicOperatorExpression(expression)
+
+    open fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression) = visitDynamicExpression(expression)
+    final override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: Nothing?) =
+        visitDynamicMemberExpression(expression)
 
     open fun visitErrorDeclaration(declaration: IrErrorDeclaration) = visitDeclaration(declaration)
-    override final fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) = visitErrorDeclaration(declaration)
+    final override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) = visitErrorDeclaration(declaration)
 
     open fun visitErrorExpression(expression: IrErrorExpression) = visitExpression(expression)
-    override final fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?) = visitErrorExpression(expression)
+    final override fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?) = visitErrorExpression(expression)
 
     open fun visitErrorCallExpression(expression: IrErrorCallExpression) = visitErrorExpression(expression)
-    override final fun visitErrorCallExpression(expression: IrErrorCallExpression, data: Nothing?) = visitErrorCallExpression(expression)
+    final override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: Nothing?) = visitErrorCallExpression(expression)
 
     protected inline fun <T : IrElement> T.transformPostfix(body: T.() -> Unit): T {
         transformChildrenVoid()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt

@@ -106,6 +106,10 @@ interface IrElementVisitor<out R, in D> {
     fun visitReturn(expression: IrReturn, data: D) = visitExpression(expression, data)
     fun visitThrow(expression: IrThrow, data: D) = visitExpression(expression, data)
 
+    fun visitDynamicExpression(expression: IrDynamicExpression, data: D) = visitExpression(expression, data)
+    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D) = visitDynamicExpression(expression, data)
+    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D) = visitDynamicExpression(expression, data)
+
     fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D) = visitDeclaration(declaration, data)
     fun visitErrorExpression(expression: IrErrorExpression, data: D) = visitExpression(expression, data)
     fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D) = visitErrorExpression(expression, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt

@@ -233,6 +233,17 @@ interface IrElementVisitorVoid : IrElementVisitor<Unit, Nothing?> {
     fun visitThrow(expression: IrThrow) = visitExpression(expression)
     override fun visitThrow(expression: IrThrow, data: Nothing?) = visitThrow(expression)
 
+    fun visitDynamicExpression(expression: IrDynamicExpression) = visitExpression(expression)
+    override fun visitDynamicExpression(expression: IrDynamicExpression, data: Nothing?) = visitDynamicExpression(expression)
+
+    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression) = visitDynamicExpression(expression)
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: Nothing?) =
+        visitDynamicOperatorExpression(expression)
+
+    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression) = visitDynamicExpression(expression)
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: Nothing?) =
+        visitDynamicMemberExpression(expression)
+
     fun visitErrorDeclaration(declaration: IrErrorDeclaration) = visitDeclaration(declaration)
     override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) = visitErrorDeclaration(declaration)