dart2js: Constant fold num.round()

pkg/compiler/lib/src/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.
 
 library dart2js.constant_system.js;
 
 import '../compiler.dart' show Compiler;
 import '../constant_system_dart.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 147 matching lines @@
       double leftDouble = leftNum.primitiveValue.toDouble();
       double rightDouble = rightNum.primitiveValue.toDouble();
       return new BoolConstantValue(leftDouble == rightDouble);
     }
     return result;
   }
 
   apply(left, right) => identical(left, right);
 }
 
+class JavaScriptRoundOperation implements UnaryOperation {
+  const JavaScriptRoundOperation();
+  String get name => DART_CONSTANT_SYSTEM.round.name;
+  ConstantValue fold(ConstantValue constant) {
+    // Be careful to round() only values that do not throw on either the host or
+    // target platform.
+    ConstantValue tryToRound(num value) {
+      // Due to differences between browsers, only 'round' easy cases. Avoid
+      // cases where nudging the value up or down changes the answer.
+      // 13 digits is safely within the ~15 digit precision of doubles.
+      const severalULP = 0.0000000000001;
+      // Use 'roundToDouble()' to avoid exceptions on rounding the nudged value.
+      double rounded = value.roundToDouble();
+      double rounded1 = (value * (1.0 + severalULP)).roundToDouble();
+      double rounded2 = (value * (1.0 - severalULP)).roundToDouble();
+      if (rounded != rounded1 || rounded != rounded2) return null;
+      return JAVA_SCRIPT_CONSTANT_SYSTEM
+          .convertToJavaScriptConstant(new IntConstantValue(value.round()));
+    }
+
+    if (constant.isInt) {
+      IntConstantValue intConstant = constant;
+      int value = intConstant.primitiveValue;
+      if (value >= -double.MAX_FINITE && value <= double.MAX_FINITE) {
+        return tryToRound(value);
+      }
+    }
+    if (constant.isDouble) {
+      DoubleConstantValue doubleConstant = constant;
+      double value = doubleConstant.primitiveValue;
+      // NaN and infinities will throw.
+      if (value.isNaN) return null;
+      if (value.isInfinite) return null;
+      return tryToRound(value);
+    }
+    return null;
+  }
+}
+
 /**
  * Constant system following the semantics for Dart code that has been
  * compiled to JavaScript.
  */
 class JavaScriptConstantSystem extends ConstantSystem {
-  final int BITS31 = 0x8FFFFFFF;
   final int BITS32 = 0xFFFFFFFF;
 
   final add = const JavaScriptAddOperation();
   final bitAnd = const JavaScriptBinaryBitOperation(const BitAndOperation());
   final bitNot = const JavaScriptBitNotOperation();
   final bitOr = const JavaScriptBinaryBitOperation(const BitOrOperation());
   final bitXor = const JavaScriptBinaryBitOperation(const BitXorOperation());
   final booleanAnd = const BooleanAndOperation();
   final booleanOr = const BooleanOrOperation();
   final divide =
@@ skipping 12 matching lines @@
   final negate = const JavaScriptNegateOperation();
   final not = const NotOperation();
   final shiftLeft =
       const JavaScriptBinaryBitOperation(const ShiftLeftOperation());
   final shiftRight = const JavaScriptShiftRightOperation();
   final subtract =
       const JavaScriptBinaryArithmeticOperation(const SubtractOperation());
   final truncatingDivide = const JavaScriptBinaryArithmeticOperation(
       const TruncatingDivideOperation());
   final codeUnitAt = const CodeUnitAtRuntimeOperation();
+  final round = const JavaScriptRoundOperation();
 
   const JavaScriptConstantSystem();
 
   /**
    * Returns true if [value] will turn into NaN or infinity
    * at runtime.
    */
   bool integerBecomesNanOrInfinity(int value) {
     double doubleValue = value.toDouble();
     return doubleValue.isNaN || doubleValue.isInfinite;
@@ skipping 184 matching lines @@
       result.add(keyList);
     } else {
       // Add the keys individually to avoid generating an unused list constant
       // for the keys.
       result.addAll(keys);
     }
     result.addAll(values);
     return result;
   }
 }