From fc894242953ab641de2392b8611113a65f2543c9 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 27 Jun 2014 20:39:32 +0400 Subject: [PATCH] Minor corrections in JVM codegen - use mapSignature instead of mapToCallableMethod where possible - use resolvedCall where possible - fix some warnings and style issues --- .../org/jetbrains/jet/codegen/ExpressionCodegen.java | 11 ++++------- .../org/jetbrains/jet/codegen/FunctionCodegen.java | 5 +++-- .../jet/codegen/ImplementationBodyCodegen.java | 8 +++----- .../jet/codegen/intrinsics/MonitorInstruction.java | 10 +++------- 4 files changed, 13 insertions(+), 21 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index fb372f3fadc..aaf15bb8415 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1325,7 +1325,7 @@ public class ExpressionCodegen extends JetVisitor implem ConstructorDescriptor constructorDescriptor = bindingContext.get(CONSTRUCTOR, expression.getObjectDeclaration()); assert constructorDescriptor != null; - CallableMethod constructor = typeMapper.mapToCallableMethod(constructorDescriptor); + Method constructor = typeMapper.mapSignature(constructorDescriptor).getAsmMethod(); Type type = bindingContext.get(ASM_TYPE, constructorDescriptor.getContainingDeclaration()); assert type != null; @@ -1337,16 +1337,13 @@ public class ExpressionCodegen extends JetVisitor implem JetDelegatorToSuperCall superCall = closure.getSuperCall(); if (superCall != null) { - ConstructorDescriptor superConstructor = (ConstructorDescriptor) bindingContext - .get(REFERENCE_TARGET, superCall.getCalleeExpression().getConstructorReferenceExpression()); - assert superConstructor != null; - CallableMethod superCallable = typeMapper.mapToCallableMethod(superConstructor); - Type[] argumentTypes = superCallable.getAsmMethod().getArgumentTypes(); ResolvedCall resolvedCall = getResolvedCallWithAssert(superCall, bindingContext); + ConstructorDescriptor superConstructor = (ConstructorDescriptor) resolvedCall.getResultingDescriptor(); + Type[] argumentTypes = typeMapper.mapSignature(superConstructor).getAsmMethod().getArgumentTypes(); pushMethodArgumentsWithoutCallReceiver(resolvedCall, Arrays.asList(argumentTypes), false, defaultCallGenerator); } - v.invokespecial(type.getInternalName(), "", constructor.getAsmMethod().getDescriptor()); + v.invokespecial(type.getInternalName(), "", constructor.getDescriptor()); return StackValue.onStack(type); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index ba056e0c487..8c4620b4250 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -496,7 +496,7 @@ public class FunctionCodegen extends ParentCodegenAware { } } ); - return strings.toArray(new String[strings.size()]); + return ArrayUtil.toStringArray(strings); } static void generateConstructorWithoutParametersIfNeeded( @@ -661,7 +661,8 @@ public class FunctionCodegen extends ParentCodegenAware { CallableMethod method; if (functionDescriptor instanceof ConstructorDescriptor) { method = state.getTypeMapper().mapToCallableMethod((ConstructorDescriptor) functionDescriptor); - } else { + } + else { method = state.getTypeMapper().mapToCallableMethod(functionDescriptor, false, methodContext); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index a1f3bdfff74..391038b7987 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -869,8 +869,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { parameterIndex += type.getSize(); } - String constructorJvmDescriptor = typeMapper.mapToCallableMethod(constructor).getAsmMethod().getDescriptor(); - iv.invokespecial(thisDescriptorType.getInternalName(), "", constructorJvmDescriptor); + Method constructorAsmMethod = typeMapper.mapSignature(constructor).getAsmMethod(); + iv.invokespecial(thisDescriptorType.getInternalName(), "", constructorAsmMethod.getDescriptor()); iv.areturn(thisDescriptorType); } @@ -1580,8 +1580,6 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { iv.load(2, Type.INT_TYPE); } - CallableMethod method = typeMapper.mapToCallableMethod(constructorDescriptor); - ResolvedCall resolvedCall = BindingContextUtilPackage.getResolvedCallWithAssert(superCall, bindingContext); ConstructorDescriptor superConstructor = (ConstructorDescriptor) resolvedCall.getResultingDescriptor(); @@ -1594,7 +1592,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { CallableMethod superCallable = typeMapper.mapToCallableMethod(superConstructor); if (isAnonymousObject(descriptor) && superCall instanceof JetDelegatorToSuperCall) { - int nextVar = findFirstSuperArgument(method); + int nextVar = findFirstSuperArgument(typeMapper.mapToCallableMethod(constructorDescriptor)); for (Type t : superCallable.getAsmMethod().getArgumentTypes()) { iv.load(nextVar, t); nextVar += t.getSize(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/MonitorInstruction.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/MonitorInstruction.java index b57712d283f..8c84207c016 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/MonitorInstruction.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/MonitorInstruction.java @@ -23,8 +23,6 @@ import org.jetbrains.jet.codegen.ExpressionCodegen; import org.jetbrains.jet.codegen.StackValue; import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage; -import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.org.objectweb.asm.Opcodes; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; @@ -32,6 +30,7 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; import java.util.Arrays; import java.util.List; +import static org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage.getResolvedCallWithAssert; import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; public class MonitorInstruction extends IntrinsicMethod { @@ -56,12 +55,9 @@ public class MonitorInstruction extends IntrinsicMethod { @Nullable StackValue receiver ) { assert element != null : "Element should not be null"; - ResolvedCall resolvedCall = BindingContextUtilPackage.getResolvedCall((JetElement) element, codegen.getBindingContext()); - - assert resolvedCall != null : "Resolved call for " + element.getText() + " should be not null"; codegen.pushMethodArgumentsWithoutCallReceiver( - resolvedCall, + getResolvedCallWithAssert((JetElement) element, codegen.getBindingContext()), Arrays.asList(OBJECT_TYPE), false, codegen.defaultCallGenerator @@ -70,4 +66,4 @@ public class MonitorInstruction extends IntrinsicMethod { v.visitInsn(opcode); return Type.VOID_TYPE; } -} \ No newline at end of file +}