Change IllegalArgumentException to ArgumentError.

pkg/fixnum/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.
 
 /**
  * An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
  * Arithmetic operations may overflow in order to maintain this range.
  */
 class int64 implements intx {
 
@@ skipping 402 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 IllegalArgumentException("$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 IllegalArgumentException("$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 IllegalArgumentException("$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 587 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);
   }
 }