Get rid of a lot of () for getters.

lib/core/future.dart

 // Copyright (c) 2011, 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.
 
 /**
  * A [Future] is used to obtain a value sometime in the future.  Receivers of a
  * [Future] can obtain the value by passing a callback to [then]. For example:
  *
  *     Future<int> future = getFutureFromSomewhere();
  *     future.then((value) {
@@ skipping 15 matching lines @@
  *      [:true:], then the exception is thrown.
  *
  * Use a [Completer] to create and change the state of a [Future].
  */
 interface Future<T> default FutureImpl<T> {
 
   /** A future whose value is immediately available. */
   Future.immediate(T value);
 
   /** The value provided. Throws an exception if [hasValue] is false. */
-  T get value();
+  T get value;
 
   /**
    * Exception that occurred ([:null:] if no exception occured). This property
    * throws a [FutureNotCompleteException] if it is used before this future is
    * completes.
    */
-  Object get exception();
+  Object get exception;
 
   /**
    * The stack trace object associated with the exception that occurred. This
    * throws a [FutureNotCompleteException] if it is used before the future
    * completes. Returns [:null:] if the future completed successfully or a
    * stack trace wasn't provided with the exception when it occurred.
    */
-  Object get stackTrace();
+  Object get stackTrace;
 
   /**
    * Whether the future is complete (either the value is available or there was
    * an exception).
    */
-  bool get isComplete();
+  bool get isComplete;
 
   /**
    * Whether the value is available (meaning [isComplete] is true, and there was
    * no exception).
    */
-  bool get hasValue();
+  bool get hasValue;
 
   /**
    * When this future is complete (either with a value or with an exception),
    * then [complete] is called with the future.
    * If [complete] throws an exception, it is ignored.
    */
   void onComplete(void complete(Future<T> future));
 
   /**
    * If this future is complete and has a value, then [onValue] is called
@@ skipping 82 matching lines @@
  *   // alternatively, if the service cannot produce the value, it
  *   // can provide an exception:
  *   completer.completeException(exception);
  *
  */
 interface Completer<T> default CompleterImpl<T> {
 
   Completer();
 
   /** The future that will contain the value produced by this completer. */
-  Future get future();
+  Future get future;
 
   /** Supply a value for [future]. */
   void complete(T value);
 
   /**
    * Indicate in [future] that an exception occured while trying to produce its
    * value. The argument [exception] should not be [:null:]. A [stackTrace]
    * object can be provided as well to give the user information about where
    * the error occurred. If omitted, it will be [:null:].
    */
@@ skipping 54 matching lines @@
       future.handleException((exception) {
         if (!result.isComplete) {
           completer.completeException(exception, future.stackTrace);
         }
         return true;
       });
     }
     return result;
   }
 }