Change dart2js int.toRadixString to not return spurious format on IE.

sdk/lib/_internal/compiler/js_lib/js_number.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 _interceptors;
 
 /**
  * The super interceptor class for [JSInt] and [JSDouble]. The compiler
  * recognizes this class as an interceptor, and changes references to
  * [:this:] to actually use the receiver of the method, which is
@@ skipping 92 matching lines @@
     if (this.compareTo(lowerLimit) < 0) return lowerLimit;
     if (this.compareTo(upperLimit) > 0) return upperLimit;
     return this;
   }
 
   // The return type is intentionally omitted to avoid type checker warnings
   // from assigning JSNumber to double.
   toDouble() => this;
 
   String toStringAsFixed(int fractionDigits) {
-    checkNum(fractionDigits);
-    // TODO(floitsch): fractionDigits must be an integer.
+    checkInt(fractionDigits);
     if (fractionDigits < 0 || fractionDigits > 20) {
       throw new RangeError(fractionDigits);
     }
     String result = JS('String', r'#.toFixed(#)', this, fractionDigits);
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toStringAsExponential([int fractionDigits]) {
     String result;
     if (fractionDigits != null) {
-      // TODO(floitsch): fractionDigits must be an integer.
-      checkNum(fractionDigits);
+      checkInt(fractionDigits);
       if (fractionDigits < 0 || fractionDigits > 20) {
         throw new RangeError(fractionDigits);
       }
       result = JS('String', r'#.toExponential(#)', this, fractionDigits);
     } else {
       result = JS('String', r'#.toExponential()', this);
     }
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toStringAsPrecision(int precision) {
-    // TODO(floitsch): precision must be an integer.
-    checkNum(precision);
+    checkInt(precision);
     if (precision < 1 || precision > 21) {
       throw new RangeError(precision);
     }
     String result = JS('String', r'#.toPrecision(#)',
                        this, precision);
     if (this == 0 && isNegative) return "-$result";
     return result;
   }
 
   String toRadixString(int radix) {
-    checkNum(radix);
+    checkInt(radix);
     if (radix < 2 || radix > 36) throw new RangeError(radix);
-    return JS('String', r'#.toString(#)', this, radix);
+    String result = JS('String', r'#.toString(#)', this, radix);
+    const int rightParenCode = 0x29;
+    if (result.codeUnitAt(result.length - 1) != rightParenCode) {
+      return result;
+    }
+    return _handleIEtoString(result);
+  }
+
+  static String _handleIEtoString(String result) {
+    // Result is probably IE's untraditional format for large numbers,
+    // e.g., "8.0000000000008(e+15)" for 0x8000000000000800.toString(16).
+    var match = JS('List|Null',
+                   r'/^([\da-z]+)(?:\.([\da-z]+))?\(e\+(\d+)\)$/.exec(#)',
+                   result);
+    if (match == null) {
+      // Then we don't know how to handle it at all.
+      throw new UnsupportedError("Unexpected toString result: $result");
+    }
+    String result = JS('String', '#', match[1]);
+    int exponent = JS("int", "+#", match[3]);
+    if (match[2] != null) {
+      result = JS('String', '# + #', result, match[2]);
+      exponent -= JS('int', '#.length', match[2]);
+    }
+    return result + "0" * exponent;
   }
 
   // Note: if you change this, also change the function [S].
   String toString() {
     if (this == 0 && JS('bool', '(1 / #) < 0', this)) {
       return '-0.0';
     } else {
       return JS('String', r'"" + (#)', this);
     }
   }
@@ skipping 227 matching lines @@
 }
 
 class JSDouble extends JSNumber implements double {
   const JSDouble();
   Type get runtimeType => double;
 }
 
 class JSPositiveInt extends JSInt {}
 class JSUInt32 extends JSPositiveInt {}
 class JSUInt31 extends JSUInt32 {}