Change our 'is int' check to use Math.floor instead of a smi check.

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 2132 matching lines @@
   }
 
   void checkInt(HInstruction input, String cmp) {
     use(input);
     js.Expression left = pop();
     use(input);
     js.Expression or0 = new js.Binary("|", pop(), new js.LiteralNumber("0"));
     push(new js.Binary(cmp, left, or0));
   }
 
+  void checkBigInt(HInstruction input, String cmp) {
+    use(input);
+    js.Expression left = pop();
+    use(input);
+    js.Expression right = pop();
+    // TODO(ngeoffray,floitsch): Deal with infinity.

[floitsch, 2012/09/07 11:56:47]

file bug.

[ngeoffray, 2012/09/07 12:06:26]

Done: http://code.google.com/p/dart/issues/detail?id=4984

+    push(new js.LiteralExpression.withData('Math.floor(#) === #',
+                                           <js.Expression>[left, right]));
+  }
+
   void checkTypeOf(HInstruction input, String cmp, String typeName) {
     use(input);
     js.Expression typeOf = new js.Prefix("typeof", pop());
     push(new js.Binary(cmp, typeOf, new js.LiteralString("'$typeName'")));
   }
 
   void checkNum(HInstruction input, String cmp)
       => checkTypeOf(input, cmp, 'number');
 
   void checkDouble(HInstruction input, String cmp)  => checkNum(input, cmp);
@@ skipping 135 matching lines @@
     } else if (element == compiler.numClass) {
       checkNum(input, '===');
       attachLocationToLast(node);
     } else if (element == compiler.boolClass) {
       checkBool(input, '===');
       attachLocationToLast(node);
     } else if (element == compiler.functionClass) {
       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();
-      checkInt(input, '===');
+      checkBigInt(input, '===');
       push(new js.Binary('&&', numTest, pop()), node);
     } else if (Elements.isStringSupertype(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, '===');
@@ skipping 614 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }