Get rid of myStack holding intermediate StackValues and use functional style visitor instead.

idea/src/org/jetbrains/jet/codegen/ClassContext.java

@@ -37,7 +37,7 @@ public class ClassContext {
     }
 
     public StackValue getThisExpression() {
-        if (parentContext == null) return null;
+        if (parentContext == null) return StackValue.none();
 
         thisWasUsed = true;
         if (thisExpression != null) return thisExpression;

idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -3,7 +3,9 @@ package org.jetbrains.jet.codegen;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.psi.JetDeclarationWithBody;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.MethodVisitor;
@@ -12,7 +14,6 @@ import org.objectweb.asm.Type;
 import org.objectweb.asm.commons.InstructionAdapter;
 import org.objectweb.asm.commons.Method;
 
-import java.util.Collections;
 import java.util.List;
 
 /**
@@ -40,11 +41,10 @@ public class FunctionCodegen {
         ClassContext funContext = owner.intoFunction(functionDescriptor);
 
         final JetExpression bodyExpression = f.getBodyExpression();
-        final List<JetElement> bodyExpressions = bodyExpression != null ? Collections.<JetElement>singletonList(bodyExpression) : null;
+        generatedMethod(bodyExpression, jvmMethod, funContext, functionDescriptor.getValueParameters(), functionDescriptor.getTypeParameters());
-        generatedMethod(bodyExpressions, jvmMethod, funContext, functionDescriptor.getValueParameters(), functionDescriptor.getTypeParameters());
     }
 
-    private void generatedMethod(List<JetElement> bodyExpressions,
+    private void generatedMethod(JetExpression bodyExpressions,
                                  Method jvmSignature,
                                  ClassContext context,
                                  List<ValueParameterDescriptor> paramDescrs,
@@ -95,35 +95,11 @@ public class FunctionCodegen {
                 iv.areturn(jvmSignature.getReturnType());
             }
             else if (!isAbstract) {
-                JetElement last = null;
+                codegen.returnExpression(bodyExpressions);
-                for (JetElement expression : bodyExpressions) {
-                    expression.accept(codegen);
-                    last = expression;
-                }
-                generateReturn(mv, last, codegen, jvmSignature);
             }
             mv.visitMaxs(0, 0);
             mv.visitEnd();
         }
     }
 
-    private void generateReturn(MethodVisitor mv, JetElement bodyExpression, ExpressionCodegen codegen, Method jvmSignature) {
-        if (!endsWithReturn(bodyExpression)) {
-            if (jvmSignature.getReturnType() == Type.VOID_TYPE) {
-                mv.visitInsn(Opcodes.RETURN);
-            }
-            else {
-                codegen.returnTopOfStack();
-            }
-        }
-    }
-
-    private static boolean endsWithReturn(JetElement bodyExpression) {
-        if (bodyExpression instanceof JetBlockExpression) {
-            final List<JetElement> statements = ((JetBlockExpression) bodyExpression).getStatements();
-            return statements.size() > 0 && statements.get(statements.size()-1) instanceof JetReturnExpression;
-        }
-
-        return bodyExpression instanceof JetReturnExpression;
-    }
 }

idea/src/org/jetbrains/jet/codegen/StackValue.java

@@ -48,8 +48,7 @@ public abstract class StackValue {
     }
 
     public static StackValue onStack(Type type) {
-        assert type != Type.VOID_TYPE;
+        return type == Type.VOID_TYPE ? none() : new OnStack(type);
-        return new OnStack(type);
     }
 
     public static StackValue constant(Object value, Type type) {
@@ -190,6 +189,21 @@ public abstract class StackValue {
         v.mark(end);
     }
 
+    public static StackValue none() {
+        return None.INSTANCE;
+    }
+    
+    private static class None extends StackValue {
+        public static None INSTANCE = new None();
+        private None() {
+            super(Type.VOID_TYPE);
+        }
+
+        @Override
+        public void put(Type type, InstructionAdapter v) {
+        }
+    }
+
     public static class Local extends StackValue {
         private final int index;
 

idea/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java

@@ -15,8 +15,8 @@ import java.util.List;
  */
 public class ArraySize implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
-        codegen.ensureReceiverOnStack(element, null, JetTypeMapper.TYPE_OBJECT);
+        receiver.put(JetTypeMapper.TYPE_OBJECT, v);
         v.arraylength();
         return StackValue.onStack(Type.INT_TYPE);
     }

idea/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java

@@ -2,7 +2,6 @@ package org.jetbrains.jet.codegen.intrinsics;
 
 import com.intellij.psi.PsiElement;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.objectweb.asm.Type;
@@ -21,16 +20,16 @@ public class BinaryOp implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         if (arguments.size() == 1) {
             // intrinsic is called as an ordinary function
-            codegen.ensureReceiverOnStack(element, null, expectedType);
+            if (receiver != null) {
+                receiver.put(expectedType, v);
+            }
             codegen.gen(arguments.get(0), expectedType);
         }
         else {
-            if (!haveReceiver) {
+            codegen.gen(arguments.get(0), expectedType);
-                codegen.gen(arguments.get(0), expectedType);
-            }
             codegen.gen(arguments.get(1), expectedType);
         }
         v.visitInsn(expectedType.getOpcode(opcode));

