From c84486f860d3045d2ba965e004986493cdb2e7c6 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 10 Feb 2015 16:38:34 +0300 Subject: [PATCH] Refactor CodegenContext and subclasses Drop unused methods, inline parameters, fix warnings, etc. --- .../kotlin/codegen/ClosureCodegen.java | 15 +++---- .../kotlin/codegen/ExpressionCodegen.java | 16 +++---- .../context/AnonymousClassContext.java | 1 - .../kotlin/codegen/context/ClassContext.java | 29 +++++++++---- .../codegen/context/ClosureContext.java | 22 +++++++--- .../codegen/context/CodegenContext.java | 42 +++++++------------ .../kotlin/codegen/context/MethodContext.java | 5 --- .../codegen/context/PackageContext.java | 5 --- .../kotlin/codegen/context/RootContext.java | 9 +--- .../kotlin/codegen/context/ScriptContext.java | 5 --- 10 files changed, 70 insertions(+), 79 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index 631d26926a0..ab453ddb330 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.codegen.binding.CalculatedClosure; -import org.jetbrains.kotlin.codegen.context.ClassContext; +import org.jetbrains.kotlin.codegen.context.ClosureContext; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; @@ -71,24 +71,21 @@ public class ClosureCodegen extends MemberCodegen { public ClosureCodegen( @NotNull GenerationState state, @NotNull JetElement element, - @NotNull FunctionDescriptor funDescriptor, @Nullable SamType samType, - @NotNull ClassContext context, + @NotNull ClosureContext context, @NotNull KotlinSyntheticClass.Kind syntheticClassKind, @NotNull FunctionGenerationStrategy strategy, @NotNull MemberCodegen parentCodegen, - @NotNull ClassBuilder classBuilder, - @NotNull Type asmType + @NotNull ClassBuilder classBuilder ) { super(state, parentCodegen, context, element, classBuilder); - this.funDescriptor = funDescriptor; + this.funDescriptor = context.getFunctionDescriptor(); + this.classDescriptor = context.getContextDescriptor(); this.samType = samType; this.syntheticClassKind = syntheticClassKind; this.strategy = strategy; - this.classDescriptor = context.getContextDescriptor(); - if (samType == null) { this.superInterfaceTypes = new ArrayList(); @@ -115,7 +112,7 @@ public class ClosureCodegen extends MemberCodegen { this.closure = bindingContext.get(CLOSURE, classDescriptor); assert closure != null : "Closure must be calculated for class: " + classDescriptor; - this.asmType = asmType; + this.asmType = typeMapper.mapClass(classDescriptor); visibilityFlag = AsmUtil.getVisibilityAccessFlagForAnonymous(classDescriptor); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 3d9f943c061..7b59182944d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -1390,13 +1390,14 @@ public class ExpressionCodegen extends JetVisitor implem @Nullable SamType samType, @NotNull KotlinSyntheticClass.Kind kind ) { - Type asmType = asmTypeForAnonymousClass(bindingContext, descriptor); - ClassBuilder cv = state.getFactory().newVisitor(OtherOrigin(declaration, descriptor), asmType, declaration.getContainingFile()); - ClassContext closureContext = context.intoClosure(descriptor, this, typeMapper); + ClassBuilder cv = state.getFactory().newVisitor( + OtherOrigin(declaration, descriptor), + asmTypeForAnonymousClass(bindingContext, descriptor), + declaration.getContainingFile() + ); ClosureCodegen closureCodegen = new ClosureCodegen( - state, declaration, descriptor, samType, closureContext, kind, - strategy, parentCodegen, cv, asmType + state, declaration, samType, context.intoClosure(descriptor, this, typeMapper), kind, strategy, parentCodegen, cv ); closureCodegen.generate(); @@ -1410,7 +1411,7 @@ public class ExpressionCodegen extends JetVisitor implem } @Override - public StackValue visitObjectLiteralExpression(@NotNull final JetObjectLiteralExpression expression, final StackValue receiver) { + public StackValue visitObjectLiteralExpression(@NotNull JetObjectLiteralExpression expression, StackValue receiver) { final ObjectLiteralResult objectLiteralResult = generateObjectLiteral(expression); final ClassDescriptor classDescriptor = objectLiteralResult.classDescriptor; final Type type = typeMapper.mapType(classDescriptor); @@ -2481,8 +2482,7 @@ public class ExpressionCodegen extends JetVisitor implem public StackValue generateThisOrOuter(@NotNull ClassDescriptor calleeContainingClass, boolean isSuper) { boolean isSingleton = calleeContainingClass.getKind().isSingleton(); if (isSingleton) { - if (context.hasThisDescriptor() && - context.getThisDescriptor().equals(calleeContainingClass) && + if (calleeContainingClass.equals(context.getThisDescriptor()) && !AnnotationsPackage.isPlatformStaticInObjectOrClass(context.getContextDescriptor())) { return StackValue.local(0, typeMapper.mapType(calleeContainingClass)); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/AnonymousClassContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/AnonymousClassContext.java index f3d4446730f..5478da4744c 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/AnonymousClassContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/AnonymousClassContext.java @@ -31,7 +31,6 @@ public class AnonymousClassContext extends ClassContext { @Nullable CodegenContext parentContext, @Nullable LocalLookup localLookup ) { - //noinspection SuspiciousMethodCalls super(typeMapper, contextDescriptor, contextKind, parentContext, localLookup); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java index 222105e8c8b..65571f6e690 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java @@ -19,12 +19,16 @@ package org.jetbrains.kotlin.codegen.context; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.codegen.OwnerKind; +import org.jetbrains.kotlin.codegen.StackValue; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.kotlin.descriptors.ClassDescriptor; +import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD; import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE; +import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.canHaveOuter; public class ClassContext extends FieldOwnerContext { + private final JetTypeMapper typeMapper; public ClassContext( @NotNull JetTypeMapper typeMapper, @@ -33,12 +37,28 @@ public class ClassContext extends FieldOwnerContext { @Nullable CodegenContext parentContext, @Nullable LocalLookup localLookup ) { - //noinspection SuspiciousMethodCalls super(contextDescriptor, contextKind, parentContext, typeMapper.getBindingContext().get(CLOSURE, contextDescriptor), contextDescriptor, localLookup); - initOuterExpression(typeMapper, contextDescriptor); + + this.typeMapper = typeMapper; } + @Override + @Nullable + protected StackValue.Field computeOuterExpression() { + ClassDescriptor enclosingClass = getEnclosingClass(); + if (enclosingClass == null) return null; + + if (!canHaveOuter(typeMapper.getBindingContext(), getContextDescriptor())) return null; + + return StackValue.field( + typeMapper.mapType(enclosingClass), + typeMapper.mapType(getContextDescriptor()), + CAPTURED_THIS_FIELD, + /* isStatic = */ false, + StackValue.LOCAL_0 + ); + } @Nullable public CodegenContext getClassObjectContext() { @@ -48,11 +68,6 @@ public class ClassContext extends FieldOwnerContext { return null; } - @Override - public boolean isStatic() { - return false; - } - @Override public String toString() { return "Class: " + getContextDescriptor(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java index 57b00cd86f3..96a2f541028 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClosureContext.java @@ -20,18 +20,28 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.codegen.OwnerKind; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; -import org.jetbrains.kotlin.descriptors.ClassDescriptor; +import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -class ClosureContext extends ClassContext { +import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.anonymousClassForFunction; + +public class ClosureContext extends ClassContext { + private final FunctionDescriptor functionDescriptor; public ClosureContext( @NotNull JetTypeMapper typeMapper, - @NotNull ClassDescriptor classDescriptor, + @NotNull FunctionDescriptor functionDescriptor, @Nullable CodegenContext parentContext, - @Nullable LocalLookup localLookup + @NotNull LocalLookup localLookup ) { - //noinspection SuspiciousMethodCalls - super(typeMapper, classDescriptor, OwnerKind.IMPLEMENTATION, parentContext, localLookup); + super(typeMapper, anonymousClassForFunction(typeMapper.getBindingContext(), functionDescriptor), + OwnerKind.IMPLEMENTATION, parentContext, localLookup); + + this.functionDescriptor = functionDescriptor; + } + + @NotNull + public FunctionDescriptor getFunctionDescriptor() { + return functionDescriptor; } @Override diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java index 6f40b771e7a..1f58cd70dc4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java @@ -33,10 +33,7 @@ import org.jetbrains.org.objectweb.asm.Type; import java.util.*; -import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_THIS_FIELD; import static org.jetbrains.kotlin.codegen.AsmUtil.getVisibilityAccessFlag; -import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.anonymousClassForFunction; -import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.canHaveOuter; import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PRIVATE; import static org.jetbrains.org.objectweb.asm.Opcodes.ACC_PROTECTED; @@ -49,10 +46,10 @@ public abstract class CodegenContext { private final ClassDescriptor thisDescriptor; public final MutableClosure closure; private final LocalLookup enclosingLocalLookup; + private final NullableLazyValue outerExpression; private Map accessors; private Map childContexts; - private NullableLazyValue lazyOuterExpression; public CodegenContext( @NotNull T contextDescriptor, @@ -60,14 +57,20 @@ public abstract class CodegenContext { @Nullable CodegenContext parentContext, @Nullable MutableClosure closure, @Nullable ClassDescriptor thisDescriptor, - @Nullable LocalLookup expressionCodegen + @Nullable LocalLookup localLookup ) { this.contextDescriptor = contextDescriptor; this.contextKind = contextKind; this.parentContext = parentContext; this.closure = closure; this.thisDescriptor = thisDescriptor; - this.enclosingLocalLookup = expressionCodegen; + this.enclosingLocalLookup = localLookup; + this.outerExpression = LockBasedStorageManager.NO_LOCKS.createNullableLazyValue(new Function0() { + @Override + public StackValue.Field invoke() { + return computeOuterExpression(); + } + }); if (parentContext != null) { parentContext.addChild(this); @@ -116,7 +119,7 @@ public abstract class CodegenContext { } private StackValue getOuterExpression(@Nullable StackValue prefix, boolean ignoreNoOuter, boolean captureThis) { - if (lazyOuterExpression == null || lazyOuterExpression.invoke() == null) { + if (outerExpression.invoke() == null) { if (!ignoreNoOuter) { throw new UnsupportedOperationException("Don't know how to generate outer expression for " + getContextDescriptor()); } @@ -128,7 +131,7 @@ public abstract class CodegenContext { } closure.setCaptureThis(); } - return StackValue.changeReceiverForFieldAndSharedVar(lazyOuterExpression.invoke(), prefix); + return StackValue.changeReceiverForFieldAndSharedVar(outerExpression.invoke(), prefix); } @NotNull @@ -187,13 +190,12 @@ public abstract class CodegenContext { } @NotNull - public ClassContext intoClosure( + public ClosureContext intoClosure( @NotNull FunctionDescriptor funDescriptor, @NotNull LocalLookup localLookup, @NotNull JetTypeMapper typeMapper ) { - ClassDescriptor classDescriptor = anonymousClassForFunction(typeMapper.getBindingContext(), funDescriptor); - return new ClosureContext(typeMapper, classDescriptor, this, localLookup); + return new ClosureContext(typeMapper, funDescriptor, this, localLookup); } @Nullable @@ -257,21 +259,9 @@ public abstract class CodegenContext { return accessor; } - public abstract boolean isStatic(); - - protected void initOuterExpression(@NotNull final JetTypeMapper typeMapper, @NotNull final ClassDescriptor classDescriptor) { - lazyOuterExpression = LockBasedStorageManager.NO_LOCKS.createNullableLazyValue(new Function0() { - @Override - public StackValue.Field invoke() { - ClassDescriptor enclosingClass = getEnclosingClass(); - if (enclosingClass == null) return null; - - return canHaveOuter(typeMapper.getBindingContext(), classDescriptor) - ? StackValue.field(typeMapper.mapType(enclosingClass), typeMapper.mapType(classDescriptor), - CAPTURED_THIS_FIELD, false, StackValue.LOCAL_0) - : null; - } - }); + @Nullable + protected StackValue.Field computeOuterExpression() { + return null; } public StackValue lookupInContext(DeclarationDescriptor d, @Nullable StackValue result, GenerationState state, boolean ignoreNoOuter) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java index 990cad3a365..d98cd986aff 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/MethodContext.java @@ -78,11 +78,6 @@ public class MethodContext extends CodegenContext { return lookupInContext(parameter, StackValue.LOCAL_0, state, ignoreNoOuter); } - @Override - public boolean isStatic() { - return getParentContext().isStatic(); - } - @Override public StackValue getOuterExpression(StackValue prefix, boolean ignoreNoOuter) { return getParentContext().getOuterExpression(prefix, false); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java index 6ca56fa9a95..826bc1b780b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/PackageContext.java @@ -31,11 +31,6 @@ public class PackageContext extends FieldOwnerContext this.packagePartType = packagePartType; } - @Override - public boolean isStatic() { - return true; - } - @Override public String toString() { return "Package: " + getContextDescriptor().getName(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/RootContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/RootContext.java index b40d4e2abbf..3e63db79663 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/RootContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/RootContext.java @@ -24,22 +24,17 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.types.TypeSubstitutor; -class RootContext extends CodegenContext { +class RootContext extends CodegenContext { public RootContext() { super(new FakeDescriptor(), OwnerKind.PACKAGE, null, null, null, null); } - @Override - public boolean isStatic() { - return true; - } - @Override public String toString() { return "ROOT"; } - private static class FakeDescriptor implements DeclarationDescriptor { + static class FakeDescriptor implements DeclarationDescriptor { @NotNull @Override public DeclarationDescriptor getOriginal() { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java index b26b7d9b7c7..64905a5971b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ScriptContext.java @@ -61,9 +61,4 @@ public class ScriptContext extends FieldOwnerContext { } return "script$" + (index + 1); } - - @Override - public boolean isStatic() { - return true; - } }