IrTypes: deep copy with symbols

Preliminary implementation of type remapper (does nothing).

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

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.expressions.IrLoop
-import org.jetbrains.kotlin.ir.util.DeepCopySymbolsRemapper
+import org.jetbrains.kotlin.ir.util.DeepCopySymbolRemapper
 import org.jetbrains.kotlin.ir.util.DescriptorsRemapper
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 
@@ -38,7 +38,7 @@ fun <T : IrElement> T.deepCopyWithVariables(): T {
         )
     }
 
-    val symbolsRemapper = DeepCopySymbolsRemapper(descriptorsRemapper)
+    val symbolsRemapper = DeepCopySymbolRemapper(descriptorsRemapper)
     acceptVoid(symbolsRemapper)
 
     return this.transform(

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

@@ -27,18 +27,24 @@ import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
 import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl
+import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import java.util.*
 
 inline fun <reified T : IrElement> T.deepCopyWithSymbols(initialParent: IrDeclarationParent? = null): T {
-    val remapper = DeepCopySymbolsRemapper()
+    val symbolRemapper = DeepCopySymbolRemapper()
-    acceptVoid(remapper)
+    acceptVoid(symbolRemapper)
-    return transform(DeepCopyIrTreeWithSymbols(remapper), null).patchDeclarationParents(initialParent) as T
+    val typeRemapper = DeepCopyTypeRemapper(symbolRemapper)
+    return transform(DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper), null).patchDeclarationParents(initialParent) as T
 }
 
 
-open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) : IrElementTransformerVoid() {
+open class DeepCopyIrTreeWithSymbols(
+    private val symbolRemapper: SymbolRemapper,
+    private val typeRemapper: TypeRemapper
+) : IrElementTransformerVoid() {
+
     private fun mapDeclarationOrigin(origin: IrDeclarationOrigin) = origin
     private fun mapStatementOrigin(origin: IrStatementOrigin?) = origin
 
@@ -54,6 +60,8 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     private fun <T : IrDeclarationContainer> T.transformDeclarationsTo(destination: T) =
         declarations.transformTo(destination.declarations)
 
+    private fun IrType.remapType() = typeRemapper.remapType(this)
+
     override fun visitElement(element: IrElement): IrElement =
         throw IllegalArgumentException("Unsupported element type: $element")
 
@@ -112,7 +120,8 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrFunctionImpl(
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredFunction(declaration.symbol)
+            symbolRemapper.getDeclaredFunction(declaration.symbol),
+            declaration.returnType.remapType()
         ).apply {
             declaration.overriddenSymbols.mapTo(overriddenSymbols) {
                 symbolRemapper.getReferencedFunction(it) as IrSimpleFunctionSymbol
@@ -124,7 +133,8 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrConstructorImpl(
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredConstructor(declaration.symbol)
+            symbolRemapper.getDeclaredConstructor(declaration.symbol),
+            declaration.returnType.remapType()
         ).apply {
             transformFunctionChildren(declaration)
         }
@@ -149,6 +159,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
             mapDeclarationOrigin(declaration.origin),
             declaration.isDelegated,
             declaration.descriptor,
+            declaration.type.remapType(),
             declaration.backingField?.transform(),
             declaration.getter?.transform(),
             declaration.setter?.transform()
@@ -160,7 +171,8 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrFieldImpl(
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredField(declaration.symbol)
+            symbolRemapper.getDeclaredField(declaration.symbol),
+            declaration.type.remapType()
         ).apply {
             transformAnnotations(declaration)
             initializer = declaration.initializer?.transform()
@@ -171,6 +183,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
             declaration.descriptor,
+            declaration.type.remapType(),
             declaration.delegate.transform(),
             declaration.getter.transform(),
             declaration.setter?.transform()
@@ -202,7 +215,8 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrVariableImpl(
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredVariable(declaration.symbol)
+            symbolRemapper.getDeclaredVariable(declaration.symbol),
+            declaration.type.remapType()
         ).apply {
             transformAnnotations(declaration)
             initializer = declaration.initializer?.transform()
@@ -212,7 +226,8 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrTypeParameterImpl(
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredTypeParameter(declaration.symbol)
+            symbolRemapper.getDeclaredTypeParameter(declaration.symbol),
+            declaration.upperBounds.map { it.remapType() }
         ).apply {
             transformAnnotations(declaration)
             declaration.superClassifiers.mapTo(superClassifiers) {
@@ -224,7 +239,9 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrValueParameterImpl(
             declaration.startOffset, declaration.endOffset,
             mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredValueParameter(declaration.symbol)
+            symbolRemapper.getDeclaredValueParameter(declaration.symbol),
+            declaration.type.remapType(),
+            declaration.varargElementType?.remapType()
         ).apply {
             transformAnnotations(declaration)
             defaultValue = declaration.defaultValue?.transform()
@@ -254,7 +271,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitVararg(expression: IrVararg): IrVararg =
         IrVarargImpl(
             expression.startOffset, expression.endOffset,
-            expression.type, expression.varargElementType,
+            expression.type.remapType(), expression.varargElementType.remapType(),
             expression.elements.transform()
         )
 
@@ -267,7 +284,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitBlock(expression: IrBlock): IrBlock =
         IrBlockImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             mapStatementOrigin(expression.origin),
             expression.statements.map { it.transform() }
         )
@@ -275,7 +292,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitComposite(expression: IrComposite): IrComposite =
         IrCompositeImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             mapStatementOrigin(expression.origin),
             expression.statements.map { it.transform() }
         )
@@ -283,27 +300,28 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitStringConcatenation(expression: IrStringConcatenation): IrStringConcatenation =
         IrStringConcatenationImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.arguments.map { it.transform() }
         )
 
     override fun visitGetObjectValue(expression: IrGetObjectValue): IrGetObjectValue =
         IrGetObjectValueImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             symbolRemapper.getReferencedClass(expression.symbol)
         )
 
     override fun visitGetEnumValue(expression: IrGetEnumValue): IrGetEnumValue =
         IrGetEnumValueImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             symbolRemapper.getReferencedEnumEntry(expression.symbol)
         )
 
     override fun visitGetValue(expression: IrGetValue): IrGetValue =
         IrGetValueImpl(
             expression.startOffset, expression.endOffset,
+            expression.type.remapType(),
             symbolRemapper.getReferencedValue(expression.symbol),
             mapStatementOrigin(expression.origin)
         )
@@ -311,6 +329,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitSetVariable(expression: IrSetVariable): IrSetVariable =
         IrSetVariableImpl(
             expression.startOffset, expression.endOffset,
+            expression.type.remapType(),
             symbolRemapper.getReferencedVariable(expression.symbol),
             expression.value.transform(),
             mapStatementOrigin(expression.origin)
@@ -320,6 +339,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         IrGetFieldImpl(
             expression.startOffset, expression.endOffset,
             symbolRemapper.getReferencedField(expression.symbol),
+            expression.type.remapType(),
             expression.receiver?.transform(),
             mapStatementOrigin(expression.origin),
             symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol)
@@ -331,16 +351,26 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
             symbolRemapper.getReferencedField(expression.symbol),
             expression.receiver?.transform(),
             expression.value.transform(),
+            expression.type.remapType(),
             mapStatementOrigin(expression.origin),
             symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol)
         )
 
     override fun visitCall(expression: IrCall): IrCall =
         shallowCopyCall(expression).apply {
-            copyTypeArgumentsFrom(expression)
+            copyRemappedTypeArgumentsFrom(expression)
             transformValueArguments(expression)
         }
 
+    private fun IrMemberAccessExpression.copyRemappedTypeArgumentsFrom(other: IrMemberAccessExpression) {
+        assert(typeArgumentsCount == other.typeArgumentsCount) {
+            "Mismatching type arguments: $typeArgumentsCount vs ${other.typeArgumentsCount} "
+        }
+        for (i in 0 until typeArgumentsCount) {
+            putTypeArgument(i, other.getTypeArgument(i)?.remapType())
+        }
+    }
+
     private fun shallowCopyCall(expression: IrCall) =
         when (expression) {
             is IrCallWithShallowCopy ->
@@ -353,14 +383,14 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
                 val newCallee = symbolRemapper.getReferencedFunction(expression.symbol)
                 IrCallImpl(
                     expression.startOffset, expression.endOffset,
-                    expression.type,
+                    expression.type.remapType(),
                     newCallee,
                     expression.descriptor, // TODO substitute referenced descriptor
                     expression.typeArgumentsCount,
                     mapStatementOrigin(expression.origin),
                     symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol)
                 ).apply {
-                    copyTypeArgumentsFrom(expression)
+                    copyRemappedTypeArgumentsFrom(expression)
                 }
             }
         }
@@ -382,11 +412,12 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         val newConstructor = symbolRemapper.getReferencedConstructor(expression.symbol)
         return IrDelegatingConstructorCallImpl(
             expression.startOffset, expression.endOffset,
+            expression.type.remapType(),
             newConstructor,
             expression.descriptor,
             expression.typeArgumentsCount
         ).apply {
-            copyTypeArgumentsFrom(expression)
+            copyRemappedTypeArgumentsFrom(expression)
             transformValueArguments(expression)
         }
     }
@@ -395,10 +426,11 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
         val newConstructor = symbolRemapper.getReferencedConstructor(expression.symbol)
         return IrEnumConstructorCallImpl(
             expression.startOffset, expression.endOffset,
+            expression.type.remapType(),
             newConstructor,
             expression.typeArgumentsCount
         ).apply {
-            copyTypeArgumentsFrom(expression)
+            copyRemappedTypeArgumentsFrom(expression)
             transformValueArguments(expression)
         }
     }
@@ -406,27 +438,27 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitGetClass(expression: IrGetClass): IrGetClass =
         IrGetClassImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.argument.transform()
         )
 
     override fun visitFunctionReference(expression: IrFunctionReference): IrFunctionReference =
         IrFunctionReferenceImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             symbolRemapper.getReferencedFunction(expression.symbol),
             expression.descriptor, // TODO substitute referenced descriptor
             expression.typeArgumentsCount,
             mapStatementOrigin(expression.origin)
         ).apply {
-            copyTypeArgumentsFrom(expression)
+            copyRemappedTypeArgumentsFrom(expression)
             transformValueArguments(expression)
         }
 
     override fun visitPropertyReference(expression: IrPropertyReference): IrPropertyReference =
         IrPropertyReferenceImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.descriptor,
             expression.typeArgumentsCount,
             expression.field?.let { symbolRemapper.getReferencedField(it) },
@@ -434,14 +466,14 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
             expression.setter?.let { symbolRemapper.getReferencedFunction(it) },
             mapStatementOrigin(expression.origin)
         ).apply {
-            copyTypeArgumentsFrom(expression)
+            copyRemappedTypeArgumentsFrom(expression)
             transformReceiverArguments(expression)
         }
 
     override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrLocalDelegatedPropertyReference =
         IrLocalDelegatedPropertyReferenceImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.descriptor,
             symbolRemapper.getReferencedVariable(expression.delegate),
             symbolRemapper.getReferencedFunction(expression.getter),
@@ -452,7 +484,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitClassReference(expression: IrClassReference): IrClassReference =
         IrClassReferenceImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             symbolRemapper.getReferencedClassifier(expression.symbol),
             expression.classType
         )
@@ -460,13 +492,14 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall): IrInstanceInitializerCall =
         IrInstanceInitializerCallImpl(
             expression.startOffset, expression.endOffset,
-            symbolRemapper.getReferencedClass(expression.classSymbol)
+            symbolRemapper.getReferencedClass(expression.classSymbol),
+            expression.type.remapType()
         )
 
     override fun visitTypeOperator(expression: IrTypeOperatorCall): IrTypeOperatorCall =
         IrTypeOperatorCallImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.operator,
             expression.typeOperand,
             symbolRemapper.getReferencedClassifier(expression.typeOperandClassifier),
@@ -476,7 +509,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitWhen(expression: IrWhen): IrWhen =
         IrWhenImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             mapStatementOrigin(expression.origin),
             expression.branches.map { it.transform() }
         )
@@ -552,7 +585,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitReturn(expression: IrReturn): IrReturn =
         IrReturnImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             symbolRemapper.getReferencedReturnTarget(expression.returnTargetSymbol),
             expression.value.transform()
         )
@@ -567,7 +600,7 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitThrow(expression: IrThrow): IrThrow =
         IrThrowImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.value.transform()
         )
 
@@ -577,14 +610,14 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper)
     override fun visitErrorExpression(expression: IrErrorExpression): IrErrorExpression =
         IrErrorExpressionImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.description
         )
 
     override fun visitErrorCallExpression(expression: IrErrorCallExpression): IrErrorCallExpression =
         IrErrorCallExpressionImpl(
             expression.startOffset, expression.endOffset,
-            expression.type,
+            expression.type.remapType(),
             expression.description
         ).apply {
             explicitReceiver = expression.explicitReceiver?.transform()

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

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.ir.symbols.impl.*
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 
-open class DeepCopySymbolsRemapper(
+open class DeepCopySymbolRemapper(
     private val descriptorsRemapper: DescriptorsRemapper = DescriptorsRemapper.DEFAULT
 ) : IrElementVisitorVoid, SymbolRemapper {
     private val classes = hashMapOf<IrClassSymbol, IrClassSymbol>()

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

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2018 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.util
+
+import org.jetbrains.kotlin.ir.types.IrType
+
+class DeepCopyTypeRemapper(
+    private val symbolRemapper: SymbolRemapper
+) : TypeRemapper {
+
+    override fun remapType(type: IrType): IrType = type // TODO
+
+}

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2010-2018 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.util
+
+import org.jetbrains.kotlin.ir.types.IrType
+
+interface TypeRemapper {
+    fun remapType(type: IrType): IrType
+}