num implements Comparable and Hashable.

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 14 matching lines @@
       return canBeNull ? HType.NUMBER_OR_NULL : HType.NUMBER;
     } else if (element === compiler.doubleClass) {
       return canBeNull ? HType.DOUBLE_OR_NULL : HType.DOUBLE;
     } 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)) {
+    } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
+      return new HBoundedPotentialPrimitiveNumberOrString(type, canBeNull);
+    } else if (Elements.isStringOnlySupertype(element, compiler)) {
       return new HBoundedPotentialPrimitiveString(type, canBeNull);
     } else {
       return canBeNull ? new HBoundedType.withNull(type)
                        : new HBoundedType.nonNull(type);
     }
   }
 
   static const HType CONFLICTING = const HConflictingType();
   static const HType UNKNOWN = const HUnknownType();
   static const HType BOOLEAN = const HBooleanType();
@@ skipping 650 matching lines @@
     return HType.UNKNOWN;
   }
 }
 
 class HBoundedPotentialPrimitiveType extends HBoundedType {
   const HBoundedPotentialPrimitiveType(DartType type, bool canBeNull)
       : super(type, canBeNull, false);
   bool canBePrimitive() => true;
 }
 
+class HBoundedPotentialPrimitiveNumberOrString
+    extends HBoundedPotentialPrimitiveType {
+  const HBoundedPotentialPrimitiveNumberOrString(DartType type, bool canBeNull)
+      : super(type, canBeNull);
+
+  HType union(HType other) {
+    if (other.isNumber()) return this;
+    if (other.isNumberOrNull()) {
+      if (canBeNull()) return this;
+      return new HBoundedPotentialPrimitiveNumberOrString(type, true);
+    }
+
+    if (other.isString()) return this;
+    if (other.isStringOrNull()) {
+      if (canBeNull()) return this;
+      return new HBoundedPotentialPrimitiveNumberOrString(type, true);
+    }
+
+    if (other.isNull()) {
+      if (canBeNull()) return this;
+      return new HBoundedPotentialPrimitiveNumberOrString(type, true);
+    }
+
+    return super.union(other);
+  }
+
+  HType intersection(HType other) {
+    if (other.isNumber()) return other;
+    if (other.isNumberOrNull()) {
+      if (!canBeNull()) return HType.NUMBER;
+      return other;
+    }
+    if (other.isString()) return other;
+    if (other.isStringOrNull()) {
+      if (!canBeNull()) return HType.STRING;
+      return other;
+    }
+    return super.intersection(other);
+  }
+}
+
 class HBoundedPotentialPrimitiveArray extends HBoundedPotentialPrimitiveType {
   const HBoundedPotentialPrimitiveArray(DartType type, bool canBeNull)
       : super(type, canBeNull);
 
   HType union(HType other) {
     if (other.isString()) return HType.UNKNOWN;
     if (other.isReadableArray()) return this;
     // TODO(ngeoffray): implement union types.
     if (other.isIndexablePrimitive()) return HType.UNKNOWN;
     if (other.isNull()) {
@@ skipping 60 matching lines @@
   operator [](HInstruction instruction) {
     HType result = _map[instruction];
     if (result == null) return instruction.guaranteedType;
     return result;
   }
 
   operator []=(HInstruction instruction, HType value) {
     _map[instruction] = value;
   }
 }