Fix more type intersection stuff.

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 22 matching lines @@
         || Elements.isListSupertype(element, compiler)) {
       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 HAnalysisType("conflicting");
+  static final HType CONFLICTING = const HConflictingType();
   static final HType UNKNOWN = const HAnalysisType("unknown");
   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();
@@ skipping 78 matching lines @@
   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);
 }
 
+class HConflictingType extends HAnalysisType {
+  const HConflictingType() : super("conflicting");
+  bool canBePrimitive() => false;
+  bool canBeNull() => false;
+}
+
 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;
@@ skipping 151 matching lines @@
     if (other.isNumberOrNull()) return HType.NUMBER_OR_NULL;
     if (other.isNull()) return HType.INTEGER_OR_NULL;
     return HType.CONFLICTING;
   }
 
   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.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;
@@ skipping 39 matching lines @@
     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;
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.DOUBLE_OR_NULL;
-    if (other.isIntegerOrNull()) return HType.CONFLICTING;
+    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;
   }
 }
 
@@ skipping 349 matching lines @@
   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);
   }
 }