dart2js: Better big-number shortening.

pkg/compiler/lib/src/js_backend/constant_emitter.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;
 
 class ConstantEmitter {
   ConstantReferenceEmitter _referenceEmitter;
   ConstantLiteralEmitter _literalEmitter;
 
@@ skipping 182 matching lines @@
     compiler.internalError(NO_LOCATION_SPANNABLE,
         "The function constant does not need specific JS code.");
     return null;
   }
 
   @override
   jsAst.Expression visitNull(NullConstantValue constant, [_]) {
     return new jsAst.LiteralNull();
   }
 
+  /// Reduces the size of exponential representations when minification is
+  /// enabled.
+  ///
+  /// Removes the "+" after the exponential sign, and removes the "." before the
+  /// "e". For example `1.23e+5` is changed to `123e3`.
+  String _shortenExponentialRepresentation(String numberString) {
+    if (!compiler.enableMinification) return numberString;

[sra1, 2015/02/20 22:08:25]

I would still do this, the cutoff avoids most weird looking numbers like 1e3.

[floitsch, 2015/02/23 18:36:23]

It was to avoid running it for visitDouble but done.

+    if (numberString.length < 4) return numberString;
+    if (numberString[1] == "e" && numberString[2] == "+") {
+      // For example: "1e+5". Remove the "+".
+      return "${numberString[0]}e${numberString.substring(2)}";
+    }
+    if (numberString[1] != ".") return numberString;
+    int digitsAfterDotCount = 0;
+    int pos = 2;

[sra1, 2015/02/20 22:08:25]

int pos = numberString.indexOf('e', 2);

Or you could match the pieces with a regexp, which might be able to take care of
all the special cases.

[floitsch, 2015/02/23 18:36:23]

Exponential representations always start with a single digit. No need to search
for more.

I just did a regexp, but in the end I don't think it's worth it.
Keeping the manual parsing.

+    while (pos < numberString.length && numberString[pos] != "e") {
+      pos++;
+      digitsAfterDotCount++;
+    }
+    if (pos >= numberString.length) return numberString;
+    int exponent = int.parse(numberString.substring(pos + 1));
+    if (exponent <= digitsAfterDotCount) return numberString;
+    String digitsAfterDot = numberString.substring(2, pos);
+    int shiftedExponent = exponent - digitsAfterDotCount;
+    String result = "${numberString[0]}${digitsAfterDot}e$shiftedExponent";
+    assert(double.parse(result) == double.parse(numberString));
+    return result;
+  }
+
   @override
   jsAst.Expression visitInt(IntConstantValue constant, [_]) {
     int primitiveValue = constant.primitiveValue;
     // Since we are in JavaScript we can shorten long integers to their
     // shorter exponential representation.
     // For example: "1e+4" is shorter than "10000".
     //
     // Note that this shortening apparently loses precision for big numbers
     // (like 1234567890123456789012345 which becomes 1.2345678901234568e+24).

[sra1, 2015/02/20 22:08:25]

This comment might not be accurate - no +.

[floitsch, 2015/02/23 18:36:23]

Done.

-    // However, since JavaScript engines implicitly convert to double, these
-    // digits are lost anyway.
-    if (primitiveValue.abs() >= 10000) {
-      String exponential = primitiveValue.toStringAsExponential();
+    // However, since JavaScript engines represent all numbers as doubles,
+    // these digits are lost anyway.
+    int cutOffValue = compiler.enableMinification ? 10000 : 1e20.toInt();
+    if (primitiveValue.abs() >= cutOffValue) {
+      String exponential = _shortenExponentialRepresentation(
+          primitiveValue.toStringAsExponential());
       String decimal = primitiveValue.toString();
       return new jsAst.LiteralNumber(
           (exponential.length < decimal.length) ? exponential : decimal);
     }
     return new jsAst.LiteralNumber('$primitiveValue');
   }
 
   @override
   jsAst.Expression visitDouble(DoubleConstantValue constant, [_]) {
     double value = constant.primitiveValue;
     if (value.isNaN) {
       return js("0/0");
     } else if (value == double.INFINITY) {
       return js("1/0");
     } else if (value == -double.INFINITY) {
       return js("-1/0");
     } else {
-      return new jsAst.LiteralNumber("$value");
+      String shortened = _shortenExponentialRepresentation("$value");
+      return new jsAst.LiteralNumber(shortened);
     }
   }
 
   @override
   jsAst.Expression visitBool(BoolConstantValue constant, [_]) {
     if (compiler.enableMinification) {
       if (constant.isTrue) {
         // Use !0 for true.
         return js("!0");
       } else {
@@ skipping 169 matching lines @@
                             [value, argumentList]);
     }
     return value;
   }
 
   @override
   jsAst.Expression visitDeferred(DeferredConstantValue constant, [_]) {
     return constantEmitter.reference(constant.referenced);
   }
 }