diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java b/compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java index 1a28ba69649..16157825090 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java @@ -16,10 +16,10 @@ package org.jetbrains.jet.codegen; -import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind; import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature; -import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.codegen.signature.JvmMethodSignature; import java.util.List; @@ -28,10 +28,10 @@ import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; public class ConstructorFrameMap extends FrameMap { private int myOuterThisIndex = -1; - public ConstructorFrameMap(CallableMethod callableMethod, @Nullable ConstructorDescriptor descriptor) { + public ConstructorFrameMap(@NotNull JvmMethodSignature signature) { enterTemp(OBJECT_TYPE); // this - List parameterTypes = callableMethod.getSignature().getKotlinParameterTypes(); + List parameterTypes = signature.getKotlinParameterTypes(); if (parameterTypes != null) { for (JvmMethodParameterSignature parameterType : parameterTypes) { if (parameterType.getKind() == JvmMethodParameterKind.OUTER) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index ab6709efe53..eb09d79d29f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -74,13 +74,7 @@ public class FunctionCodegen extends GenerationStateAware { assert functionDescriptor != null; OwnerKind kind = owner.getContextKind(); - JvmMethodSignature method = - typeMapper.mapToCallableMethod( - functionDescriptor, - false, - isCallInsideSameClassAsDeclared(functionDescriptor, owner), - isCallInsideSameModuleAsDeclared(functionDescriptor, owner), - kind).getSignature(); + JvmMethodSignature method = typeMapper.mapSignature(functionDescriptor, true, kind); if (kind != OwnerKind.TRAIT_IMPL || function.getBodyExpression() != null) { boolean needJetAnnotations = kind != OwnerKind.TRAIT_IMPL; @@ -88,7 +82,7 @@ public class FunctionCodegen extends GenerationStateAware { new FunctionGenerationStrategy.FunctionDefault(state, functionDescriptor, function)); } - generateDefaultIfNeeded(owner.intoFunction(functionDescriptor), state, v, method.getAsmMethod(), functionDescriptor, kind, + generateDefaultIfNeeded(owner.intoFunction(functionDescriptor), state, v, method, functionDescriptor, kind, DefaultParameterValueLoader.DEFAULT); } @@ -524,10 +518,10 @@ public class FunctionCodegen extends GenerationStateAware { } static void generateDefaultIfNeeded( - MethodContext owner, + @NotNull MethodContext owner, GenerationState state, ClassBuilder v, - Method jvmSignature, + JvmMethodSignature signature, @NotNull FunctionDescriptor functionDescriptor, OwnerKind kind, DefaultParameterValueLoader loadStrategy @@ -552,6 +546,8 @@ public class FunctionCodegen extends GenerationStateAware { CodegenBinding.canHaveOuter(state.getBindingContext(), ((ConstructorDescriptor) functionDescriptor).getContainingDeclaration()); boolean isStatic = isStatic(kind); + Method jvmSignature = signature.getAsmMethod(); + if (kind == OwnerKind.TRAIT_IMPL) { String correctedDescr = "(" + jvmSignature.getDescriptor().substring(jvmSignature.getDescriptor().indexOf(";") + 1); jvmSignature = new Method(jvmSignature.getName(), correctedDescr); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionGenerationStrategy.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionGenerationStrategy.java index fd81638252c..6a7f7426e47 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionGenerationStrategy.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionGenerationStrategy.java @@ -52,12 +52,12 @@ public abstract class FunctionGenerationStrategy { } @NotNull - protected FrameMap createFrameMap(@NotNull JetTypeMapper typeMapper, @NotNull CodegenContext context) { + protected FrameMap createFrameMap(@NotNull JetTypeMapper typeMapper, @NotNull MethodContext context) { return context.prepareFrame(typeMapper); } @NotNull - public FrameMap getFrameMap(@NotNull JetTypeMapper typeMapper, @NotNull CodegenContext context) { + public FrameMap getFrameMap(@NotNull JetTypeMapper typeMapper, @NotNull MethodContext context) { if (frameMap == null) { frameMap = createFrameMap(typeMapper, context); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 56ef145be49..cba0dfea6d1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -749,7 +749,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { }); MethodContext functionContext = context.intoFunction(function); - FunctionCodegen.generateDefaultIfNeeded(functionContext, state, v, methodSignature.getAsmMethod(), function, OwnerKind.IMPLEMENTATION, + FunctionCodegen.generateDefaultIfNeeded(functionContext, state, v, methodSignature, function, OwnerKind.IMPLEMENTATION, new DefaultParameterValueLoader() { @Override public void putValueOnStack( @@ -816,7 +816,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Method method = typeMapper.mapSignature(bridge).getAsmMethod(); boolean isConstructor = original instanceof ConstructorDescriptor; Method originalMethod = isConstructor ? - typeMapper.mapToCallableMethod((ConstructorDescriptor) original).getSignature().getAsmMethod() : + typeMapper.mapConstructorSignature((ConstructorDescriptor) original).getAsmMethod() : typeMapper.mapSignature(original).getAsmMethod(); Type[] argTypes = method.getArgumentTypes(); @@ -938,18 +938,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { lookupConstructorExpressionsInClosureIfPresent(constructorContext); } - final CallableMethod callableMethod = typeMapper.mapToCallableMethod(constructorDescriptor, context.closure); - JvmMethodSignature constructorMethod = callableMethod.getSignature(); + final JvmMethodSignature constructorSignature = typeMapper.mapConstructorSignature(constructorDescriptor, closure); assert constructorDescriptor != null; - functionCodegen.generateMethod(null, constructorMethod, true, constructorDescriptor, constructorContext, + functionCodegen.generateMethod(null, constructorSignature, true, constructorDescriptor, constructorContext, new FunctionGenerationStrategy.CodegenBased(state, constructorDescriptor) { @NotNull @Override - protected FrameMap createFrameMap(@NotNull JetTypeMapper typeMapper, @NotNull CodegenContext context) { - return new ConstructorFrameMap(callableMethod, callableDescriptor); + protected FrameMap createFrameMap(@NotNull JetTypeMapper typeMapper, @NotNull MethodContext context) { + return new ConstructorFrameMap(constructorSignature); } @Override @@ -959,10 +958,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } ); - FunctionCodegen.generateDefaultIfNeeded(constructorContext, state, v, constructorMethod.getAsmMethod(), constructorDescriptor, + FunctionCodegen.generateDefaultIfNeeded(constructorContext, state, v, constructorSignature, constructorDescriptor, OwnerKind.IMPLEMENTATION, DefaultParameterValueLoader.DEFAULT); - + CallableMethod callableMethod = typeMapper.mapToCallableMethod(constructorDescriptor, closure); FunctionCodegen.generateConstructorWithoutParametersIfNeeded(state, callableMethod, constructorDescriptor, v); } @@ -1336,13 +1335,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { @NotNull FunctionDescriptor inheritedFun, @NotNull MethodVisitor mv ) { - JvmMethodSignature jvmSignature = typeMapper.mapToCallableMethod( - inheritedFun, - false, - isCallInsideSameClassAsDeclared(inheritedFun, context), - isCallInsideSameModuleAsDeclared(inheritedFun, context), - OwnerKind.IMPLEMENTATION).getSignature(); - + JvmMethodSignature jvmSignature = typeMapper.mapSignature(inheritedFun, true, OwnerKind.IMPLEMENTATION); JetMethodAnnotationWriter aw = JetMethodAnnotationWriter.visitAnnotation(mv); int kotlinFlags = getFlagsForVisibility(fun.getVisibility()); if (fun instanceof PropertyAccessorDescriptor) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java index f646c7acd65..5861fa2a645 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java @@ -24,6 +24,7 @@ import org.jetbrains.asm4.Type; import org.jetbrains.asm4.commons.InstructionAdapter; import org.jetbrains.asm4.commons.Method; import org.jetbrains.jet.codegen.context.CodegenContext; +import org.jetbrains.jet.codegen.context.MethodContext; import org.jetbrains.jet.codegen.context.ScriptContext; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; import org.jetbrains.jet.codegen.state.GenerationState; @@ -99,7 +100,7 @@ public class ScriptCodegen extends MemberCodegen { @NotNull ScriptDescriptor scriptDescriptor, @NotNull ClassDescriptor classDescriptorForScript, @NotNull ClassBuilder classBuilder, - @NotNull CodegenContext context, + @NotNull MethodContext context, @NotNull List importedScripts ) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java index 53d3b59cc28..f78261f5c6c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java @@ -255,15 +255,6 @@ public abstract class CodegenContext { public abstract boolean isStatic(); - public void copyAccessors(Map accessors) { - if (accessors != null) { - if (this.accessors == null) { - this.accessors = new HashMap(); - } - this.accessors.putAll(accessors); - } - } - protected void initOuterExpression(JetTypeMapper typeMapper, ClassDescriptor classDescriptor) { ClassDescriptor enclosingClass = getEnclosingClass(); outerExpression = enclosingClass != null && canHaveOuter(typeMapper.getBindingContext(), classDescriptor) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/signature/JvmMethodSignature.java b/compiler/backend/src/org/jetbrains/jet/codegen/signature/JvmMethodSignature.java index c23af8f1c0a..a6d6c20a1fa 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/signature/JvmMethodSignature.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/signature/JvmMethodSignature.java @@ -90,7 +90,7 @@ public class JvmMethodSignature { return kotlinTypeParameter; } - @Nullable + @NotNull public List getKotlinParameterTypes() { checkGenericsAvailable(); return kotlinParameterTypes; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 3df691f617f..6b2e915f340 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -217,13 +217,13 @@ public class JetTypeMapper extends BindingTraceAware { } @NotNull - public Type mapType(JetType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull JetTypeMapperMode kind) { + public Type mapType(@NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull JetTypeMapperMode kind) { return mapType(jetType, signatureVisitor, kind, Variance.INVARIANT); } @NotNull public Type mapType( - JetType jetType, + @NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor, @NotNull JetTypeMapperMode kind, @NotNull Variance howThisTypeIsUsed @@ -577,7 +577,7 @@ public class JetTypeMapper extends BindingTraceAware { } @NotNull - private JvmMethodSignature mapSignature(@NotNull FunctionDescriptor f, boolean needGenericSignature, @NotNull OwnerKind kind) { + public JvmMethodSignature mapSignature(@NotNull FunctionDescriptor f, boolean needGenericSignature, @NotNull OwnerKind kind) { String name = f.getName().getName(); if (f instanceof PropertyAccessorDescriptor) { boolean isGetter = f instanceof PropertyGetterDescriptor; @@ -776,13 +776,19 @@ public class JetTypeMapper extends BindingTraceAware { return signatureWriter.makeJvmPropertyAccessorSignature(name, false); } - private void writeParameter(BothSignatureWriter signatureWriter, JetType outType) { + private void writeParameter(@NotNull BothSignatureWriter signatureWriter, @NotNull JetType outType) { signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); mapType(outType, signatureWriter, JetTypeMapperMode.VALUE); signatureWriter.writeParameterTypeEnd(); } - private JvmMethodSignature mapConstructorSignature(ConstructorDescriptor descriptor, CalculatedClosure closure) { + @NotNull + public JvmMethodSignature mapConstructorSignature(@NotNull ConstructorDescriptor descriptor) { + return mapConstructorSignature(descriptor, bindingContext.get(CodegenBinding.CLOSURE, descriptor.getContainingDeclaration())); + } + + @NotNull + public JvmMethodSignature mapConstructorSignature(@NotNull ConstructorDescriptor descriptor, @Nullable CalculatedClosure closure) { BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD, true); @@ -848,9 +854,7 @@ public class JetTypeMapper extends BindingTraceAware { ConstructorDescriptor superConstructor = (ConstructorDescriptor) superDescriptor; if (isObjectLiteral(bindingContext, descriptor.getContainingDeclaration())) { - //noinspection SuspiciousMethodCalls - CallableMethod superCallable = mapToCallableMethod(superConstructor); - List types = superCallable.getSignature().getKotlinParameterTypes(); + List types = mapConstructorSignature(superConstructor).getKotlinParameterTypes(); if (types != null) { for (JvmMethodParameterSignature type : types) { signatureWriter.writeParameterType(JvmMethodParameterKind.SUPER_CALL_PARAM); @@ -901,11 +905,13 @@ public class JetTypeMapper extends BindingTraceAware { return signatureWriter.makeJvmMethodSignature(""); } - public CallableMethod mapToCallableMethod(ConstructorDescriptor descriptor) { + @NotNull + public CallableMethod mapToCallableMethod(@NotNull ConstructorDescriptor descriptor) { return mapToCallableMethod(descriptor, bindingContext.get(CodegenBinding.CLOSURE, descriptor.getContainingDeclaration())); } - public CallableMethod mapToCallableMethod(ConstructorDescriptor descriptor, CalculatedClosure closure) { + @NotNull + public CallableMethod mapToCallableMethod(@NotNull ConstructorDescriptor descriptor, @Nullable CalculatedClosure closure) { JvmMethodSignature method = mapConstructorSignature(descriptor, closure); JetType defaultType = descriptor.getContainingDeclaration().getDefaultType(); Type mapped = mapType(defaultType, JetTypeMapperMode.IMPL);