Reapply change to update dart2js operator equals semantics to follow

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 181 matching lines @@
     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;
   }
 
   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.isNull()) return HType.NULL;
+    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) {
@@ skipping 34 matching lines @@
   }
 
   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.isNull()) return HType.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) {
@@ skipping 38 matching lines @@
   }
 
   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.isNumber()) return HType.INTEGER;
     if (other.isNumberOrNull()) return HType.INTEGER_OR_NULL;
-    if (other.isNull()) return HType.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) {
@@ skipping 42 matching lines @@
   }
 
   HType intersection(HType other) {
     if (other.isUnknown()) return HType.DOUBLE_OR_NULL;
     if (other.isIntegerOrNull()) return HType.CONFLICTING;
     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.isNull()) return HType.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) {
@@ skipping 87 matching lines @@
 
   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.isNull()) return HType.NULL;
+    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) {
@@ skipping 126 matching lines @@
   }
 
   HType intersection(HType other) {
     assert(!(isExact() && canBeNull()));
     if (other.isNull()) return canBeNull() ? HType.NULL : HType.CONFLICTING;
     if (other is HBoundedType) {
       HBoundedType temp = other;
       if (this.type === temp.type) {
         if (isExact()) {
           return this;
-        } else if (other.isExact()){
+        } else if (other.isExact()) {
           return other;
         } else if (canBeNull()) {
           return other;
         } else {
           return this;
         }
-      } else if (canBeNull() && other.canBeNull()) {
-        return HType.NULL;
       }
     }
     if (other.isUnknown()) return this;
+    if (other.canBeNull() && canBeNull()) return HType.NULL;
     return HType.CONFLICTING;
   }
 
   bool operator ==(HType other) {
     if (other is !HBoundedType) return false;
     HBoundedType bounded = other;
     return (type === bounded.type && canBeNull() === bounded.canBeNull()
             && isExact() === other .isExact());
   }
 
@@ skipping 78 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);
   }
 }