A dart int literal is a dart2js' int unless it will become NaN or infinity.

sdk/lib/_internal/compiler/implementation/js_backend/constant_system_javascript.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.
 
 part of js_backend;
 
 const JAVA_SCRIPT_CONSTANT_SYSTEM = const JavaScriptConstantSystem();
 
 class JavaScriptBitNotOperation extends BitNotOperation {
   const JavaScriptBitNotOperation();
@@ skipping 159 matching lines @@
       const JavaScriptBinaryBitOperation(const ShiftLeftOperation());
   final shiftRight = const JavaScriptShiftRightOperation();
   final subtract =
       const JavaScriptBinaryArithmeticOperation(const SubtractOperation());
   final truncatingDivide = const JavaScriptBinaryArithmeticOperation(
       const TruncatingDivideOperation());
 
   const JavaScriptConstantSystem();
 
   /**
-   * Returns true if the given [value] fits into a double without losing
-   * precision.
+   * Returns true if [value] will turn into NaN or infinity
+   * at runtime.
    */
-  bool integerFitsIntoDouble(int value) {
-    int absValue = value.abs();
-    double doubleValue = absValue.toDouble();
-    if (doubleValue.isNaN || doubleValue.isInfinite) return false;
-    return value.toDouble().floor().toInt() == value;
+  bool integerBecomesNanOrInfinity(int value) {
+    double doubleValue = value.toDouble();
+    return doubleValue.isNaN || doubleValue.isInfinite;
   }
 
   NumConstant convertToJavaScriptConstant(NumConstant constant) {
     if (constant.isInt()) {
       IntConstant intConstant = constant;
       int intValue = intConstant.value;
-      if (!integerFitsIntoDouble(intValue)) {
+      if (integerBecomesNanOrInfinity(intValue)) {
         return new DoubleConstant(intValue.toDouble());
       }
+      // If the integer loses precision with JavaScript numbers, use
+      // the floored version JavaScript will use.
+      int floorValue = intValue.toDouble().floor().toInt();
+      if (floorValue != intValue) {
+        return new IntConstant(floorValue);
+      }
     } else if (constant.isDouble()) {
       DoubleConstant doubleResult = constant;
       double doubleValue = doubleResult.value;
       if (!doubleValue.isInfinite && !doubleValue.isNaN &&
           !constant.isMinusZero()) {
         int intValue = doubleValue.truncate();
-        if (intValue == doubleValue && integerFitsIntoDouble(intValue)) {
+        if (intValue == doubleValue) {
           return new IntConstant(intValue);
         }
       }
     }
     return constant;
   }
 
   NumConstant createInt(int i)
       => convertToJavaScriptConstant(new IntConstant(i));
   NumConstant createInt32(int i) => new IntConstant(i & BITS32);
@@ skipping 16 matching lines @@
     // At runtime, an integer is both an integer and a double: the
     // integer type check is Math.floor, which will return true only
     // for real integers, and our double type check is 'typeof number'
     // which will return true for both integers and doubles.
     if (s.element == compiler.intClass && t.element == compiler.doubleClass) {
       return true;
     }
     return compiler.types.isSubtype(s, t);
   }
 }