Cleanup various argument and range errors in double.dart and integers.dart.

runtime/lib/double.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 _Double implements double {
   factory _Double.fromInteger(int value)
       native "Double_doubleFromInteger";
 
   Type get runtimeType => double;
 
@@ skipping 99 matching lines @@
   int floor() => floorToDouble().toInt();
   int ceil () => ceilToDouble().toInt();
   int truncate() => truncateToDouble().toInt();
 
   double roundToDouble() native "Double_round";
   double floorToDouble() native "Double_floor";
   double ceilToDouble() native "Double_ceil";
   double truncateToDouble() native "Double_truncate";
 
   num clamp(num lowerLimit, num upperLimit) {
-    if (lowerLimit is! num) throw new ArgumentError(lowerLimit);
-    if (upperLimit is! num) throw new ArgumentError(upperLimit);
+    if (lowerLimit is! num) {
+      throw new ArgumentError.value(lowerLimit, "lowerLimit", "not a number");
+    }
+    if (upperLimit is! num) {
+      throw new ArgumentError.value(upperLimit, "upperLimit", "not a number");
+    }
 
     if (lowerLimit.compareTo(upperLimit) > 0) {
       throw new ArgumentError(lowerLimit);
     }
     if (lowerLimit.isNaN) return lowerLimit;
     if (this.compareTo(lowerLimit) < 0) return lowerLimit;
     if (this.compareTo(upperLimit) > 0) return upperLimit;
     return this;
   }
 
@@ skipping 27 matching lines @@
     _cache[_cacheEvictIndex] = this;
     _cache[_cacheEvictIndex + 1] = result;
     _cacheEvictIndex = (_cacheEvictIndex + 2) & CACHE_MASK;
     return result;
   }
 
   String toStringAsFixed(int fractionDigits) {
     // See ECMAScript-262, 15.7.4.5 for details.
 
     if (fractionDigits is! int) {
-      throw new ArgumentError(fractionDigits);
+      throw new ArgumentError.value(
+          fractionDigits, "fractionDigits", "not an integer");
     }
     // Step 2.
     if (fractionDigits < 0 || fractionDigits > 20) {
-      throw new RangeError(fractionDigits);
+      throw new RangeError.range(fractionDigits, 0, 20, "fractionDigits");
     }
 
     // Step 3.
     double x = this;
 
     // Step 4.
     if (isNaN) return "NaN";
 
     // Step 5 and 6 skipped. Will be dealt with by native function.
 
     // Step 7.
     if (x >= 1e21 || x <= -1e21) {
       return x.toString();
     }
 
     return _toStringAsFixed(fractionDigits);
   }
   String _toStringAsFixed(int fractionDigits) native "Double_toStringAsFixed";
 
   String toStringAsExponential([int fractionDigits]) {
     // See ECMAScript-262, 15.7.4.6 for details.
 
     // The EcmaScript specification checks for NaN and Infinity before looking
     // at the fractionDigits. In Dart we are consistent with toStringAsFixed and
     // look at the fractionDigits first.
 
     // Step 7.
     if (fractionDigits != null) {
       if (fractionDigits is! int) {
-        throw new ArgumentError(fractionDigits);
+        throw new ArgumentError.value(
+            fractionDigits, "fractionDigits", "not an integer");
       }
       if (fractionDigits < 0 || fractionDigits > 20) {
-        throw new RangeError(fractionDigits);
+        throw new RangeError.range(fractionDigits, 0, 20, "fractionDigits");
       }
     }
 
     if (isNaN) return "NaN";
     if (this == double.INFINITY) return "Infinity";
     if (this == -double.INFINITY) return "-Infinity";
 
     // The dart function prints the shortest representation when fractionDigits
     // equals null. The native function wants -1 instead.
     fractionDigits = (fractionDigits == null) ? -1 : fractionDigits;
 
     return _toStringAsExponential(fractionDigits);
   }
   String _toStringAsExponential(int fractionDigits)
       native "Double_toStringAsExponential";
 
   String toStringAsPrecision(int precision) {
     // See ECMAScript-262, 15.7.4.7 for details.
 
     // The EcmaScript specification checks for NaN and Infinity before looking
     // at the fractionDigits. In Dart we are consistent with toStringAsFixed and
     // look at the fractionDigits first.
 
-    if (precision is! int) throw new ArgumentError(precision);
-
+    if (precision is! int) {
+      throw new ArgumentError.value(precision, "precision", "not an integer");
+    }
     // Step 8.
     if (precision < 1 || precision > 21) {
-      throw new RangeError(precision);
+      throw new RangeError.range(precision, 1, 21, "precision");
     }
 
     if (isNaN) return "NaN";
     if (this == double.INFINITY) return "Infinity";
     if (this == -double.INFINITY) return "-Infinity";
 
     return _toStringAsPrecision(precision);
   }
   String _toStringAsPrecision(int fractionDigits)
       native "Double_toStringAsPrecision";
@@ skipping 17 matching lines @@
         return EQUAL;
       }
     } else if (isNaN) {
       return other.isNaN ? EQUAL : GREATER;
     } else {
       // Other is NaN.
       return LESS;
     }
   }
 }