diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java index 8a475602ce9..c0a014ba50b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java +++ b/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 { +public class AnonymousObjectTransformer extends ObjectTransformer { protected final GenerationState state; @@ -59,23 +59,23 @@ public class AnonymousObjectTransformer extends ObjectTransformer> fieldNames = new HashMap>(); 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 innerClassNodes = new ArrayList(); ClassBuilder classBuilder = createRemappingClassBuilderViaFactory(inliningContext); final List methodsToTransform = new ArrayList(); @@ -155,13 +155,13 @@ public class AnonymousObjectTransformer extends ObjectTransformer additionalFakeParams = extractParametersMappingAndPatchConstructor(constructor, allCapturedParamBuilder, constructorParamBuilder, - regenerationInfo, parentRemapper); + transformationInfo, parentRemapper); List deferringMethods = new ArrayList(); 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 constructorAdditionalFakeParams ) { @@ -285,7 +285,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer", constructorDescriptor, @@ -323,7 +323,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer capturedLambdas = new LinkedHashSet(); //captured var of inlined parameter List constructorAdditionalFakeParams = new ArrayList(); - Map indexToLambda = regenerationInfo.getLambdasToInline(); + Map indexToLambda = transformationInfo.getLambdasToInline(); Set capturedParams = new HashSet(); //load captured parameters and patch instruction list (NB: there is also could be object fields) @@ -423,7 +423,7 @@ public class AnonymousObjectTransformer extends ObjectTransformer invokeCalls = new ArrayList(); //keeps order - private final List anonymousObjectRegenerations = new ArrayList(); + private final List anonymousObjectRegenerations = new ArrayList(); //current state private final Map currentTypeMapping = new HashMap(); @@ -160,7 +160,7 @@ public class MethodInliner { final MethodNode resultNode = new MethodNode(node.access, node.name, node.desc, node.signature, null); - final Iterator iterator = anonymousObjectRegenerations.iterator(); + final Iterator 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 newClassName = anonymousObjectGen.getNewClassName(); + String oldClassName = transformationInfo.getOldClassName(); + 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 : " call not corresponds to new call" + owner + " " + name; - if (anonymousObjectGen.shouldRegenerate(isSameModule)) { + assert transformationInfo != null : " call not corresponds to new call" + owner + " " + name; + 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(); - super.visitMethodInsn(opcode, newInternalName, name, anonymousObjectGen.getNewConstructorDescriptor(), itf); + String newInternalName = transformationInfo.getNewClassName(); + 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 lambdaMapping, boolean needReification ) { - return new AnonymousObjectRegenerationInfo( + return new AnonymousObjectTransformationInfo( anonymousType, needReification, lambdaMapping, inliningContext.classRegeneration, isAlreadyRegenerated(anonymousType), diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt index f94e4fd991d..02c73eebbe7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ObjectTransformer.kt +++ b/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(val regenerationInfo: T, val state: GenerationState) { +abstract class ObjectTransformer(val transformationInfo: T, val state: GenerationState) { abstract fun doTransform(info: T, parentRemapper: FieldRemapper): InlineResult @@ -33,7 +33,7 @@ abstract class ObjectTransformer(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(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(whenObjectRegenerationInfo, state) { +) : ObjectTransformer(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) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegenerationInfo.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TransformationInfo.kt similarity index 82% rename from compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegenerationInfo.kt rename to compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TransformationInfo.kt index 1ce431b7924..93fc04c3a0d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegenerationInfo.kt +++ b/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, @@ -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()