From 9452c200a0491ca2eba422a8b673ef48acfadabd Mon Sep 17 00:00:00 2001 From: Michael Bogdanov Date: Thu, 10 Dec 2015 15:22:23 +0300 Subject: [PATCH] Keep typeRemapper in inlining context instead of hashMap for transformed types --- .../inline/AnonymousObjectTransformer.java | 12 ++----- .../codegen/inline/InliningContext.java | 17 ++++------ .../kotlin/codegen/inline/MethodInliner.java | 13 ++++---- .../inline/RegeneratedClassContext.java | 4 +-- .../codegen/inline/RootInliningContext.java | 3 +- .../kotlin/codegen/inline/TypeRemapper.java | 33 +++++++++++++++++-- 6 files changed, 51 insertions(+), 31 deletions(-) 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 9f4ea4ab5bd..211b2bdd82a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.java @@ -27,10 +27,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.org.objectweb.asm.*; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; -import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode; -import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode; -import org.jetbrains.org.objectweb.asm.tree.MethodNode; -import org.jetbrains.org.objectweb.asm.tree.VarInsnNode; +import org.jetbrains.org.objectweb.asm.tree.*; import java.util.*; @@ -65,8 +62,6 @@ public class AnonymousObjectTransformer { private final Map> fieldNames = new HashMap>(); - private final TypeRemapper typeRemapper; - public AnonymousObjectTransformer( @NotNull String objectInternalName, @NotNull InliningContext inliningContext, @@ -81,7 +76,6 @@ public class AnonymousObjectTransformer { this.newLambdaType = newLambdaType; reader = InlineCodegenUtil.buildClassReaderByInternalName(state, objectInternalName); - typeRemapper = new TypeRemapper(inliningContext.typeMapping); transformationResult = InlineResult.create(); } @@ -192,7 +186,7 @@ public class AnonymousObjectTransformer { String oldFunReturnType = returnType.getInternalName(); String newFunReturnType = funResult.getChangedTypes().get(oldFunReturnType); if (newFunReturnType != null) { - typeRemapper.addAdditionalMappings(oldFunReturnType, newFunReturnType); + inliningContext.typeRemapper.addAdditionalMappings(oldFunReturnType, newFunReturnType); } } deferringMethods.add(deferringVisitor); @@ -344,7 +338,7 @@ public class AnonymousObjectTransformer { @NotNull private ClassBuilder createClassBuilder() { ClassBuilder classBuilder = state.getFactory().newVisitor(NO_ORIGIN, newLambdaType, inliningContext.getRoot().callElement.getContainingFile()); - return new RemappingClassBuilder(classBuilder, typeRemapper); + return new RemappingClassBuilder(classBuilder, inliningContext.typeRemapper); } @NotNull diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java index 999713b572d..5143e43196d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.java @@ -35,7 +35,7 @@ public class InliningContext { public final NameGenerator nameGenerator; - public final Map typeMapping; + public final TypeRemapper typeRemapper; public final ReifiedTypeInliner reifedTypeInliner; @@ -48,7 +48,7 @@ public class InliningContext { @NotNull Map map, @NotNull GenerationState state, @NotNull NameGenerator nameGenerator, - @NotNull Map typeMapping, + @NotNull TypeRemapper typeRemapper, @NotNull ReifiedTypeInliner reifedTypeInliner, boolean isInliningLambda, boolean classRegeneration @@ -57,7 +57,7 @@ public class InliningContext { expressionMap = map; this.state = state; this.nameGenerator = nameGenerator; - this.typeMapping = typeMapping; + this.typeRemapper = typeRemapper; this.reifedTypeInliner = reifedTypeInliner; this.isInliningLambda = isInliningLambda; this.classRegeneration = classRegeneration; @@ -78,13 +78,12 @@ public class InliningContext { } public InliningContext subInlineWithClassRegeneration(@NotNull NameGenerator generator, - @NotNull Map additionalTypeMappings, + @NotNull Map newTypeMappings, @NotNull AnonymousObjectGeneration anonymousObjectGeneration ) { - Map newTypeMappings = new HashMap(typeMapping); - newTypeMappings.putAll(additionalTypeMappings); return new RegeneratedClassContext(this, expressionMap, state, generator, - newTypeMappings, reifedTypeInliner, isInliningLambda, anonymousObjectGeneration); + new TypeRemapper(typeRemapper, newTypeMappings), + reifedTypeInliner, isInliningLambda, anonymousObjectGeneration); } public InliningContext subInline(NameGenerator generator, Map additionalTypeMappings, boolean isInliningLambda) { @@ -97,10 +96,8 @@ public class InliningContext { boolean isInliningLambda, boolean isRegeneration ) { - Map newTypeMappings = new HashMap(typeMapping); - newTypeMappings.putAll(additionalTypeMappings); return new InliningContext(this, expressionMap, state, generator, - newTypeMappings, reifedTypeInliner, isInliningLambda, isRegeneration); + new TypeRemapper(typeRemapper, additionalTypeMappings), reifedTypeInliner, isInliningLambda, isRegeneration); } public boolean isRoot() { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java index 7eb5865dd7a..1b573fdfc2e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.java @@ -78,7 +78,7 @@ public class MethodInliner { public MethodInliner( @NotNull MethodNode node, @NotNull Parameters parameters, - @NotNull InliningContext parent, + @NotNull InliningContext inliningContext, @NotNull FieldRemapper nodeRemapper, boolean isSameModule, @NotNull String errorPrefix, @@ -86,12 +86,12 @@ public class MethodInliner { ) { this.node = node; this.parameters = parameters; - this.inliningContext = parent; + this.inliningContext = inliningContext; this.nodeRemapper = nodeRemapper; this.isSameModule = isSameModule; this.errorPrefix = errorPrefix; this.sourceMapper = sourceMapper; - this.typeMapper = parent.state.getTypeMapper(); + this.typeMapper = inliningContext.state.getTypeMapper(); this.result = InlineResult.create(); } @@ -153,8 +153,9 @@ public class MethodInliner { final Iterator iterator = anonymousObjectGenerations.iterator(); + final TypeRemapper remapper = TypeRemapper.createFrom(currentTypeMapping); RemappingMethodAdapter remappingMethodAdapter = new RemappingMethodAdapter(resultNode.access, resultNode.desc, resultNode, - new TypeRemapper(currentTypeMapping)); + remapper); final int markerShift = InlineCodegenUtil.calcMarkerShift(parameters, node); InlineAdapter lambdaInliner = new InlineAdapter(remappingMethodAdapter, parameters.getArgsSizeOnStack(), sourceMapper) { @@ -167,7 +168,7 @@ public class MethodInliner { //TODO: need poping of type but what to do with local funs??? String oldClassName = anonymousObjectGen.getOwnerInternalName(); String newClassName = inliningContext.nameGenerator.genLambdaClassName(); - currentTypeMapping.put(oldClassName, newClassName); + remapper.addMapping(oldClassName, newClassName); AnonymousObjectTransformer transformer = new AnonymousObjectTransformer(oldClassName, inliningContext @@ -551,7 +552,7 @@ public class MethodInliner { } private boolean isAlreadyRegenerated(@NotNull String owner) { - return inliningContext.typeMapping.containsKey(owner); + return inliningContext.typeRemapper.hasNoAdditionalMapping(owner); } @Nullable diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegeneratedClassContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegeneratedClassContext.java index 49e21d26753..4a3bbfa48f0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegeneratedClassContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RegeneratedClassContext.java @@ -30,12 +30,12 @@ public class RegeneratedClassContext extends InliningContext { @NotNull Map map, @NotNull GenerationState state, @NotNull NameGenerator nameGenerator, - @NotNull Map typeMapping, + @NotNull TypeRemapper typeRemapper, @NotNull ReifiedTypeInliner reifiedTypeInliner, boolean isInliningLambda, @NotNull AnonymousObjectGeneration anonymousObjectGeneration ) { - super(parent, map, state, nameGenerator, typeMapping, reifiedTypeInliner, isInliningLambda, true); + super(parent, map, state, nameGenerator, typeRemapper, reifiedTypeInliner, isInliningLambda, true); this.anonymousObjectGeneration = anonymousObjectGeneration; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java index f3e62022047..22940a9ea2d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/RootInliningContext.java @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.codegen.context.CodegenContext; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.psi.KtElement; -import java.util.Collections; import java.util.Map; public class RootInliningContext extends InliningContext { @@ -38,7 +37,7 @@ public class RootInliningContext extends InliningContext { @NotNull String classNameToInline, @NotNull ReifiedTypeInliner inliner ) { - super(null, map, state, nameGenerator, Collections.emptyMap(), inliner, false, false); + super(null, map, state, nameGenerator, TypeRemapper.createEmpty(), inliner, false, false); this.callElement = callElement; this.startContext = startContext; this.classNameToInline = classNameToInline; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.java index 6ff1757821e..ea3923c18f7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TypeRemapper.java @@ -23,14 +23,43 @@ import java.util.HashMap; import java.util.Map; public class TypeRemapper extends Remapper { + //typeMapping field could be changed outside through method processing private final Map typeMapping; + private Map additionalMappings; - //typeMapping could be changed outside through method processing - public TypeRemapper(@NotNull Map typeMapping) { + //typeMapping field could be changed outside through method processing + private TypeRemapper(@NotNull Map typeMapping) { this.typeMapping = typeMapping; } + public TypeRemapper(@NotNull TypeRemapper remapper, @NotNull Map newTypeMappings) { + this(createNewAndMerge(remapper, newTypeMappings)); + } + + public static TypeRemapper createEmpty() { + return new TypeRemapper(new HashMap()); + } + + public static TypeRemapper createFrom(Map mappings) { + return new TypeRemapper(mappings); + } + + @NotNull + private static Map createNewAndMerge(@NotNull TypeRemapper remapper, @NotNull Map additionalTypeMappings) { + Map map = new HashMap(remapper.typeMapping); + map.putAll(additionalTypeMappings); + return map; + } + + public void addMapping(String type, String newType) { + typeMapping.put(type, newType); + } + + public boolean hasNoAdditionalMapping(String type) { + return typeMapping.containsKey(type); + } + @Override public String map(String type) { String newType = typeMapping.get(type);