Make sure all loop-phis are declared.

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 127 matching lines @@
   static final String TEMPORARY_PREFIX = 't';
 
   final Compiler compiler;
   final WorkItem work;
   final StringBuffer buffer;
   final String parameters;
 
   final Map<Element, String> parameterNames;
   final Map<int, String> names;
   final Set<String> usedNames;
+  final Set<HInstruction> declaredInstructions;
   final Map<String, int> prefixes;
   final Set<HInstruction> generateAtUseSite;
   final Map<HPhi, String> logicalOperations;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Equivalence<HPhi> phiEquivalence;
 
   Element equalsNullElement;
   Element boolifiedEqualsNullElement;
   int indent = 0;
@@ skipping 25 matching lines @@
     return generateAtUseSite.contains(instruction);
   }
 
   SsaCodeGenerator(this.compiler,
                    this.work,
                    this.parameters,
                    this.parameterNames)
     : names = new Map<int, String>(),
       prefixes = new Map<String, int>(),
       usedNames = new Set<String>(),
+      declaredInstructions = new Set<HInstruction>(),
       buffer = new StringBuffer(),
       generateAtUseSite = new Set<HInstruction>(),
       logicalOperations = new Map<HPhi, String>(),
       breakAction = new Map<Element, ElementAction>(),
       continueAction = new Map<Element, ElementAction>(),
       phiEquivalence = new Equivalence<HPhi>(),
       unsignedShiftPrecedences = JSPrecedence.binary['>>>'] {
 
     for (final name in parameterNames.getValues()) {
       prefixes[name] = 0;
@@ skipping 239 matching lines @@
     String prefix = TEMPORARY_PREFIX;
     String name = '${prefix}${prefixes[prefix]++}';
     while (usedNames.contains(name)) {
       name = '${prefix}${prefixes[prefix]++}';
     }
     String result = JsNames.getValid(name);
     usedNames.add(result);
     return result;
   }
 
-  bool temporaryExists(HInstruction instruction) {
-    return names.containsKey(instruction.id);
-  }
-
   String newName(int id, String name) {
     String result = JsNames.getValid(name);
     names[id] = result;
     usedNames.add(result);
     return result;
   }
 
   /**
     * Only visits the arguments starting at inputs[HInvoke.ARGUMENTS_OFFSET].
     */
@@ skipping 43 matching lines @@
       buffer.add(variableName);
       if (!isGeneratingDeclaration()) {
         delayedVarDecl = delayedVarDecl.prepend(variableName);
       }
     } else {
       buffer.add("var ");
       buffer.add(variableName);
     }
   }
 
+  void declareInstruction(HInstruction instruction) {
+    declaredInstructions.add(instruction);
+    String name = temporary(instruction);
+    declareVariable(name);
+  }
+
   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:
@@ skipping 15 matching lines @@
       // var a = FooTypeCheck(foo());
       // print(a);
       // print(a);
       needsVar = isGenerateAtUseSite(input) && !input.isCodeMotionInvariant();
     }
     return needsVar;
   }
 
   void define(HInstruction instruction) {
     if (needsNewVariable(instruction)) {
-      String name = temporary(instruction);
-      declareVariable(name);
+      declareInstruction(instruction);
       buffer.add(" = ");
       visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
     } else {
       visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
     }
   }
 
   void use(HInstruction argument, int expectedPrecedenceForArgument) {
     if (argument is HCheck) {
       HCheck instruction  = argument;
@@ skipping 457 matching lines @@
       if (isGeneratingExpression()) {
         addExpressionSeparator();
       } else {
         addIndentation();
       }
       if (temporaryNamesOfPhis !== null &&
           canonicalPhi !== value &&
           temporaryNamesOfPhis.containsKey(canonicalPhi)) {
         // This is the assignment to the temporary.
         declareVariable(temporaryNamesOfPhis[canonicalPhi]);
-      } else if (!temporaryExists(canonicalPhi)) {
-        declareVariable(temporary(canonicalPhi));
+      } else if (!declaredInstructions.contains(canonicalPhi)) {
+        declareInstruction(canonicalPhi);
       } else {
         buffer.add(temporary(canonicalPhi));
       }
       buffer.add(" = ");
       bool isLogicalOperation = logicalOperations.containsKey(canonicalPhi);
       if (isLogicalOperation) {
         emitLogicalOperation(canonicalPhi, logicalOperations[canonicalPhi]);
       } else if (canonicalPhi === value) {
         buffer.add(temporaryNamesOfPhis[value]);
       } else {
@@ skipping 1553 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }