Fix usage of UNKNOWN/CONFLICTING types for union.

lib/compiler/implementation/ssa/types.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.
 
 abstract class HType {
   const HType();
 
   /**
    * Returns an [HType] that represents [type] and all types that have
    * [type] as supertype.
@@ skipping 23 matching lines @@
       return new HBoundedPotentialPrimitiveArray(type, canBeNull);
     } else if (Elements.isStringSupertype(element, compiler)) {
       return new HBoundedPotentialPrimitiveString(type, canBeNull);
     } else {
       return canBeNull ? new HBoundedType.withNull(type)
                        : new HBoundedType.nonNull(type);
     }
   }
 
   static final HType CONFLICTING = const HConflictingType();
-  static final HType UNKNOWN = const HAnalysisType("unknown");
+  static final HType UNKNOWN = const HUnknownType();
   static final HType BOOLEAN = const HBooleanType();
   static final HType NUMBER = const HNumberType();
   static final HType INTEGER = const HIntegerType();
   static final HType DOUBLE = const HDoubleType();
   static final HType INDEXABLE_PRIMITIVE = const HIndexablePrimitiveType();
   static final HType STRING = const HStringType();
   static final HType READABLE_ARRAY = const HReadableArrayType();
   static final HType MUTABLE_ARRAY = const HMutableArrayType();
   static final HType EXTENDABLE_ARRAY = const HExtendableArrayType();
   static final HType NULL = const HNullType();
@@ skipping 49 matching lines @@
    */
   abstract HType intersection(HType other);
 
   /**
    * The union of two types is the union of its values. For example:
    *   * INTEGER.union(NUMBER) => NUMBER.
    *   * DOUBLE.union(INTEGER) => NUMBER.
    *   * MUTABLE_ARRAY.union(READABLE_ARRAY) => READABLE_ARRAY.
    *
    * When there is no predefined type to represent the union returns
-   * [CONFLICTING].
+   * [UNKNOWN].
    *
-   * A union with [UNKNOWN] returns the non-UNKNOWN type. A union with
-   * [CONFLICTING] returns [CONFLICTING].
+   * A union with [UNKNOWN] returns [UNKNOWN].
+   * A union of [CONFLICTING] with any other types returns the other type.

[sra1, 2012/07/11 20:04:34]

I find CONFLICTING to be a confusing name.
The element is really the bottom element of a bounded lattice, which represents
the empty set of values.  For there to be a 'conflict' two things have to be in
opposition.  In a 0-1-many analysis, two is 'many', making it feel like
CONFLICTING is the top element, i.e. the same as UNKNOWN.
I suspect the bugs fixed in this change are due to that confusion.

I suggest renaming CONFLICTING to NOTHING, EMPTY, BOTTOM, NO_VALUES or something
similar.

If you choose BOTTOM, for consistency also change UNKNOWN to TOP.

    */
   abstract HType union(HType other);
 }
 
 /** Used to represent [HType.UNKNOWN] and [HType.CONFLICTING]. */
