From 374d50609d681d62cfd782fe3596fe6bde35be1a Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 4 Jul 2014 21:22:22 +0400 Subject: [PATCH] Inline ExpressionCodegen#pushMethodArguments, drop "skipLast" hack --- .../codegen/CallBasedArgumentGenerator.java | 15 ++--- .../jet/codegen/ExpressionCodegen.java | 60 +++++++++---------- 2 files changed, 34 insertions(+), 41 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CallBasedArgumentGenerator.java b/compiler/backend/src/org/jetbrains/jet/codegen/CallBasedArgumentGenerator.java index f25ceac4416..ff8628ded5f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CallBasedArgumentGenerator.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CallBasedArgumentGenerator.java @@ -34,25 +34,24 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator { private final CallGenerator callGenerator; private final List valueParameters; private final List valueParameterTypes; - private final boolean skipLast; public CallBasedArgumentGenerator( @NotNull ExpressionCodegen codegen, @NotNull CallGenerator callGenerator, @NotNull List valueParameters, - @NotNull List valueParameterTypes, - boolean skipLast + @NotNull List valueParameterTypes ) { this.codegen = codegen; this.callGenerator = callGenerator; this.valueParameters = valueParameters; this.valueParameterTypes = valueParameterTypes; - this.skipLast = skipLast; + + assert valueParameters.size() == valueParameterTypes.size() : + "Value parameters and their types mismatch in sizes: " + valueParameters.size() + " != " + valueParameterTypes.size(); } @Override protected void generateExpression(int i, @NotNull ExpressionValueArgument argument) { - if (shouldSkip(i)) return; ValueParameterDescriptor parameter = valueParameters.get(i); Type type = valueParameterTypes.get(i); ValueArgument valueArgument = argument.getValueArgument(); @@ -64,7 +63,6 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator { @Override protected void generateDefault(int i, @NotNull DefaultValueArgument argument) { - if (shouldSkip(i)) return; ValueParameterDescriptor parameter = valueParameters.get(i); Type type = valueParameterTypes.get(i); pushDefaultValueOnStack(type, codegen.v); @@ -73,14 +71,9 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator { @Override protected void generateVararg(int i, @NotNull VarargValueArgument argument) { - if (shouldSkip(i)) return; ValueParameterDescriptor parameter = valueParameters.get(i); Type type = valueParameterTypes.get(i); codegen.genVarargs(argument, parameter.getType()); callGenerator.afterParameterPut(type, null, parameter); } - - private boolean shouldSkip(int i) { - return skipLast && i == valueParameters.size() - 1; - } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 2a2b80c7b90..0cde7aa165d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1342,8 +1342,7 @@ public class ExpressionCodegen extends JetVisitor implem assert valueArguments != null : "Failed to arrange value arguments by index: " + superConstructor; ArgumentGenerator argumentGenerator = new CallBasedArgumentGenerator(this, defaultCallGenerator, superConstructor.getValueParameters(), - typeMapper.mapToCallableMethod(superConstructor).getValueParameterTypes(), - /* skipLast = */ false); + typeMapper.mapToCallableMethod(superConstructor).getValueParameterTypes()); argumentGenerator.generate(valueArguments); } @@ -2131,9 +2130,19 @@ public class ExpressionCodegen extends JetVisitor implem "Tail recursive method couldn't be inlined " + descriptor; ArgumentGenerator argumentGenerator = new CallBasedArgumentGenerator(this, callGenerator, descriptor.getValueParameters(), - callableMethod.getValueParameterTypes(), - /* skipLast = */ false); - int mask = pushMethodArguments(receiver, resolvedCall, callableMethod, callGenerator, argumentGenerator); + callableMethod.getValueParameterTypes()); + + if (!(descriptor instanceof ConstructorDescriptor)) { // otherwise already + receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod); + receiver.put(receiver.type, v); + } + + callGenerator.putHiddenParams(); + + List valueArguments = resolvedCall.getValueArgumentsByIndex(); + assert valueArguments != null : "Failed to arrange value arguments by index: " + descriptor; + + int mask = argumentGenerator.generate(valueArguments); if (tailRecursionCodegen.isTailRecursion(resolvedCall)) { tailRecursionCodegen.generateTailRecursion(resolvedCall); @@ -2316,28 +2325,6 @@ public class ExpressionCodegen extends JetVisitor implem return false; } - private int pushMethodArguments( - @Nullable StackValue receiver, - @NotNull ResolvedCall resolvedCall, - @NotNull CallableMethod callableMethod, - @NotNull CallGenerator callGenerator, - @NotNull ArgumentGenerator argumentGenerator - ) { - CallableDescriptor descriptor = resolvedCall.getResultingDescriptor(); - - if (!(descriptor instanceof ConstructorDescriptor)) { // otherwise already - receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod); - receiver.put(receiver.type, v); - } - - callGenerator.putHiddenParams(); - - List valueArguments = resolvedCall.getValueArgumentsByIndex(); - assert valueArguments != null : "Failed to arrange value arguments by index: " + descriptor; - - return argumentGenerator.generate(valueArguments); - } - public void genVarargs(@NotNull VarargValueArgument valueArgument, @NotNull JetType outType) { Type type = asmType(outType); assert type.getSort() == Type.ARRAY; @@ -3371,9 +3358,22 @@ public class ExpressionCodegen extends JetVisitor implem ArgumentGenerator argumentGenerator = new CallBasedArgumentGenerator(this, defaultCallGenerator, resolvedCall.getResultingDescriptor().getValueParameters(), - callableMethod.getValueParameterTypes(), - /* skipLast = */ !isGetter); - pushMethodArguments(receiver, resolvedCall, callableMethod, defaultCallGenerator, argumentGenerator); + callableMethod.getValueParameterTypes()); + + receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod); + receiver.put(receiver.type, v); + + List valueArguments = resolvedCall.getValueArgumentsByIndex(); + assert valueArguments != null : "Failed to arrange value arguments by index: " + operationDescriptor; + + if (!isGetter) { + assert valueArguments.size() >= 2 : "Setter call should have at least 2 arguments: " + operationDescriptor; + + // Skip generation of the right hand side of an indexed assignment, which is the last value argument + valueArguments.remove(valueArguments.size() - 1); + } + + argumentGenerator.generate(valueArguments); } else { gen(array, arrayType); // intrinsic method