Clean up exceptions thrown in pkg/fixnum.

pkg/fixnum/lib/src/int64.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 fixnum;
 
 /**
  * An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
  * Arithmetic operations may overflow in order to maintain this range.
  */
@@ skipping 102 matching lines @@
     return _TWO;
   }
 
   /**
    * Parses a [String] in a given [radix] between 2 and 16 and returns an
    * [Int64].
    */
   // TODO(rice) - make this faster by converting several digits at once.
   static Int64 parseRadix(String s, int radix) {
     if ((radix <= 1) || (radix > 16)) {
-      throw "Bad radix: $radix";
+      throw new ArgumentError("Bad radix: $radix");
     }
     Int64 x = ZERO;
     int i = 0;
     bool negative = false;
     if (s[0] == '-') {
       negative = true;
       i++;
     }
     for (; i < s.length; i++) {
       int c = s.codeUnitAt(i);
@@ skipping 280 matching lines @@
     return new Int64._bits(a0, a1, a2);
   }
 
   Int64 operator ~() {
     var result = new Int64._bits((~_l) & _MASK, (~_m) & _MASK, (~_h) & _MASK_2);
     return result;
   }
 
   Int64 operator <<(int n) {
     if (n < 0) {
-      throw new ArgumentError("$n");
+      throw new ArgumentError(n);
     }
     n &= 63;
 
     int res0, res1, res2;
     if (n < _BITS) {
       res0 = _l << n;
       res1 = (_m << n) | (_l >> (_BITS - n));
       res2 = (_h << n) | (_m >> (_BITS - n));
     } else if (n < _BITS01) {
       res0 = 0;
       res1 = _l << (n - _BITS);
       res2 = (_m << (n - _BITS)) | (_l >> (_BITS01 - n));
     } else {
       res0 = 0;
       res1 = 0;
       res2 = _l << (n - _BITS01);
     }
 
     return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
   }
 
   Int64 operator >>(int n) {
     if (n < 0) {
-      throw new ArgumentError("$n");
+      throw new ArgumentError(n);
     }
     n &= 63;
 
     int res0, res1, res2;
 
     // Sign extend h(a).
     int a2 = _h;
     bool negative = (a2 & _SIGN_BIT_VALUE) != 0;
     if (negative) {
       a2 += 0x3 << _BITS2; // add extra one bits on the left
@@ skipping 20 matching lines @@
       if (negative) {
         res0 |= _MASK & ~(_MASK >> (n - _BITS01));
       }
     }
 
     return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
   }
 
   Int64 shiftRightUnsigned(int n) {
     if (n < 0) {
-      throw new ArgumentError("$n");
+      throw new ArgumentError(n);
     }
     n &= 63;
 
     int res0, res1, res2;
     int a2 = _h & _MASK_2; // Ensure a2 is positive.
     if (n < _BITS) {
       res2 = a2 >> n;
       res1 = (_m >> n) | (a2 << (_BITS - n));
       res0 = (_l >> n) | (_m << (_BITS - n));
     } else if (n < _BITS01) {
@@ skipping 218 matching lines @@
     while (!x.isZero) {
       int digit = x._l & 0xf;
       hexStr = "${_hexDigit(digit)}$hexStr";
       x = x.shiftRightUnsigned(4);
     }
     return hexStr;
   }
 
   String toRadixString(int radix) {
     if ((radix <= 1) || (radix > 16)) {
-      throw "Bad radix: $radix";
+      throw new ArgumentError("Bad radix: $radix");
     }
     Int64 a = this;
     if (a.isZero) {
       return "0";
     }
     if (a.isMinValue) {
       return _minValues[radix];
     }
 
     String result = "";
@@ skipping 355 matching lines @@
         }
       }
       return ZERO;
     }
 
     // Generate the quotient using bit-at-a-time long division.
     return _divModHelper(aIsCopy ? a : new Int64._copy(a), b, negative,
         aIsNegative, aIsMinValue, computeRemainder);
   }
 }