num implements Comparable and Hashable.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 2234 matching lines @@
       push(new js.Call(field, <js.Expression>[]));
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       // We always negate at least once so that the result is boolified.
       push(new js.Prefix('!', field));
       // If the result is not negated, put another '!' in front.
       if (!negative) push(new js.Prefix('!', pop()));
     }
   }
 
-  void handleStringSupertypeCheck(HInstruction input, DartType type) {
-    // Make sure List and String don't share supertypes, otherwise we
-    // would need to check for List too.
+  void handleNumberOrStringSupertypeCheck(HInstruction input, DartType type) {
     assert(type.element !== compiler.listClass
-           && !Elements.isListSupertype(type.element, compiler));
+           && !Elements.isListSupertype(type.element, compiler)
+           && !Elements.isStringOnlySupertype(type.element, compiler));
+    checkNum(input, '===');
+    js.Expression numberTest = pop();
     checkString(input, '===');
     js.Expression stringTest = pop();
     checkObject(input, '===');
+    js.Expression objectTest = pop();
+    checkType(input, type);
+    push(new js.Binary('||',
+                       new js.Binary('||', numberTest, stringTest),
+                       new js.Binary('&&', objectTest, pop())));
+  }
+
+  void handleStringSupertypeCheck(HInstruction input, DartType type) {
+    assert(type.element !== compiler.listClass
+           && !Elements.isListSupertype(type.element, compiler)
+           && !Elements.isNumberOrStringSupertype(type.element, compiler));
+    checkString(input, '===');
+    js.Expression stringTest = pop();
+    checkObject(input, '===');
     js.Expression objectTest = pop();
     checkType(input, type);
     push(new js.Binary('||',
                        stringTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
   void handleListOrSupertypeCheck(HInstruction input, DartType type) {
-    // Make sure List and String don't share supertypes, otherwise we
-    // would need to check for String too.
     assert(type.element !== compiler.stringClass
-           && !Elements.isStringSupertype(type.element, compiler));
+           && !Elements.isStringOnlySupertype(type.element, compiler)
+           && !Elements.isNumberOrStringSupertype(type.element, compiler));
     checkObject(input, '===');
     js.Expression objectTest = pop();
     checkArray(input, '===');
     js.Expression arrayTest = pop();
     checkType(input, type);
     push(new js.Binary('&&',
                        objectTest,
                        new js.Binary('||', arrayTest, pop())));
   }
 
@@ skipping 29 matching lines @@
       checkFunction(input, type);
       attachLocationToLast(node);
     } else if (element == compiler.intClass) {
       // The is check in the code tells us that it might not be an
       // int. So we do a typeof first to avoid possible
       // deoptimizations on the JS engine due to the Math.floor check.
       checkNum(input, '===');
       js.Expression numTest = pop();
       checkBigInt(input, '===');
       push(new js.Binary('&&', numTest, pop()), node);
-    } else if (Elements.isStringSupertype(element, compiler)) {
+    } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
+      handleNumberOrStringSupertypeCheck(input, type);
+      attachLocationToLast(node);
+    } else if (Elements.isStringOnlySupertype(element, compiler)) {
       handleStringSupertypeCheck(input, type);
       attachLocationToLast(node);
     } else if (element === compiler.listClass
                || Elements.isListSupertype(element, compiler)) {
       handleListOrSupertypeCheck(input, type);
       attachLocationToLast(node);
     } else if (types[input].canBePrimitive() || types[input].canBeNull()) {
       checkObject(input, '===');
       js.Expression objectTest = pop();
       checkType(input, type);
@@ skipping 33 matching lines @@
       "doubleTypeCheck":
           const SourceString("doubleTypeCast"),
       "numTypeCheck":
           const SourceString("numTypeCast"),
       "boolTypeCheck":
           const SourceString("boolTypeCast"),
       "functionTypeCheck":
           const SourceString("functionTypeCast"),
       "intTypeCheck":
           const SourceString("intTypeCast"),
+      "numberOrStringSuperNativeTypeCheck":
+          const SourceString("numberOrStringSuperNativeTypeCast"),
+      "numberOrStringSuperTypeCheck":
+          const SourceString("numberOrStringSuperTypeCast"),
       "stringSuperNativeTypeCheck":
           const SourceString("stringSuperNativeTypeCast"),
       "stringSuperTypeCheck":
           const SourceString("stringSuperTypeCast"),
       "listTypeCheck":
           const SourceString("listTypeCast"),
       "listSuperNativeTypeCheck":
           const SourceString("listSuperNativeTypeCast"),
       "listSuperTypeCheck":
           const SourceString("listSuperTypeCast"),
@@ skipping 559 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }