Merge functionality of HExactType into HBoundedType and fix computation of unions and intersections.

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 17 matching lines @@
     } else if (element === compiler.stringClass) {
       return canBeNull ? HType.STRING_OR_NULL : HType.STRING;
     } else if (element === compiler.boolClass) {
       return canBeNull ? HType.BOOLEAN_OR_NULL : HType.BOOLEAN;
     } else if (element === compiler.listClass
         || Elements.isListSupertype(element, compiler)) {
       return new HBoundedPotentialPrimitiveArray(type, canBeNull);
     } else if (Elements.isStringSupertype(element, compiler)) {
       return new HBoundedPotentialPrimitiveString(type, canBeNull);
     } else {
-      return new HBoundedType(type, canBeNull);
+      return canBeNull ? new HBoundedType.canBeNull(type)
+                       : new HBoundedType.nonNull(type);
     }
   }
 
   static final HType CONFLICTING = const HAnalysisType("conflicting");
   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();
@@ skipping 541 matching lines @@
     if (other.isString()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.EXTENDABLE_ARRAY;
     if (other is HBoundedPotentialPrimitiveArray) return HType.EXTENDABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HBoundedType extends HType {
   final Type type;
   final bool _canBeNull;
+  final bool _isExact;

[ngeoffray, 2012/05/29 12:16:21]

I think I'd prefer having a HExactType extends HType instead of that boolean.
But that may complicate intersection/union. So I'm fine keeping it like you
wrote it.

[karlklose, 2012/05/29 13:25:16]

The complicated code for the union/intersection was the reason to merge both
classes.

+
+  toString() {
+    return 'BoundedType($type, $_canBeNull, $_isExact)';
+  }
 
   bool canBeNull() => _canBeNull;
 
-  const HBoundedType(Type this.type, [bool this._canBeNull = false]);
-  String toString() => type.toString();
+  bool isExact() => _isExact;
+
+  const HBoundedType(Type this.type, bool this._canBeNull, this._isExact);

[ngeoffray, 2012/05/29 12:16:21]

Maybe use named arguments here and at the call site, to make it obvious what
these sequences of [true, false] mean.

[karlklose, 2012/05/29 13:25:16]

Done.

+  const HBoundedType.exact(Type type) : this(type, false, true);
+  const HBoundedType.canBeNull(Type type) : this(type, true, false);

[ngeoffray, 2012/05/29 12:16:21]

canBeNull -> withNull?

[karlklose, 2012/05/29 13:25:16]

Done.

+  const HBoundedType.nonNull(Type type) : this(type, false, false);
 
   Type computeType(Compiler compiler) => type;
 
-  HType combine(HType other) {
+  Element lookupMember(SourceString name) {
+    if (!isExact()) return null;
+    ClassElement classElement = type.element;
+    return classElement.lookupMember(name);
+  }
+
+  HType intersection(HType other) {
+    assert(!(isExact() && canBeNull()));
+    if (other.isNull()) return canBeNull() ? HType.NULL : HType.CONFLICTING;
     if (other is HBoundedType) {
       HBoundedType temp = other;
-      // Return [other] in case it is an exact type.
-      if (this.type === temp.type) return other;
+      if (this.type === temp.type) {
+        if (isExact()) {
+          return this;
+        } 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;
     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);
+  bool operator ==(HType other) {
+    if (other is !HBoundedType) return false;
+    HBoundedType bounded = other;
+    return (type === bounded.type && canBeNull() === bounded.canBeNull()
+            && isExact() === other .isExact());
   }
 
   HType union(HType other) {
     if (other.isNull()) {
       if (canBeNull()) {
         return this;
       } else {
-        return new HBoundedType(type, true);
+        return new HBoundedType.canBeNull(type);
       }
     }
-    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 combine(HType other) {
-    if (other.isExact()) {
-      HExactType concrete = other;
-      if (this.type === concrete.type) return this;
+    if (other is HBoundedType) {
+      HBoundedType temp = other;
+      if (type !== temp.type) return HType.CONFLICTING;
+      if (isExact()) return other;
+      if (other.isExact()) return this;
+      return canBeNull() ? this : other;
     }
     if (other.isUnknown()) return this;
     return HType.CONFLICTING;
   }
-
-  HType union(HType other) {
-    if (other.isNull()) return HType.CONFLICTING;
-    return combine(other);
-  }
 }
 
 class HBoundedPotentialPrimitiveType extends HBoundedType {
   const HBoundedPotentialPrimitiveType(Type type, bool canBeNull)
-      : super(type, 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.isReadableArray()) return this;
@@ skipping 45 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);
   }
 }