Fix usage of UNKNOWN/CONFLICTING types for union.

lib/compiler/implementation/ssa/nodes.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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 1294 matching lines @@
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   void prepareGvn() {
     setUseGvn();
     if (!isFinalOrConst) setDependsOnSomething();
   }
 
   int typeCode() => 27;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
+  String toString() => "FieldGet $element.name";
 }
 
 class HFieldSet extends HFieldAccess {
   HFieldSet(Element element, HInstruction receiver, HInstruction value)
       : super(element, <HInstruction>[receiver, value]);
 
   HInstruction get receiver() => inputs[0];
   HInstruction get value() => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   void prepareGvn() {
     // TODO(ngeoffray): implement more fine grained side effects.
     setAllSideEffects();
   }
 
   final bool isStatement = true;
+  String toString() => "FieldSet $element.name";
 }
 
 class HLocalGet extends HFieldGet {
   HLocalGet(Element element, HLocalValue local) : super(element, local);
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local() => inputs[0];
 
   void prepareGvn() {
@@ skipping 581 matching lines @@
   void addInput(HInstruction input) {
     assert(isInBasicBlock());
     inputs.add(input);
     input.usedBy.add(this);
   }
 
   // Compute the (shared) type of the inputs if any. If all inputs
   // have the same known type return it. If any two inputs have
   // different known types, we'll return a conflict -- otherwise we'll
   // simply return an unknown type.
-  HType computeInputsType(bool unknownWins) {
-    HType candidateType = inputs[0].propagatedType;
-    bool seenUnknown = candidateType.isUnknown();
-    for (int i = 1, length = inputs.length; i < length; i++) {
+  HType computeInputsType(bool ignoreUnknowns) {
+    HType candidateType = HType.CONFLICTING;
+    for (int i = 0, length = inputs.length; i < length; i++) {
       HType inputType = inputs[i].propagatedType;
-      if (inputType.isUnknown()) {
-        seenUnknown = true;
-      } else {
-        // Phis need to combine the incoming types using the union operation.
-        // For example, if one incoming edge has type integer and the other has
-        // type double, then the phi is either an integer or double and thus has
-        // type number.
-        candidateType = candidateType.union(inputType);
-        if (candidateType.isConflicting()) return HType.CONFLICTING;
-      }
+      if (ignoreUnknowns && inputType.isUnknown()) continue;
+      // Phis need to combine the incoming types using the union operation.
+      // For example, if one incoming edge has type integer and the other has
+      // type double, then the phi is either an integer or double and thus has
+      // type number.
+      candidateType = candidateType.union(inputType);
+      if (candidateType.isUnknown()) return HType.UNKNOWN;
     }
-    if (seenUnknown && unknownWins) return HType.UNKNOWN;
     return candidateType;
   }
 
   HType computeTypeFromInputTypes() {
-    HType inputsType = computeInputsType(true);
+    HType inputsType = computeInputsType(false);
     if (inputsType.isConflicting()) return HType.UNKNOWN;
     return inputsType;
   }
 
   HType computeDesiredTypeForInput(HInstruction input) {
     // Best case scenario for a phi is, when all inputs have the same type. If
     // there is no desired outgoing type we therefore try to unify the input
     // types (which is basically the [likelyType]).
     if (propagatedType.isUnknown()) return likelyType;
     // When the desired outgoing type is conflicting we don't need to give any
     // requirements on the inputs.
     if (propagatedType.isConflicting()) return HType.UNKNOWN;
     // Otherwise the input type must match the desired outgoing type.
     return propagatedType;
   }
 
   HType get likelyType() {
-    HType agreedType = computeInputsType(false);
+    HType agreedType = computeInputsType(true);
     if (agreedType.isConflicting()) return HType.UNKNOWN;
     // Don't be too restrictive. If the agreed type is integer or double just
     // say that the likely type is number. If more is expected the type will be
     // propagated back.
     if (agreedType.isNumber()) return HType.NUMBER;
     return agreedType;
   }
 
   bool isLogicalOperator() => logicalOperatorType != IS_NOT_LOGICAL_OPERATOR;
 
@@ skipping 682 matching lines @@
   HBasicBlock get start() => expression.start;
   HBasicBlock get end() {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }