Fix usage of UNKNOWN/CONFLICTING types for union.

lib/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
@@ skipping 1157 matching lines @@
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   void visitFieldGet(HFieldGet node) {
     if (!node.element.enclosingElement.isClass()) return;
     Element field = node.element;
     HType type = backend.optimisticFieldTypeAfterConstruction(field);
-    switch (compiler.phase) {
-      case Compiler.PHASE_COMPILING:
-        if (!type.isConflicting()) {
+    if (!type.isConflicting() && !type.isUnknown()) {

[Mads Ager (google), 2012/07/11 10:24:34]

I think we can relax this check but I will look into that once you submit this.

+      switch (compiler.phase) {
+        case Compiler.PHASE_COMPILING:
           compiler.enqueuer.codegen.registerRecompilationCandidate(
               work.element);
-        }
-        break;
-      case Compiler.PHASE_RECOMPILING:
-        if (!type.isConflicting() && !type.isUnknown()) {
+          break;
+        case Compiler.PHASE_RECOMPILING:
           // Check if optimistic type is based on a setter in the constructor
           // body.
           if (backend.hasConstructorBodyFieldSetter(field)) {
             // There is at least one field setter from the constructor.
             if (!compiler.codegenWorld.hasInvokedSetter(field, compiler)) {
               node.guaranteedType =
                   type.union(backend.fieldSettersTypeSoFar(node.element));
             } else {
               node.propagatedType =
                   type.union(backend.fieldSettersTypeSoFar(node.element));
             }
           } else {
             // Optimistic type is based on field initializer list.
             if (!compiler.codegenWorld.hasFieldSetter(field, compiler) &&
                 !compiler.codegenWorld.hasInvokedSetter(field, compiler)) {
               node.guaranteedType = type;
             } else {
               node.propagatedType = type;
             }
           }
-        }
-        break;
+          break;
+      }
     }
   }
 
   HInstruction visitEquals(HEquals node) {
     // Determine if one of the operands is an HFieldGet.
     HFieldGet field;
     HInstruction other;
     if (node.left is HFieldGet) {
       field = node.left;
       other = node.right;
     } else if (node.right is HFieldGet) {
       field = node.right;
       other = node.left;
     }
     // Try to optimize the case where a field which is known to always be an
     // integer is compared with a constant integer literal.
     if (other != null &&
-        other is HConstant &&
-        other.isInteger() &&
+        other.isConstantInteger() &&
         field.element != null &&
         field.element.enclosingElement.isClass()) {
       // Calculate the field type from the information available.
       HType type =
           backend.fieldSettersTypeSoFar(field.element).union(
               backend.typeFromInitializersSoFar(field.element));
-      if (!type.isConflicting()) {
+      if (!type.isUnknown()) {
         switch (compiler.phase) {
           case Compiler.PHASE_COMPILING:
             compiler.enqueuer.codegen.registerRecompilationCandidate(
                 work.element);
             break;
           case Compiler.PHASE_RECOMPILING:
             if (compiler.codegenWorld.hasInvokedSetter(field.element,
                                                        compiler)) {
               // If there are invoked setters we don't know for sure that the
               // field will hold the calculated, but the fact that the class
@@ skipping 22 matching lines @@
     if (node.left is HFieldGet) {
       field = node.left;
       other = node.right;
     } else if (node.right is HFieldGet) {
       field = node.right;
       other = node.left;
     }
     // Check that the other operand is a number and that we have type
     // information for the field get.
     if (other != null &&
-        other is HConstant &&
-        other.isNumber() &&
+        other.isConstantNumber() &&
         field.element != null &&
         field.element.enclosingElement.isClass()) {
       // If we have type information for the field and it contains
       // NUMBER, we mark for recompilation.
       Element fieldElement = field.element;
       HType fieldSettersType = backend.fieldSettersTypeSoFar(fieldElement);
       HType initializersType = backend.typeFromInitializersSoFar(fieldElement);
       HType fieldType = fieldSettersType.union(initializersType);
       HType type = HType.NUMBER.union(fieldType);
-      if (!type.isConflicting()) {
+      if (type == HType.NUMBER) {
         switch (compiler.phase) {
           case Compiler.PHASE_COMPILING:
             compiler.enqueuer.codegen.registerRecompilationCandidate(
                 work.element);
             break;
           case Compiler.PHASE_RECOMPILING:
             if (compiler.codegenWorld.hasInvokedSetter(fieldElement,
                                                        compiler)) {
               // If there are invoked setters we don't know for sure
               // that the field will hold a value of the calculated
               // type, but the fact that the class itself sticks to
               // this type for the field is still a strong signal
               // indicating the expected type of the field.
               field.propagatedType = type;
               graph.highTypeLikelyhood = true;
             } else {
               // If there are no invoked setters we know the type of
               // this field for sure.
               field.guaranteedType = type;
             }
             break;
           default:
             assert(false);
             break;
         }
       }
     }
   }
 }