RegenerationInfo renamed to TransformationInfo

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java

@@ -34,7 +34,7 @@ import java.util.*;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil.isThis0;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
 
-public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjectRegenerationInfo> {
+public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjectTransformationInfo> {
 
     protected final GenerationState state;
 
@@ -59,23 +59,23 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
     private final Map<String, List<String>> fieldNames = new HashMap<String, List<String>>();
 
     public AnonymousObjectTransformer(
-            @NotNull AnonymousObjectRegenerationInfo regenerationInfo,
+            @NotNull AnonymousObjectTransformationInfo transformationInfo,
             @NotNull InliningContext inliningContext,
             boolean isSameModule,
             @NotNull Type newLambdaType
     ) {
-        super(regenerationInfo, inliningContext.state);
+        super(transformationInfo, inliningContext.state);
         this.isSameModule = isSameModule;
         this.state = inliningContext.state;
         this.typeMapper = state.getTypeMapper();
         this.inliningContext = inliningContext;
-        this.oldObjectType = Type.getObjectType(regenerationInfo.getOldClassName());
+        this.oldObjectType = Type.getObjectType(transformationInfo.getOldClassName());
         this.newLambdaType = newLambdaType;
     }
 
     @Override
     @NotNull
-    public InlineResult doTransform(@NotNull AnonymousObjectRegenerationInfo regenerationInfo, @NotNull FieldRemapper parentRemapper) {
+    public InlineResult doTransform(@NotNull AnonymousObjectTransformationInfo transformationInfo, @NotNull FieldRemapper parentRemapper) {
         final List<InnerClassNode> innerClassNodes = new ArrayList<InnerClassNode>();
         ClassBuilder classBuilder = createRemappingClassBuilderViaFactory(inliningContext);
         final List<MethodNode> methodsToTransform = new ArrayList<MethodNode>();
@@ -155,13 +155,13 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         ParametersBuilder constructorParamBuilder = ParametersBuilder.newBuilder();
         List<CapturedParamInfo> additionalFakeParams =
                 extractParametersMappingAndPatchConstructor(constructor, allCapturedParamBuilder, constructorParamBuilder,
-                                                            regenerationInfo, parentRemapper);
+                                                            transformationInfo, parentRemapper);
         List<MethodVisitor> deferringMethods = new ArrayList<MethodVisitor>();
 
         for (MethodNode next : methodsToTransform) {
             MethodVisitor deferringVisitor = newMethod(classBuilder, next);
             InlineResult funResult =
-                    inlineMethodAndUpdateGlobalResult(regenerationInfo, parentRemapper, deferringVisitor, next, allCapturedParamBuilder, false);
+                    inlineMethodAndUpdateGlobalResult(transformationInfo, parentRemapper, deferringVisitor, next, allCapturedParamBuilder, false);
 
             Type returnType = Type.getReturnType(next.desc);
             if (!AsmUtil.isPrimitive(returnType)) {
@@ -178,7 +178,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             method.visitEnd();
         }
 
-        generateConstructorAndFields(classBuilder, allCapturedParamBuilder, constructorParamBuilder, regenerationInfo, parentRemapper, additionalFakeParams);
+        generateConstructorAndFields(classBuilder, allCapturedParamBuilder, constructorParamBuilder, transformationInfo, parentRemapper, additionalFakeParams);
 
         SourceMapper.Companion.flushToClassBuilder(sourceMapper, classBuilder);
 
@@ -201,14 +201,14 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
 
     @NotNull
     private InlineResult inlineMethodAndUpdateGlobalResult(
-            @NotNull AnonymousObjectRegenerationInfo regenerationInfo,
+            @NotNull AnonymousObjectTransformationInfo transformationInfo,
             @NotNull FieldRemapper parentRemapper,
             @NotNull MethodVisitor deferringVisitor,
             @NotNull MethodNode next,
             @NotNull ParametersBuilder allCapturedParamBuilder,
             boolean isConstructor
     ) {
-        InlineResult funResult = inlineMethod(regenerationInfo, parentRemapper, deferringVisitor, next, allCapturedParamBuilder, isConstructor);
+        InlineResult funResult = inlineMethod(transformationInfo, parentRemapper, deferringVisitor, next, allCapturedParamBuilder, isConstructor);
         transformationResult.addAllClassesToRemove(funResult);
         transformationResult.getReifiedTypeParametersUsages().mergeAll(funResult.getReifiedTypeParametersUsages());
         return funResult;
@@ -216,7 +216,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
 
     @NotNull
     private InlineResult inlineMethod(
-            @NotNull AnonymousObjectRegenerationInfo regenerationInfo,
+            @NotNull AnonymousObjectTransformationInfo transformationInfo,
             @NotNull FieldRemapper parentRemapper,
             @NotNull MethodVisitor deferringVisitor,
             @NotNull MethodNode sourceNode,
@@ -228,7 +228,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
 
         RegeneratedLambdaFieldRemapper remapper =
                 new RegeneratedLambdaFieldRemapper(oldObjectType.getInternalName(), newLambdaType.getInternalName(),
-                                                   parameters, regenerationInfo.getCapturedLambdasToInline(),
+                                                   parameters, transformationInfo.getCapturedLambdasToInline(),
                                                    parentRemapper, isConstructor);
 
         MethodInliner inliner =
@@ -238,12 +238,12 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
                         inliningContext.subInline(inliningContext.nameGenerator.subGenerator("lambda")),
                         remapper,
                         isSameModule,
-                        "Transformer for " + regenerationInfo.getOldClassName(),
+                        "Transformer for " + transformationInfo.getOldClassName(),
                         sourceMapper,
                         new InlineCallSiteInfo(
-                                regenerationInfo.getOldClassName(),
+                                transformationInfo.getOldClassName(),
                                 sourceNode.name,
-                                isConstructor ? regenerationInfo.getNewConstructorDescriptor() : sourceNode.desc),
+                                isConstructor ? transformationInfo.getNewConstructorDescriptor() : sourceNode.desc),
                         null
                 );
 
@@ -257,7 +257,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             @NotNull ClassBuilder classBuilder,
             @NotNull ParametersBuilder allCapturedBuilder,
             @NotNull ParametersBuilder constructorInlineBuilder,
-            @NotNull AnonymousObjectRegenerationInfo regenerationInfo,
+            @NotNull AnonymousObjectTransformationInfo transformationInfo,
             @NotNull FieldRemapper parentRemapper,
             @NotNull List<CapturedParamInfo> constructorAdditionalFakeParams
     ) {
@@ -285,7 +285,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
 
         String constructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, descTypes.toArray(new Type[descTypes.size()]));
         //TODO for inline method make public class
-        regenerationInfo.setNewConstructorDescriptor(constructorDescriptor);
+        transformationInfo.setNewConstructorDescriptor(constructorDescriptor);
         MethodVisitor constructorVisitor = classBuilder.newMethod(NO_ORIGIN,
                                                                   AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
                                                                   "<init>", constructorDescriptor,
@@ -323,7 +323,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             }
         }
 
-        inlineMethodAndUpdateGlobalResult(regenerationInfo, parentRemapper, capturedFieldInitializer, constructor, constructorInlineBuilder, true);
+        inlineMethodAndUpdateGlobalResult(transformationInfo, parentRemapper, capturedFieldInitializer, constructor, constructorInlineBuilder, true);
         constructorVisitor.visitEnd();
         AsmUtil.genClosureFields(TransformationUtilsKt.toNameTypePair(TransformationUtilsKt.filterSkipped(newFieldsWithSkipped)), classBuilder);
     }
@@ -367,20 +367,20 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             @NotNull MethodNode constructor,
             @NotNull ParametersBuilder capturedParamBuilder,
             @NotNull ParametersBuilder constructorParamBuilder,
-            @NotNull final AnonymousObjectRegenerationInfo regenerationInfo,
+            @NotNull final AnonymousObjectTransformationInfo transformationInfo,
             @NotNull FieldRemapper parentFieldRemapper
     ) {
 
         CapturedParamOwner owner = new CapturedParamOwner() {
             @Override
             public Type getType() {
-                return Type.getObjectType(regenerationInfo.getOldClassName());
+                return Type.getObjectType(transformationInfo.getOldClassName());
             }
         };
 
         Set<LambdaInfo> capturedLambdas = new LinkedHashSet<LambdaInfo>(); //captured var of inlined parameter
         List<CapturedParamInfo> constructorAdditionalFakeParams = new ArrayList<CapturedParamInfo>();
-        Map<Integer, LambdaInfo> indexToLambda = regenerationInfo.getLambdasToInline();
+        Map<Integer, LambdaInfo> indexToLambda = transformationInfo.getLambdasToInline();
         Set<Integer> capturedParams = new HashSet<Integer>();
 
         //load captured parameters and patch instruction list (NB: there is also could be object fields)
@@ -423,7 +423,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
         }
 
         constructorParamBuilder.addThis(oldObjectType, false);
-        String constructorDesc = regenerationInfo.getConstructorDesc();
+        String constructorDesc = transformationInfo.getConstructorDesc();
 
         if (constructorDesc == null) {
             // in case of anonymous object with empty closure
@@ -498,8 +498,8 @@ public class AnonymousObjectTransformer extends ObjectTransformer<AnonymousObjec
             constructorParamBuilder.addCapturedParam(recapturedParamInfo, recapturedParamInfo.getNewFieldName()).setRemapValue(composed);
         }
 
-        regenerationInfo.setAllRecapturedParameters(allRecapturedParameters);
+        transformationInfo.setAllRecapturedParameters(allRecapturedParameters);
-        regenerationInfo.setCapturedLambdasToInline(capturedLambdasToInline);
+        transformationInfo.setCapturedLambdasToInline(capturedLambdasToInline);
 
         return constructorAdditionalFakeParams;
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java

@@ -63,7 +63,7 @@ public class MethodInliner {
     private final List<InvokeCall> invokeCalls = new ArrayList<InvokeCall>();
 
     //keeps order
-    private final List<AnonymousObjectRegenerationInfo> anonymousObjectRegenerations = new ArrayList<AnonymousObjectRegenerationInfo>();
+    private final List<AnonymousObjectTransformationInfo> anonymousObjectRegenerations = new ArrayList<AnonymousObjectTransformationInfo>();
     //current state
     private final Map<String, String> currentTypeMapping = new HashMap<String, String>();
 
@@ -160,7 +160,7 @@ public class MethodInliner {
 
         final MethodNode resultNode = new MethodNode(node.access, node.name, node.desc, node.signature, null);
 
-        final Iterator<AnonymousObjectRegenerationInfo> iterator = anonymousObjectRegenerations.iterator();
+        final Iterator<AnonymousObjectTransformationInfo> iterator = anonymousObjectRegenerations.iterator();
 
         final TypeRemapper remapper = TypeRemapper.createFrom(currentTypeMapping);
         final RemappingMethodAdapter remappingMethodAdapter = new RemappingMethodAdapter(
@@ -173,17 +173,17 @@ public class MethodInliner {
         final int markerShift = InlineCodegenUtil.calcMarkerShift(parameters, node);
         InlineAdapter lambdaInliner = new InlineAdapter(remappingMethodAdapter, parameters.getArgsSizeOnStack(), sourceMapper) {
 
-            private AnonymousObjectRegenerationInfo anonymousObjectGen;
+            private AnonymousObjectTransformationInfo transformationInfo;
             private void handleAnonymousObjectRegeneration() {
-                anonymousObjectGen = iterator.next();
+                transformationInfo = iterator.next();
 
-                if (anonymousObjectGen.shouldRegenerate(isSameModule)) {
+                if (transformationInfo.shouldRegenerate(isSameModule)) {
                     //TODO: need poping of type but what to do with local funs???
-                    String oldClassName = anonymousObjectGen.getOldClassName();
+                    String oldClassName = transformationInfo.getOldClassName();
-                    String newClassName = anonymousObjectGen.getNewClassName();
+                    String newClassName = transformationInfo.getNewClassName();
                     remapper.addMapping(oldClassName, newClassName);
                     AnonymousObjectTransformer transformer =
-                            new AnonymousObjectTransformer((AnonymousObjectRegenerationInfo) anonymousObjectGen,
+                            new AnonymousObjectTransformer((AnonymousObjectTransformationInfo) transformationInfo,
                                                            inliningContext
                                                                    .subInlineWithClassRegeneration(
                                                                            inliningContext.nameGenerator,
@@ -192,11 +192,11 @@ public class MethodInliner {
                                                            isSameModule, Type.getObjectType(newClassName)
                             );
 
-                    InlineResult transformResult = transformer.doTransform(anonymousObjectGen, nodeRemapper);
+                    InlineResult transformResult = transformer.doTransform(transformationInfo, nodeRemapper);
                     result.addAllClassesToRemove(transformResult);
                     result.addChangedType(oldClassName, newClassName);
 
-                    if (inliningContext.isInliningLambda && anonymousObjectGen.canRemoveAfterTransformation()) {
+                    if (inliningContext.isInliningLambda && transformationInfo.canRemoveAfterTransformation()) {
                         // this class is transformed and original not used so we should remove original one after inlining
                         result.addClassToRemove(oldClassName);
                     }
@@ -214,7 +214,7 @@ public class MethodInliner {
                     handleAnonymousObjectRegeneration();
                 }
 
-                //in case of regenerated anonymousObjectGen type would be remapped to new one via remappingMethodAdapter
+                //in case of regenerated transformationInfo type would be remapped to new one via remappingMethodAdapter
                 super.anew(type);
             }
 
@@ -269,22 +269,22 @@ public class MethodInliner {
                     }
                 }
                 else if (isAnonymousConstructorCall(owner, name)) { //TODO add method
-                    assert anonymousObjectGen != null : "<init> call not corresponds to new call" + owner + " " + name;
+                    assert transformationInfo != null : "<init> call not corresponds to new call" + owner + " " + name;
-                    if (anonymousObjectGen.shouldRegenerate(isSameModule)) {
+                    if (transformationInfo.shouldRegenerate(isSameModule)) {
                         //put additional captured parameters on stack
-                        for (CapturedParamDesc capturedParamDesc : anonymousObjectGen.getAllRecapturedParameters()) {
+                        for (CapturedParamDesc capturedParamDesc : transformationInfo.getAllRecapturedParameters()) {
                             visitFieldInsn(Opcodes.GETSTATIC, capturedParamDesc.getContainingLambdaName(),
                                            "$$$" + capturedParamDesc.getFieldName(), capturedParamDesc.getType().getDescriptor());
                         }
-                        String newInternalName = anonymousObjectGen.getNewClassName();
+                        String newInternalName = transformationInfo.getNewClassName();
-                        super.visitMethodInsn(opcode, newInternalName, name, anonymousObjectGen.getNewConstructorDescriptor(), itf);
+                        super.visitMethodInsn(opcode, newInternalName, name, transformationInfo.getNewConstructorDescriptor(), itf);
 
                         //TODO: add new inner class also for other contexts
                         if (inliningContext.getParent() instanceof RegeneratedClassContext) {
-                            inliningContext.getParent().typeRemapper.addAdditionalMappings(anonymousObjectGen.getOldClassName(), newInternalName);
+                            inliningContext.getParent().typeRemapper.addAdditionalMappings(transformationInfo.getOldClassName(), newInternalName);
                         }
 
-                        anonymousObjectGen = null;
+                        transformationInfo = null;
                     } else {
                         super.visitMethodInsn(opcode, changeOwnerForExternalPackage(owner, opcode), name, desc, itf);
                     }
@@ -499,7 +499,7 @@ public class MethodInliner {
                     String owner = fieldInsnNode.owner;
                     if (isAnonymousSingletonLoad(owner, fieldInsnNode.name)) {
                         anonymousObjectRegenerations.add(
-                                new AnonymousObjectRegenerationInfo(
+                                new AnonymousObjectTransformationInfo(
                                         owner, awaitClassReification, isAlreadyRegenerated(owner), true,
                                         inliningContext.nameGenerator
                                 )
@@ -550,13 +550,13 @@ public class MethodInliner {
     }
 
     @NotNull
-    private AnonymousObjectRegenerationInfo buildConstructorInvocation(
+    private AnonymousObjectTransformationInfo buildConstructorInvocation(
             @NotNull String anonymousType,
             @NotNull String desc,
             @NotNull Map<Integer, LambdaInfo> lambdaMapping,
             boolean needReification
     ) {
-        return new AnonymousObjectRegenerationInfo(
+        return new AnonymousObjectTransformationInfo(
                 anonymousType, needReification, lambdaMapping,
                 inliningContext.classRegeneration,
                 isAlreadyRegenerated(anonymousType),

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt

@@ -23,7 +23,7 @@ import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.ClassVisitor
 import org.jetbrains.org.objectweb.asm.Type
 
-abstract class ObjectTransformer<T : RegenerationInfo>(val regenerationInfo: T, val state: GenerationState) {
+abstract class ObjectTransformer<T : TransformationInfo>(val transformationInfo: T, val state: GenerationState) {
 
     abstract fun doTransform(info: T, parentRemapper: FieldRemapper): InlineResult
 
@@ -33,7 +33,7 @@ abstract class ObjectTransformer<T : RegenerationInfo>(val regenerationInfo: T,
     protected fun createRemappingClassBuilderViaFactory(inliningContext: InliningContext): ClassBuilder {
         val classBuilder = state.factory.newVisitor(
                 JvmDeclarationOrigin.NO_ORIGIN,
-                Type.getObjectType(regenerationInfo.newClassName),
+                Type.getObjectType(transformationInfo.newClassName),
                 inliningContext.root.callElement.containingFile
         )
 
@@ -44,20 +44,20 @@ abstract class ObjectTransformer<T : RegenerationInfo>(val regenerationInfo: T,
 
 
     fun createClassReader(): ClassReader {
-        return InlineCodegenUtil.buildClassReaderByInternalName(state, regenerationInfo.oldClassName)
+        return InlineCodegenUtil.buildClassReaderByInternalName(state, transformationInfo.oldClassName)
     }
 
 }
 
 class WhenMappingTransformer(
-        whenObjectRegenerationInfo: WhenMappingRegenerationInfo,
+        whenObjectRegenerationInfo: WhenMappingTransformationInfo,
         state: GenerationState,
         val inliningContext: InliningContext
-) : ObjectTransformer<WhenMappingRegenerationInfo>(whenObjectRegenerationInfo, state) {
+) : ObjectTransformer<WhenMappingTransformationInfo>(whenObjectRegenerationInfo, state) {
 
-    override fun doTransform(info: WhenMappingRegenerationInfo, parentRemapper: FieldRemapper): InlineResult {
+    override fun doTransform(info: WhenMappingTransformationInfo, parentRemapper: FieldRemapper): InlineResult {
         val classReader = createClassReader()
-        //TODO add additional check that it's when mapping
+        //TODO add additional check that class is when mapping
 
         val classBuilder = createRemappingClassBuilderViaFactory(inliningContext)
         classReader.accept(object : ClassVisitor(InlineCodegenUtil.API, classBuilder.visitor) {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TransformationInfo.kt

@@ -18,19 +18,19 @@ package org.jetbrains.kotlin.codegen.inline
 
 import java.util.*
 
-abstract class RegenerationInfo() {
+interface TransformationInfo {
 
-	abstract val oldClassName: String
+	val oldClassName: String
 
-	abstract val newClassName: String
+	val newClassName: String
 
-	abstract fun shouldRegenerate(sameModule: Boolean): Boolean
+	fun shouldRegenerate(sameModule: Boolean): Boolean
 
-	abstract fun canRemoveAfterTransformation(): Boolean
+	fun canRemoveAfterTransformation(): Boolean
 
 }
 
-class WhenMappingRegenerationInfo(override val oldClassName: String, val nameGenerator: NameGenerator) : RegenerationInfo() {
+class WhenMappingTransformationInfo(override val oldClassName: String, val nameGenerator: NameGenerator) : TransformationInfo {
 
 	override val newClassName by lazy {
 		nameGenerator.genLambdaClassName() + oldClassName.substringAfterLast("/")
@@ -45,7 +45,7 @@ class WhenMappingRegenerationInfo(override val oldClassName: String, val nameGen
 	}
 }
 
-class AnonymousObjectRegenerationInfo internal constructor(
+class AnonymousObjectTransformationInfo internal constructor(
 		override val oldClassName: String,
 		private val needReification: Boolean,
 		val lambdasToInline: Map<Int, LambdaInfo>,
@@ -53,7 +53,7 @@ class AnonymousObjectRegenerationInfo internal constructor(
 		private val alreadyRegenerated: Boolean,
 		val constructorDesc: String?,
 		private val isStaticOrigin: Boolean,
-		private val nameGenerator: NameGenerator) : RegenerationInfo() {
+		private val nameGenerator: NameGenerator) : TransformationInfo {
 
 	 override val newClassName: String by lazy {
 		nameGenerator.genLambdaClassName()