use StackValue (and StackValue.expression() in particular) instead of Runnable as the expression in instanceof check

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

@@ -1597,12 +1597,7 @@ public class ExpressionCodegen extends JetVisitor {
                 throw new UnsupportedOperationException("don't know how to handle non-class types in as/as?");
             }
             Type type = typeMapper.mapType(jetType, OwnerKind.INTERFACE);
-            generateInstanceOf(new Runnable() {
+            generateInstanceOf(StackValue.expression(OBJECT_TYPE, expression.getLeft(), this), jetType, true);
-                        @Override
-                        public void run() {
-                            gen(expression.getLeft(), OBJECT_TYPE);
-                        }
-                    }, jetType, true);
             Label isInstance = new Label();
             v.ifne(isInstance);
             v.pop();
@@ -1626,19 +1621,15 @@ public class ExpressionCodegen extends JetVisitor {
 
     @Override
     public void visitIsExpression(final JetIsExpression expression) {
-        generatePatternMatch(expression.getPattern(), expression.isNegated(), new Runnable() {
+        generatePatternMatch(expression.getPattern(), expression.isNegated(),
-            @Override
+                             StackValue.expression(OBJECT_TYPE, expression.getLeftHandSide(), this));
-            public void run() {
-                gen(expression.getLeftHandSide(), OBJECT_TYPE);
-            }
-        });
     }
 
-    private void generatePatternMatch(JetPattern pattern, boolean negated, Runnable expressionGen) {
+    private void generatePatternMatch(JetPattern pattern, boolean negated, StackValue expressionToMatch) {
         if (pattern instanceof JetTypePattern) {
             JetTypeReference typeReference = ((JetTypePattern) pattern).getTypeReference();
             JetType jetType = bindingContext.resolveTypeReference(typeReference);
-            generateInstanceOf(expressionGen, jetType, false);
+            generateInstanceOf(expressionToMatch, jetType, false);
             StackValue value = StackValue.onStack(Type.BOOLEAN_TYPE);
             myStack.push(negated ? StackValue.not(value) : value);
         }
@@ -1650,18 +1641,18 @@ public class ExpressionCodegen extends JetVisitor {
         }
     }
 
-    private void generateInstanceOf(Runnable expressionGen, JetType jetType, boolean leaveExpressionOnStack) {
+    private void generateInstanceOf(StackValue expressionToGen, JetType jetType, boolean leaveExpressionOnStack) {
         DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
         if (jetType.getArguments().size() > 0 || !(descriptor instanceof ClassDescriptor)) {
             generateTypeInfo(jetType);
-            expressionGen.run();
+            expressionToGen.put(OBJECT_TYPE, v);
             if (leaveExpressionOnStack) {
                 v.dupX1();
             }
             v.invokevirtual("jet/typeinfo/TypeInfo", "isInstance", "(Ljava/lang/Object;)Z");
         }
         else {
-            expressionGen.run();
+            expressionToGen.put(OBJECT_TYPE, v);
             if (leaveExpressionOnStack) {
                 v.dup();
             }
@@ -1757,12 +1748,7 @@ public class ExpressionCodegen extends JetVisitor {
                 else if (condition instanceof JetWhenConditionIsPattern) {
                     JetWhenConditionIsPattern patternCondition = (JetWhenConditionIsPattern) condition;
                     JetPattern pattern = patternCondition.getPattern();
-                    generatePatternMatch(pattern, patternCondition.isNegated(), new Runnable() {
+                    generatePatternMatch(pattern, patternCondition.isNegated(), StackValue.local(subjectLocal, subjectType));
-                        @Override
-                        public void run() {
-                            new StackValue.Local(subjectLocal, subjectType).put(OBJECT_TYPE, v);
-                        }
-                    });
                 }
                 else {
                     throw new UnsupportedOperationException("unsupported kind of when condition");

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

@@ -1,6 +1,7 @@
 package org.jetbrains.jet.codegen;
 
 import com.intellij.psi.tree.IElementType;
+import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
@@ -83,6 +84,10 @@ public abstract class StackValue {
         return new Property(name, owner, getter, setter, isStatic, isInterface, type);
     }
 
+    public static StackValue expression(Type type, JetExpression expression, ExpressionCodegen generator) {
+        return new Expression(type, expression, generator);
+    }
+
     private static void box(final Type type, final Type toType, InstructionAdapter v) {
         // TODO handle toType correctly
         if (type == Type.INT_TYPE || (JetTypeMapper.isIntPrimitive(type) && toType.getInternalName().equals("java/lang/Integer"))) {
@@ -538,4 +543,20 @@ public abstract class StackValue {
             }
         }
     }
+
+    private static class Expression extends StackValue {
+        private final JetExpression expression;
+        private final ExpressionCodegen generator;
+
+        public Expression(Type type, JetExpression expression, ExpressionCodegen generator) {
+            super(type);
+            this.expression = expression;
+            this.generator = generator;
+        }
+
+        @Override
+        public void put(Type type, InstructionAdapter v) {
+            generator.gen(expression, type);
+        }
+    }
 }