Revert "Fix bug in combination of bounded and exact types." and "Make field final in const class."

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 587 matching lines @@
   final Type type;
   final bool _canBeNull;
 
   bool canBeNull() => _canBeNull;
 
   const HBoundedType(Type this.type, [bool this._canBeNull = false]);
   String toString() => type.toString();
 
   Type computeType(Compiler compiler) => type;
 
-  HType intersection(HType other) {
-    if (other.isNull()) return canBeNull() ? HType.NULL : HType.CONFLICTING;
+  HType combine(HType other) {
     if (other is HBoundedType) {
       HBoundedType temp = other;
       // Return [other] in case it is an exact type.
       if (this.type === temp.type) return other;
     }
     if (other.isUnknown()) return this;
     return HType.CONFLICTING;
   }
 
+  // As long as we don't keep track of super/sub types for non-primitive types
+  // the intersection and union is the same, except when [other] is
+  // null.
+  HType intersection(HType other) {
+    if (other.isNull()) return canBeNull() ? HType.NULL : HType.CONFLICTING;
+    return combine(other);
+  }
+
   HType union(HType other) {
     if (other.isNull()) {
-      return canBeNull() ? this : new HBoundedType(type, true);
+      if (canBeNull()) {
+        return this;
+      } else {
+        return new HBoundedType(type, true);
+      }
     }
-    if (other is HBoundedType) {
-      HBoundedType temp = other;
-      // Return [this] in case [other] is an exact type.
-      if (this.type === temp.type) return this;
-    }
-    if (other.isUnknown()) return this;
-    return HType.CONFLICTING;
+    return combine(other);
   }
 }
 
 class HExactType extends HBoundedType {
   const HExactType(Type type) : super(type);
   bool isExact() => true;
 
   Element lookupMember(SourceString name) {
     ClassElement classElement = type.element;
     return classElement.lookupMember(name);
   }
 
-  HType intersection(HType other) {
-    if (other is HBoundedType) {
-      HBoundedType bounded = other;
-      if (this.type === bounded.type) return this;
+  HType combine(HType other) {
+    if (other.isExact()) {
+      HExactType concrete = other;
+      if (this.type === concrete.type) return this;
     }
-    return super.intersection(other);
+    if (other.isUnknown()) return this;
+    return HType.CONFLICTING;
   }
 
   HType union(HType other) {
-    if (other is HBoundedType) {
-      HBoundedType bounded = other;
-      if (this.type === bounded.type) return other;
-    }
-    return super.union(other);
+    if (other.isNull()) return HType.CONFLICTING;
+    return combine(other);
   }
 }
 
 class HBoundedPotentialPrimitiveType extends HBoundedType {
   const HBoundedPotentialPrimitiveType(Type type, bool canBeNull)
       : super(type, canBeNull);
   bool canBePrimitive() => true;
 }
 
 class HBoundedPotentialPrimitiveArray extends HBoundedPotentialPrimitiveType {
@@ skipping 51 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);
   }
 }