Get rid of a lot of () for getters.

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 45 matching lines @@
       "-8000000000000000" // base 16
   ];
 
   // The remainder of the last divide operation.
   static int64 _remainder;
 
   /**
    * The maximum positive value attainable by an [int64], namely
    * 9,223,372,036,854,775,807.
    */
-  static int64 get MAX_VALUE() {
+  static int64 get MAX_VALUE {
     if (_MAX_VALUE == null) {
       _MAX_VALUE = new int64._bits(_MASK, _MASK, _MASK_2 >> 1);
     }
     return _MAX_VALUE;
   }
 
   /**
    * The minimum positive value attainable by an [int64], namely
    * -9,223,372,036,854,775,808.
    */
-  static int64 get MIN_VALUE() {
+  static int64 get MIN_VALUE {
     if (_MIN_VALUE == null) {
       _MIN_VALUE = new int64._bits(0, 0, _SIGN_BIT_VALUE);
     }
     return _MIN_VALUE;
   }
 
   /**
    * An [int64] constant equal to 0.
    */
-  static int64 get ZERO() {
+  static int64 get ZERO {
     if (_ZERO == null) {
       _ZERO = new int64();
     }
     return _ZERO;
   }
 
   /**
    * An [int64] constant equal to 1.
    */
-  static int64 get ONE() {
+  static int64 get ONE {
     if (_ONE == null) {
       _ONE = new int64._bits(1, 0, 0);
     }
     return _ONE;
   }
 
   /**
    * An [int64] constant equal to 2.
    */
-  static int64 get TWO() {
+  static int64 get TWO {
     if (_TWO == null) {
       _TWO = new int64._bits(2, 0, 0);
     }
     return _TWO;
   }
 
   /**
    * Parses a [String] in a given [radix] between 2 and 16 and returns an
    * [int64].
    */
@@ skipping 640 matching lines @@
   int64._copy(int64 other) {
     _l = other._l;
     _m = other._m;
     _h = other._h;
   }
 
   // Determine whether the platform supports ints greater than 2^53
   // without loss of precision.
   static bool _haveBigIntsCached = null;
 
-  static bool get _haveBigInts() {
+  static bool get _haveBigInts {
     if (_haveBigIntsCached == null) {
       var x = 9007199254740992;
       // Defeat compile-time constant folding.
       if (2 + 2 != 4) {
         x = 0;
       }
       var y = x + 1;
       var same = y == x;
       _haveBigIntsCached = !same;
     }
@@ skipping 307 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);
   }
 }