idea/src/org/jetbrains/jet/codegen/intrinsics/Concat.java

@@ -14,16 +14,18 @@ import java.util.List;
  */
 public class Concat implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         codegen.generateStringBuilderConstructor();
-        if (haveReceiver) {
+        if (receiver == null) {                                    // LHS.plus(RHS)
-            v.swap();
+            v.swap();                                                              // StringBuilder LHS
-            codegen.invokeAppendMethod(codegen.expressionType(arguments.get(0)));
+            codegen.invokeAppendMethod(codegen.expressionType(arguments.get(0)));  // StringBuilder(LHS)
-        }
-        else {
             codegen.invokeAppend(arguments.get(0));
         }
-        codegen.invokeAppend(arguments.get(1));
+        else {                                                     // LHS + RHS
+            codegen.invokeAppend(arguments.get(0));                                // StringBuilder(LHS)
+            codegen.invokeAppend(arguments.get(1));
+        }
+        
         v.invokevirtual(ExpressionCodegen.CLASS_STRING_BUILDER, "toString", "()Ljava/lang/String;");
         return StackValue.onStack(Type.getObjectType("java/lang/String"));
     }

idea/src/org/jetbrains/jet/codegen/intrinsics/Increment.java

@@ -22,7 +22,7 @@ public class Increment implements IntrinsicMethod {
     }
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         final JetExpression operand = arguments.get(0);
         if (operand instanceof JetReferenceExpression) {
             final int index = codegen.indexOfLocal((JetReferenceExpression) operand);
@@ -31,7 +31,7 @@ public class Increment implements IntrinsicMethod {
                 return StackValue.local(index, expectedType);
             }
         }
-        StackValue value = codegen.generateIntermediateValue(operand);
+        StackValue value = codegen.genQualified(receiver, operand);
         value.dupReceiver(v, 0);
         value.put(expectedType, v);
         if (expectedType == Type.LONG_TYPE) {

idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java

@@ -14,5 +14,5 @@ import java.util.List;
  * @author yole
  */
 public interface IntrinsicMethod extends Callable {
-    StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver);
+    StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver);
 }

idea/src/org/jetbrains/jet/codegen/intrinsics/Inv.java

@@ -14,8 +14,8 @@ import java.util.List;
  */
 public class Inv implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
-        codegen.putTopOfStack(expectedType);
+        receiver.put(expectedType, v);
         v.aconst(-1);
         v.xor(expectedType);
         return StackValue.onStack(expectedType);

idea/src/org/jetbrains/jet/codegen/intrinsics/Not.java

@@ -14,13 +14,13 @@ import java.util.List;
  */
 public class Not implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         final StackValue stackValue;
         if (arguments.size() == 1) {
-            stackValue = codegen.generateIntermediateValue(arguments.get(0));
+            stackValue = codegen.gen(arguments.get(0));
         }
         else {
-            stackValue = codegen.getReceiverAsStackValue(element, null, expectedType);
+            stackValue = receiver;
         }
         return StackValue.not(stackValue);
     }

idea/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java

@@ -14,8 +14,8 @@ import java.util.List;
  */
 public class NumberCast implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
-        codegen.putTopOfStack(expectedType);
+        receiver.put(expectedType, v);
         return StackValue.onStack(expectedType);
     }
 }

idea/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java

@@ -24,9 +24,9 @@ public class PsiMethodCall implements IntrinsicMethod {
 
     @Override
     public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element,
-                               List<JetExpression> arguments, boolean haveReceiver) {
+                               List<JetExpression> arguments, StackValue receiver) {
         final CallableMethod callableMethod = codegen.getTypeMapper().mapToCallableMethod(myMethod);
-        codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, haveReceiver);
+        codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver);
         return StackValue.onStack(callableMethod.getSignature().getReturnType());
     }
 }

idea/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java

@@ -21,7 +21,7 @@ public class RangeTo implements IntrinsicMethod {
     private static final String CLASS_INT_RANGE = "jet/IntRange";
 
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         JetBinaryExpression expression = (JetBinaryExpression) element;
         final Type leftType = codegen.expressionType(expression.getLeft());
         if (JetTypeMapper.isIntPrimitive(leftType)) {

idea/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java

@@ -17,7 +17,7 @@ import java.util.List;
  */
 public class TypeInfo implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         final List<JetTypeProjection> typeArguments = ((JetCallExpression) element).getTypeArguments();
         if (typeArguments.size() != 1) {
             throw new UnsupportedOperationException("one type argument expected");

idea/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java

@@ -14,12 +14,12 @@ import java.util.List;
  */
 public class UnaryMinus implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         if (arguments.size() == 1) {
             codegen.gen(arguments.get(0), expectedType);
         }
         else {
-            codegen.ensureReceiverOnStack(element, null, expectedType);
+            receiver.put(expectedType, v);
         }
         v.neg(expectedType);
         return StackValue.onStack(expectedType);

idea/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java

@@ -15,7 +15,7 @@ import java.util.List;
  */
 public class ValueTypeInfo implements IntrinsicMethod {
     @Override
-    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
+    public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
         codegen.gen(arguments.get(0), JetTypeMapper.TYPE_JET_OBJECT);
         v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
         return StackValue.onStack(JetTypeMapper.TYPE_TYPEINFO);