Avoid inserting new temporaries because of HTypeConversion nodes.

lib/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String buildJavaScriptFunction(FunctionElement element,
@@ skipping 498 matching lines @@
       buffer.add(variableName);
       if (!isGeneratingDeclaration()) {
         delayedVarDecl = delayedVarDecl.prepend(variableName);
       }
     } else {
       buffer.add("var ");
       buffer.add(variableName);
     }
   }
 
+  bool needsNewVariable(HInstruction instruction) {
+    bool needsVar = !instruction.usedBy.isEmpty();
+    if (needsVar && instruction is HCheck) {
+      HCheck check = instruction;
+      HInstruction input = check.checkedInput;
+      // We only need a new var if [input] is generated at use site
+      // but is not a trivial code motion invariant instruction like
+      // for parameters or this.
+      //
+      // For example:
+      // Foo a = this;
+      // print(a);
+      // print(a);
+      //
+      // In checked mode no new variable is needed.
+      // FooTypeCheck(this);
+      // print(this);
+      // print(this);
+      //
+      // But for this example:
+      // Foo a = foo();
+      // print(a);
+      // print(a);
+      //
+      // We need a new variable:
+      // var a = FooTypeCheck(foo());
+      // print(a);
+      // print(a);
+      needsVar = isGenerateAtUseSite(input) && !input.isCodeMotionInvariant();
+    }
+    return needsVar;
+  }
+
   void define(HInstruction instruction) {
-    String name = temporary(instruction);
-    declareVariable(name);
-    buffer.add(" = ");
-    visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    if (needsNewVariable(instruction)) {
+      String name = temporary(instruction);
+      declareVariable(name);
+      buffer.add(" = ");
+      visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
+    } else {
+      visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
+    }
   }
 
   void use(HInstruction argument, int expectedPrecedenceForArgument) {
-    if (isGenerateAtUseSite(argument)) {
+    if (argument is HCheck) {
+      HCheck instruction  = argument;
+      HInstruction input = instruction.checkedInput;
+      if (isGenerateAtUseSite(argument) && isGenerateAtUseSite(input)) {
+        // If both instructions can be generated at use site, we can
+        // just visit [argument].
+        //
+        // For example:
+        // Foo a = foo();
+        // print(a);
+        //
+        // In checked mode will turn into:
+        // print(FooTypeCheck(foo()));
+        visit(argument, expectedPrecedenceForArgument);
+      } else if (isGenerateAtUseSite(input)) {
+        // If [argument] cannot be generated at use site, but [input]
+        // can, use the temporary of [argument]. A code motion
+        // invariant instruction does not have a temporary, so we just
+        // 
+        // For example:
+        // Foo a = foo();
+        // print(a);
+        // print(a);
+        //
+        // In checked mode will turn into:
+        // var a = FooTypeCheck(foo());
+        // print(a);
+        // print(a);
+        //
+        // Note that in case the input is code motion invariant, like
+        // for parameters or this, we just need to visit it, since
+        // there is no temporary for such instruction.
+        if (input.isCodeMotionInvariant()) {
+          visit(input, expectedPrecedenceForArgument);
+        } else {
+          buffer.add(temporary(argument));
+        }
+      } else {
+        // Otherwise we just use [input]. [argument] has already been
+        // emitted, and we just need the temporary of [input].
+        //
+        // For example:
+        // var a = foo();
+        // print(a);
+        // Foo b = a;
+        // print(b);
+        //
+        // In checked mode will turn into:
+        // var a = foo();
+        // print(a);
+        // FooTypeCheck(a);
+        // print(a);
+        use(input, expectedPrecedenceForArgument);
+      }
+    } else if (isGenerateAtUseSite(argument)) {
       visit(argument, expectedPrecedenceForArgument);
-    } else if (argument is HIntegerCheck) {
-      HIntegerCheck instruction = argument;
-      use(instruction.value, expectedPrecedenceForArgument);
-    } else if (argument is HBoundsCheck) {
-      HBoundsCheck instruction = argument;
-      use(instruction.index, expectedPrecedenceForArgument);
-    } else if (argument is HTypeGuard) {
-      HTypeGuard instruction = argument;
-      use(instruction.guarded, expectedPrecedenceForArgument);
     } else {
       buffer.add(temporary(argument));
     }
   }
 
   visit(HInstruction node, int expectedPrecedenceForNode) {
     int oldPrecedence = this.expectedPrecedence;
     this.expectedPrecedence = expectedPrecedenceForNode;
     node.accept(this);
     this.expectedPrecedence = oldPrecedence;
@@ skipping 511 matching lines @@
     }
   }
 
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (instruction != null) {
       if (instruction === node.last) {
         assignPhisOfAllSuccessors(node);
       }
 
-      if (instruction is HGoto || instruction is HExit || instruction is HTry) {
+      if (isGenerateAtUseSite(instruction)) {
+        if (instruction is HIf) {
+          HIf hif = instruction;
+          // The "if" is implementing part of a logical expression.
+          // Skip directly forward to to its latest successor, since everything
+          // in-between must also be generateAtUseSite.
+          assert(hif.trueBranch.id < hif.falseBranch.id);
+          visitBasicBlock(hif.falseBranch);
+        }
+      } else if (instruction is HControlFlow) {
+        if (instruction is HLoopBranch && isGeneratingExpression()) {
+          addExpressionSeparator();
+        }
         visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
-        return;
-      } else if (!isGenerateAtUseSite(instruction)) {
-        if (instruction is !HIf
-            && instruction is !HTypeGuard
-            && instruction is !HLoopBranch
-            && !isGeneratingExpression()) {
+      } else if (instruction is HTypeGuard) {
+        visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
+      } else {
+        if (isGeneratingExpression()) {
+          addExpressionSeparator();
+        } else {
           addIndentation();
         }
-        if (isGeneratingExpression()) {
-          addExpressionSeparator();
-        }
-        if (instruction.usedBy.isEmpty()
-            || instruction is HTypeGuard
-            || instruction is HCheck) {
-          visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
-        } else {
-          define(instruction);
-        }
-        // Control flow instructions, and some other instructions,
-        // know how to handle ';'.
-        if (instruction is !HControlFlow
-            && instruction is !HTypeGuard
-            && !isGeneratingExpression()) {
-          buffer.add(';\n');
-        }
-      } else if (instruction is HIf) {
-        HIf hif = instruction;
-        // The "if" is implementing part of a logical expression.
-        // Skip directly forward to to its latest successor, since everything
-        // in-between must also be generateAtUseSite.
-        assert(hif.trueBranch.id < hif.falseBranch.id);
-        visitBasicBlock(hif.falseBranch);
-        return;
+        define(instruction);
+        if (!isGeneratingExpression()) buffer.add(';\n');
       }
       instruction = instruction.next;
     }
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
     if (node.builtin) {
       JSBinaryOperatorPrecedence operatorPrecedences = JSPrecedence.binary[op];
       beginExpression(operatorPrecedences.precedence);
       use(node.left, operatorPrecedences.left);
@@ skipping 531 matching lines @@
     String operation = logicalOperations[node];
     if (operation !== null) {
       emitLogicalOperation(node, operation);
     } else {
       HPhi canonicalPhi = phiEquivalence.getRepresentative(node);
       buffer.add('${temporary(canonicalPhi)}');
     }
   }
 
   visitReturn(HReturn node) {
+    addIndentation();
     assert(node.inputs.length == 1);
     HInstruction input = node.inputs[0];
     if (input.isConstantNull()) {
       buffer.add('return;\n');
     } else {
       buffer.add('return ');
       use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(';\n');
     }
   }
 
   visitThis(HThis node) {
     buffer.add('this');
   }
 
   visitThrow(HThrow node) {
+    addIndentation();
     if (node.isRethrow) {
       buffer.add('throw ');
       use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
     } else {
       generateThrowWithHelper('captureStackTrace', node.inputs[0]);
     }
     buffer.add(';\n');
   }
 
   visitBoundsCheck(HBoundsCheck node) {
@@ skipping 426 matching lines @@
         } else if (nativeCheck) {
           helper = const SourceString('callTypeCheck');
         } else {
           helper = const SourceString('propertyTypeCheck');
         }
       }
       Element helperElement = compiler.findHelper(helper);
       compiler.registerStaticUse(helperElement);
       buffer.add(compiler.namer.isolateAccess(helperElement));
       buffer.add('(');
-      use(node.inputs[0], JSPrecedence.EXPRESSION_PRECEDENCE);
+      use(node.checkedInput, JSPrecedence.EXPRESSION_PRECEDENCE);
       if (additionalArgument !== null) buffer.add(", '$additionalArgument'");
       buffer.add(')');
       endExpression(JSPrecedence.CALL_PRECEDENCE);
     } else {
-      use(node.inputs[0], expectedPrecedence);
+      visit(node.checkedInput, expectedPrecedence);
     }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   SsaOptimizedCodeGenerator(compiler, work, parameters, parameterNames)
     : super(compiler, work, parameters, parameterNames);
 
   void beginGraph(HGraph graph) {}
   void endGraph(HGraph graph) {}
@@ skipping 388 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }