Support is checks on primitive types.

dart/frog/leg/lib/core.dart

 // Copyright (c) 2011, 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.
 
 void print(var obj) {
   obj = obj.toString();
   var hasConsole = JS("bool", @"typeof console == 'object'");
   if (hasConsole) {
     JS("void", @"console.log($0)", obj);
   } else {
@@ skipping 10 matching lines @@
   }
   throw e;
 }
 
 /**
   * Returns true if both arguments are numbers.
   * If only the first argument is a number, throws the given message as
   * exception.
   */
 bool checkNumbers(var a, var b, var message) {
-  if (JS("bool", @"typeof $0 === 'number'", a)) {
-    if (JS("bool", @"typeof $0 === 'number'", b)) {
+  if (a is num) {
+    if (b is num) {
       return true;
     } else {
       throw message;
     }
   }
   return false;
 }
 
 
 bool isJSArray(var value) {
   return JS("bool", @"$0.constructor === Array", value);
 }
 
 
 add(var a, var b) {
   if (checkNumbers(a, b, "num+ expects a number as second operand.")) {
     return JS("num", @"$0 + $1", a, b);
-  } else if (JS("bool", @"typeof $0 === 'string'", a)) {
+  } else if (a is String) {
     b = b.toString();
-    if (JS("bool", @"typeof $0 === 'string'", b)) {
+    if (b is String) {
       return JS("String", @"$0 + $1", a, b);
     }
     // The following line is too long, but we can't break it using the +
     // operator, since that's what we are defining here.
     throw "calling toString() on right hand operand of operator + did not return a String";
   }
   return UNINTERCEPTED(a + b);
 }
 
 div(var a, var b) {
@@ skipping 146 matching lines @@
   if (JS("bool", @"typeof $0 === 'number'", a)) return JS("num", @"~$0", a);
   return UNINTERCEPTED(~a);
 }
 
 neg(var a) {
   if (JS("bool", @"typeof $0 === 'number'", a)) return JS("num", @"-$0", a);
   return UNINTERCEPTED(-a);
 }
 
 index(var a, var index) {
-  if (JS("bool", @"typeof $0 === 'string'", a) || isJSArray(a)) {
-    if (!isInt(index)) $throw('Illegal argument');
+  if (a is String || isJSArray(a)) {
+    if (!(index is int)) $throw('Illegal argument');
     if (index < 0 || index >= a.length) $throw('Out of bounds');
     return JS("Object", @"$0[$1]", a, index);
   }
   return UNINTERCEPTED(a[index]);
 }
 
 indexSet(var a, var index, var value) {
   if (isJSArray(a)) {
-    if (!isInt(index)) $throw('Illegal argument');
+    if (!(index is int)) $throw('Illegal argument');
     if (index < 0 || index >= a.length) $throw('Out of bounds');
     return JS("Object", @"$0[$1] = $2", a, index, value);
   }
   return UNINTERCEPTED(a[index] = value);
 }
 
 builtin$add$1(var receiver, var value) {
   if (isJSArray(receiver)) {
     JS("Object", @"$0.push($1)", receiver, value);
     return;
@@ skipping 11 matching lines @@
 builtin$filter$1(var receiver, var predicate) {
   if (isJSArray(receiver)) {
     return JS("Object", @"$0.filter(function(v) { return $1(v) === true; })",
               receiver, predicate);
   }
   return UNINTERCEPTED(receiver.filter(predicate));
 }
 
 
 builtin$get$length(var receiver) {
-  if (JS("bool", @"typeof $0 === 'string'", receiver) || isJSArray(receiver)) {
+  if (receiver is String || isJSArray(receiver)) {
     return JS("num", @"$0.length", receiver);
   }
   return UNINTERCEPTED(receiver.length);
 }
 
 
 builtin$toString$0(var value) {
   if (JS("bool", @"typeof $0 == 'object'", value)) {
     if (isJSArray(value)) {
       return "Instance of 'List'";
     }
     return UNINTERCEPTED(value.toString());
   }
   if (JS("bool", @"$0 === 0 && (1 / $0) < 0", value)) {
     return "-0.0";
   }
   if (value === null) return "null";
   return JS("string", @"String($0)", value);
 }
 
 
 builtin$iterator$0(var receiver) {
   if (isJSArray(receiver)) {
     return new ListIterator(receiver);
   }
   return UNINTERCEPTED(receiver.iterator());
 }
 
 builtin$charCodeAt$1(var receiver, int index) {
-  if (JS("bool", @"typeof receiver === 'string'")) {
+  if (receiver is String) {
     return JS("string", @"$0.charCodeAt($1)", receiver, index);
   } else {
     return UNINTERCEPTED(receiver.charCodeAt(index));
   }
 }
 
 builtin$isEmpty$0(var receiver) {
-  if (JS("bool", @"typeof $0 === 'string'", receiver) || isJSArray(receiver)) {
+  if (receiver is String || isJSArray(receiver)) {
     return JS("bool", @"$0.length === 0", receiver);
   }
   return UNINTERCEPTED(receiver.isEmpty());
 }
 
 
-bool isInt(var v) {
-  return JS("bool", @"($0 | 0) === $1", v, v);
-}
-
 /* Include when interfaces are implemented
 interface Iterable<T> {
   Iterator<T> iterator();
 }
 
 interface Iterator<T> {
   bool hasNext();
   T next();
 }
 */
 class int {}
 class double {}
 class String {}
 class bool {}
+class num {}
 class Object {
   String toString() {
     String name = JS('String', @'this.constructor.name');
     if (name === null) {
       name = JS('String', @'$0.match(/^\s*function\s*(\S*)\s*\(/)[1]',
                 JS('String', @'this.constructor.toString()'));
     }
     return "Instance of '$name'";
   }
 
@@ skipping 10 matching lines @@
   String toString() {
     return "NoSuchMethodException - receiver: '$receiver'" +
         "function name: '$name' arguments: [$args]";
   }
 }
 
 class List<T> /* implements Iterable<T> */ {
 
   factory List([int length]) {
     if (length == null) return JS("Object", @"new Array()");
-    if (!isInt(length)) throw "Invalid argument";
+    if (!(length is int)) throw "Invalid argument";
     if (length < 0) throw "Negative size";
     return JS("Object", @"new Array($0)", length);
   }
 }
 
 class ListIterator<T> /* implements Iterator<T> */ {
   int i;
   List<T> list;
   ListIterator(List<T> this.list) : i = 0;
   bool hasNext() => i < JS("int", @"$0.length", list);
@@ skipping 85 matching lines @@
     } else {
       return
         JS("num", @"Math.floor($0 + (Date.now() - $1))", elapsedMs, startMs);
     }
   }
 
   int frequency() {
     return 1000;
   }
 }