-class HAnalysisType extends HType {
+abstract class HAnalysisType extends HType {
   final String name;
   const HAnalysisType(this.name);
   String toString() => name;
+
+  Type computeType(Compiler compiler) => null;
+}
+
+class HUnknownType extends HAnalysisType {
+  const HUnknownType() : super("unknown");
   bool canBePrimitive() => true;
   bool canBeNull() => true;
 
-  Type computeType(Compiler compiler) => null;
-
-  HType combine(HType other) {
-    if (isUnknown()) return other;
-    if (other.isUnknown()) return this;
-    return HType.CONFLICTING;
-  }
-
-  HType union(HType other) => combine(other);
-  HType intersection(HType other) => combine(other);
+  HType union(HType other) => this;
+  HType intersection(HType other) => other;
 }
 
 class HConflictingType extends HAnalysisType {
   const HConflictingType() : super("conflicting");
   bool canBePrimitive() => false;
   bool canBeNull() => false;
+
+  HType union(HType other) => other;
+  HType intersection(HType other) => this;
 }
 
 abstract class HPrimitiveType extends HType {
   const HPrimitiveType();
   bool isPrimitive() => true;
   bool canBePrimitive() => true;
 }
 
 class HNullType extends HPrimitiveType {
   const HNullType();
   bool canBeNull() => true;
   bool isNull() => true;
   String toString() => 'null';
 
   Type computeType(Compiler compiler) => null;
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.NULL;
+    if (other.isConflicting()) return HType.NULL;
+    if (other.isUnknown()) return HType.UNKNOWN;

[sra1, 2012/07/11 20:04:34]

Every union method needs to accomplish the bounded lattice axioms

   this union CONFLICTING => this
   this union this => this
   this union UNKNOWN => UNKNOWN

Would it make sense for the base class to have a union method that does these
tests and calls _union only when the types don't match the axioms?

     if (other.isString()) return HType.STRING_OR_NULL;
     if (other.isInteger()) return HType.INTEGER_OR_NULL;
     if (other.isDouble()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isBoolean()) return HType.BOOLEAN_OR_NULL;
-    if (!other.canBeNull()) return HType.CONFLICTING;
+    if (!other.canBeNull()) return HType.UNKNOWN;

[sra1, 2012/07/11 20:04:34]

This is too pessimistic.  HBoundedType should become nullable.

     return other;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.NULL;
     if (other.isConflicting()) return HType.CONFLICTING;
     if (!other.canBeNull()) return HType.CONFLICTING;
     return HType.NULL;
   }
 }
 
 abstract class HPrimitiveOrNullType extends HType {
   const HPrimitiveOrNullType();
   bool canBePrimitive() => true;
   bool canBeNull() => true;
 }
 
 class HBooleanOrNullType extends HPrimitiveOrNullType {
   const HBooleanOrNullType();
   String toString() => "boolean or null";
   bool isBooleanOrNull() => true;
 
   Type computeType(Compiler compiler) {
     return compiler.boolClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.BOOLEAN_OR_NULL;
+    if (other.isConflicting()) return HType.BOOLEAN_OR_NULL;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isBooleanOrNull()) return HType.BOOLEAN_OR_NULL;
     if (other.isBoolean()) return HType.BOOLEAN_OR_NULL;
     if (other.isNull()) return HType.BOOLEAN_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.BOOLEAN_OR_NULL;
     if (other.isBooleanOrNull()) return HType.BOOLEAN_OR_NULL;
     if (other.isBoolean()) return HType.BOOLEAN;
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HBooleanType extends HPrimitiveType {
   const HBooleanType();
   bool isBoolean() => true;
   String toString() => "boolean";
 
   Type computeType(Compiler compiler) {
     return compiler.boolClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.BOOLEAN;
+    if (other.isConflicting()) return HType.BOOLEAN;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isBoolean()) return HType.BOOLEAN;
     if (other.isBooleanOrNull()) return HType.BOOLEAN_OR_NULL;
     if (other.isNull()) return HType.BOOLEAN_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.BOOLEAN;
     if (other.isBooleanOrNull()) return HType.BOOLEAN;
     if (other.isBoolean()) return HType.BOOLEAN;
     return HType.CONFLICTING;
   }
 }
 
 class HNumberOrNullType extends HPrimitiveOrNullType {
   const HNumberOrNullType();
   bool isNumberOrNull() => true;
   String toString() => "number or null";
 
   Type computeType(Compiler compiler) {
     return compiler.numClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.NUMBER_OR_NULL;
+    if (other.isConflicting()) return HType.NUMBER_OR_NULL;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.NUMBER_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.NUMBER_OR_NULL;
     if (other.isInteger()) return HType.INTEGER;
     if (other.isDouble()) return HType.DOUBLE;
     if (other.isNumber()) return HType.NUMBER;
     if (other.isIntegerOrNull()) return HType.INTEGER_OR_NULL;
     if (other.isDoubleOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HNumberType extends HPrimitiveType {
   const HNumberType();
   bool isNumber() => true;
   String toString() => "number";
 
   Type computeType(Compiler compiler) {
     return compiler.numClass.computeType(compiler);
   }
 
   HType union(HType other) {
+    if (other.isConflicting()) return HType.NUMBER;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isNumber()) return HType.NUMBER;
-    if (other.isUnknown()) return HType.NUMBER;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.NUMBER_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.NUMBER;
     if (other.isNumber()) return other;
     if (other.isIntegerOrNull()) return HType.INTEGER;
     if (other.isDoubleOrNull()) return HType.DOUBLE;
     if (other.isNumberOrNull()) return HType.NUMBER;
     return HType.CONFLICTING;
   }
 }
 
 class HIntegerOrNullType extends HNumberOrNullType {
   const HIntegerOrNullType();
   bool isIntegerOrNull() => true;
   String toString() => "integer or null";
 
   Type computeType(Compiler compiler) {
     return compiler.intClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.INTEGER_OR_NULL;
+    if (other.isConflicting()) return HType.INTEGER_OR_NULL;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isIntegerOrNull()) return HType.INTEGER_OR_NULL;
     if (other.isInteger()) return HType.INTEGER_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.INTEGER_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.INTEGER_OR_NULL;
     if (other.isIntegerOrNull()) return HType.INTEGER_OR_NULL;
     if (other.isInteger()) return HType.INTEGER;
     if (other.isDouble()) return HType.CONFLICTING;
     if (other.isDoubleOrNull()) return HType.NULL;
     if (other.isNumber()) return HType.INTEGER;
     if (other.isNumberOrNull()) return HType.INTEGER_OR_NULL;
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HIntegerType extends HNumberType {
   const HIntegerType();
   bool isInteger() => true;
   String toString() => "integer";
 
   Type computeType(Compiler compiler) {
     return compiler.intClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.INTEGER;
+    if (other.isConflicting()) return HType.INTEGER;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isInteger()) return HType.INTEGER;
     if (other.isIntegerOrNull()) return HType.INTEGER_OR_NULL;
     if (other.isNumber()) return HType.NUMBER;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.INTEGER_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.INTEGER;
     if (other.isIntegerOrNull()) return HType.INTEGER;
     if (other.isInteger()) return HType.INTEGER;
     if (other.isDouble()) return HType.CONFLICTING;
     if (other.isDoubleOrNull()) return HType.CONFLICTING;
     if (other.isNumber()) return HType.INTEGER;
     if (other.isNumberOrNull()) return HType.INTEGER;
     return HType.CONFLICTING;
   }
 }
 
 class HDoubleOrNullType extends HNumberOrNullType {
   const HDoubleOrNullType();
   bool isDoubleOrNull() => true;
   String toString() => "double or null";
 
   Type computeType(Compiler compiler) {
     return compiler.doubleClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.DOUBLE_OR_NULL;
+    if (other.isConflicting()) return HType.DOUBLE_OR_NULL;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isDoubleOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.isDouble()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.NUMBER_OR_NULL;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.DOUBLE_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.DOUBLE_OR_NULL;
     if (other.isIntegerOrNull()) return HType.NULL;
     if (other.isInteger()) return HType.CONFLICTING;
     if (other.isDouble()) return HType.DOUBLE;
     if (other.isDoubleOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.DOUBLE;
     if (other.isNumberOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HDoubleType extends HNumberType {
   const HDoubleType();
   bool isDouble() => true;
   String toString() => "double";
 
   Type computeType(Compiler compiler) {
     return compiler.doubleClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.DOUBLE;
+    if (other.isConflicting()) return HType.DOUBLE;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isDouble()) return HType.DOUBLE;
     if (other.isDoubleOrNull()) return HType.DOUBLE_OR_NULL;
     if (other.isNumber()) return HType.NUMBER;
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.DOUBLE_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.DOUBLE;
     if (other.isIntegerOrNull()) return HType.CONFLICTING;
     if (other.isInteger()) return HType.CONFLICTING;
     if (other.isDouble()) return HType.DOUBLE;
     if (other.isDoubleOrNull()) return HType.DOUBLE;
     if (other.isNumber()) return HType.DOUBLE;
     if (other.isNumberOrNull()) return HType.DOUBLE;
     return HType.CONFLICTING;
   }
 }
 
 class HIndexablePrimitiveType extends HPrimitiveType {
   const HIndexablePrimitiveType();
   bool isIndexablePrimitive() => true;
   String toString() => "indexable";
 
   Type computeType(Compiler compiler) {
     // TODO(ngeoffray): Represent union types.
     return null;
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.INDEXABLE_PRIMITIVE;
+    if (other.isConflicting()) return HType.INDEXABLE_PRIMITIVE;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveString) {
       // TODO(ngeoffray): Represent union types.
-      return HType.CONFLICTING;
+      return HType.UNKNOWN;
     }
     if (other is HBoundedPotentialPrimitiveArray) {
       // TODO(ngeoffray): Represent union types.
-      return HType.CONFLICTING;
+      return HType.UNKNOWN;
     }
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.INDEXABLE_PRIMITIVE;
     if (other.isIndexablePrimitive()) return other;
     if (other is HBoundedPotentialPrimitiveString) return HType.STRING;
     if (other is HBoundedPotentialPrimitiveArray) return HType.READABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HStringOrNullType extends HPrimitiveOrNullType {
   const HStringOrNullType();
   bool isStringOrNull() => true;
   String toString() => "String or null";
 
   Type computeType(Compiler compiler) {
     return compiler.stringClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.STRING_OR_NULL;
+    if (other.isConflicting()) return HType.STRING_OR_NULL;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isString()) return HType.STRING_OR_NULL;
     if (other.isStringOrNull()) return HType.STRING_OR_NULL;
     if (other.isIndexablePrimitive()) {
       // We don't have a type that represents the nullable indexable
       // primitive.
-      return HType.CONFLICTING;
+      return HType.UNKNOWN;
     }
     if (other is HBoundedPotentialPrimitiveString) {
       if (other.canBeNull()) {
         return other;
       } else {
         HBoundedType boundedType = other;
         return new HBoundedPotentialPrimitiveString(boundedType.type, true);
       }
     }
     if (other.isNull()) return HType.STRING_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.STRING_OR_NULL;
     if (other.isString()) return HType.STRING;
     if (other.isStringOrNull()) return HType.STRING_OR_NULL;
     if (other.isArray()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.STRING;
     if (other is HBoundedPotentialPrimitiveString) {
       return other.canBeNull() ? HType.STRING_OR_NULL : HType.STRING;
     }
     if (other.canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 }
 
 class HStringType extends HIndexablePrimitiveType {
   const HStringType();
   bool isString() => true;
   String toString() => "String";
 
   Type computeType(Compiler compiler) {
     return compiler.stringClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.STRING;
+    if (other.isConflicting()) return HType.STRING;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isString()) return HType.STRING;
     if (other.isStringOrNull()) return HType.STRING_OR_NULL;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveString) return other;
     if (other.isNull()) return HType.STRING_OR_NULL;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.STRING;
     if (other.isString()) return HType.STRING;
     if (other.isArray()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.STRING;
     if (other.isStringOrNull()) return HType.STRING;
     if (other is HBoundedPotentialPrimitiveString) return HType.STRING;
     return HType.CONFLICTING;
   }
 }
 
 class HReadableArrayType extends HIndexablePrimitiveType {
   const HReadableArrayType();
   bool isReadableArray() => true;
   String toString() => "readable array";
 
   Type computeType(Compiler compiler) {
     return compiler.listClass.computeType(compiler);
   }
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.READABLE_ARRAY;
+    if (other.isConflicting()) return HType.READABLE_ARRAY;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isReadableArray()) return HType.READABLE_ARRAY;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveArray) return other;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.READABLE_ARRAY;
     if (other.isString()) return HType.CONFLICTING;
     if (other.isReadableArray()) return other;
     if (other.isIndexablePrimitive()) return HType.READABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.READABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HMutableArrayType extends HReadableArrayType {
   const HMutableArrayType();
   bool isMutableArray() => true;
   String toString() => "mutable array";
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.MUTABLE_ARRAY;
+    if (other.isConflicting()) return HType.MUTABLE_ARRAY;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isMutableArray()) return HType.MUTABLE_ARRAY;
     if (other.isReadableArray()) return HType.READABLE_ARRAY;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveArray) return other;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.MUTABLE_ARRAY;
     if (other.isMutableArray()) return other;
     if (other.isString()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.MUTABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.MUTABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HExtendableArrayType extends HMutableArrayType {
   const HExtendableArrayType();
   bool isExtendableArray() => true;
   String toString() => "extendable array";
 
   HType union(HType other) {
-    if (other.isUnknown()) return HType.EXTENDABLE_ARRAY;
+    if (other.isConflicting()) return HType.EXTENDABLE_ARRAY;
+    if (other.isUnknown()) return HType.UNKNOWN;
     if (other.isExtendableArray()) return HType.EXTENDABLE_ARRAY;
     if (other.isMutableArray()) return HType.MUTABLE_ARRAY;
     if (other.isReadableArray()) return HType.READABLE_ARRAY;
     if (other.isIndexablePrimitive()) return HType.INDEXABLE_PRIMITIVE;
     if (other is HBoundedPotentialPrimitiveArray) return other;
-    return HType.CONFLICTING;
+    return HType.UNKNOWN;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.EXTENDABLE_ARRAY;
     if (other.isExtendableArray()) return HType.EXTENDABLE_ARRAY;
     if (other.isString()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.EXTENDABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.EXTENDABLE_ARRAY;
     return HType.CONFLICTING;
   }
@@ skipping 59 matching lines @@
   HType union(HType other) {
     if (other.isNull()) {
       if (canBeNull()) {
         return this;
       } else {
         return new HBoundedType.withNull(type);
       }
     }
     if (other is HBoundedType) {
       HBoundedType temp = other;
-      if (type !== temp.type) return HType.CONFLICTING;
+      if (type !== temp.type) return HType.UNKNOWN;
       if (isExact()) return other;
       if (other.isExact()) return this;
       return canBeNull() ? this : other;
     }
-    if (other.isUnknown()) return this;
-    return HType.CONFLICTING;
+    if (other.isConflicting()) return this;
+    return HType.UNKNOWN;
   }
 }
 
 class HBoundedPotentialPrimitiveType extends HBoundedType {
   const HBoundedPotentialPrimitiveType(Type type, bool canBeNull)
       : super(type, canBeNull, false);
   bool canBePrimitive() => true;
 }
 
 class HBoundedPotentialPrimitiveArray extends HBoundedPotentialPrimitiveType {
   const HBoundedPotentialPrimitiveArray(Type type, bool canBeNull)
       : super(type, canBeNull);
 
   HType union(HType other) {
-    if (other.isString()) return HType.CONFLICTING;
+    if (other.isString()) return HType.UNKNOWN;
     if (other.isReadableArray()) return this;
     // TODO(ngeoffray): implement union types.
-    if (other.isIndexablePrimitive()) return HType.CONFLICTING;
+    if (other.isIndexablePrimitive()) return HType.UNKNOWN;
     if (other.isNull()) {
       if (canBeNull()) {
         return this;
       } else {
         return new HBoundedPotentialPrimitiveArray(type, true);
       }
     }
     return super.union(other);
   }
 
@@ skipping 19 matching lines @@
       }
     }
     if (other.isNull()) {
       if (canBeNull()) {
         return this;
       } else {
         return new HBoundedPotentialPrimitiveString(type, true);
       }
     }
     // TODO(ngeoffray): implement union types.
-    if (other.isIndexablePrimitive()) return HType.CONFLICTING;
+    if (other.isIndexablePrimitive()) return HType.UNKNOWN;
     return super.union(other);
   }
 
   HType intersection(HType other) {
     if (other.isString()) return HType.STRING;
     if (other.isStringOrNull()) {
       return canBeNull() ? HType.STRING_OR_NULL : HType.STRING;
     }
     if (other.isReadableArray()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.STRING;
     return super.intersection(other);
   }
 }