Get rid of a lot of () for getters.

samples/ui_lib/observable/observable.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.
 
 #library('observable');
 
 #import('dart:coreimpl');
 
 #source('ChangeEvent.dart');
 #source('EventBatch.dart');
@@ skipping 33 matching lines @@
   /** Unique id to identify this model in an event batch. */
   final int uid;
 
   /** The parent observable to notify when this child is changed. */
   final Observable parent;
 
   /** Listeners on this model. */
   List<ChangeListener> listeners;
 
   /** Whether this object is currently observed by listeners or propagators. */
-  bool get isObserved() {
+  bool get isObserved {
     for (Observable obj = this; obj != null; obj = obj.parent) {
       if (listeners.length > 0) {
         return true;
       }
     }
     return false;
   }
 
   AbstractObservable([Observable this.parent = null])
     : uid = EventBatch.genUid(),
@@ skipping 76 matching lines @@
   ObservableList([Observable parent = null])
     : super(parent), _internal = new List<T>();
 
   T operator [](int index) => _internal[index];
 
   void operator []=(int index, T value) {
     recordListUpdate(index, value, _internal[index]);
     _internal[index] = value;
   }
 
-  int get length() => _internal.length;
+  int get length => _internal.length;
 
   void set length(int value) {
     _internal.length = value;
     recordGlobalChange();
   }
 
   void clear() {
     _internal.clear();
     recordGlobalChange();
   }
@@ skipping 112 matching lines @@
 // classes observable instead of individual fields. The memory cost of having
 // every field effectively boxed, plus having a listeners list is likely too
 // much. Also, making a value observable necessitates adding ".value" to lots
 // of places, and constructing all fields with the verbose
 // "new ObservableValue<DataType>(myValue)".
 /** A wrapper around a single value whose change can be observed. */
 class ObservableValue<T> extends AbstractObservable {
   ObservableValue(T value, [Observable parent = null])
     : super(parent), _value = value;
 
-  T get value() => _value;
+  T get value => _value;
 
   void set value(T newValue) {
     // Only fire on an actual change.
     // TODO(terry): An object identity test === is needed.  Each DataSource has
     //              its own operator == which does a value compare.  Which
     //              equality check should be done?
     if (newValue !== _value) {
       final oldValue = _value;
       _value = newValue;
       recordPropertyUpdate("value", newValue, oldValue);
     }
   }
 
   T _value;
 }