Get rid of a lot of () for getters.

utils/peg/pegparser.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('Peg Parser');
 
 /*
  * The following functions are combinators for building Rules.
  *
  * A rule is one of the following
@@ skipping 65 matching lines @@
     flags[code - lo] = true;
 
   return CHARCODE((code) => code >= lo && code <= hi && flags[code - lo]);
 }
 
 /**
  * Matches the end of the input.
  *
  * END does not generate a value.
  */
-_Rule get END() => new _EndOfInputRule();
+_Rule get END => new _EndOfInputRule();
 
 /**
  * Throws an exception.
  */
 _Rule ERROR(String message) => new _ErrorRule(message);
 
 /**
  * Matches [rule] but does not consume the input.  Useful for matching a right
  * context.
  *
@@ skipping 119 matching lines @@
 /**
  * A grammar is a collection of symbols and rules that may be used to parse an
  * input.
  */
 class Grammar {
   Map<String, Symbol> _symbols;
 
   /** This rule may be set by the user to define whitespace. */
   _Rule _whitespace;
 
-  _Rule get whitespace() => _whitespace;
+  _Rule get whitespace => _whitespace;
   void set whitespace(rule) { _whitespace = _compile(rule); }
 
   Grammar() {
     _symbols = new Map<String, Symbol>();
     whitespace = CHAR(' \t\r\n');
   }
 
   /**
    * operator [] is used to find or create symbols. Symbols may appear in rules
    * to define recursive rules.
@@ skipping 135 matching lines @@
       }
     }
     // Delegate the matching logic to the the specialized function.
     return _match(state, pos);
   }
 
   // Overridden in subclasses to match the rule.
   _match(_ParserState state, int pos) => null;
 
   // Does the rule generate a value (AST) with the match?
-  bool get generatesValue() => false;
+  bool get generatesValue => false;
 
-  get defaultValue() => null;
+  get defaultValue => null;
 }
 
 int _skip_whitespace(state, pos) {
   // Returns the next non-whitespace position.
   // This is done by matching the optional whitespaceRule with the current text.
   if (state.whitespaceRule == null)
     return pos;
   state.inWhitespaceMode = true;
   state.inhibitExpectedTrackingDepth++;
   while (true) {
@@ skipping 79 matching lines @@
 
 class _SymbolRule extends _Rule {
   final Symbol _symbol;
   _SymbolRule(Symbol this._symbol);
   _match(_ParserState state, int pos) {
     if (_symbol._rule == null)
       throw new Exception("Symbol '${_symbol.name}' is undefined");
     return _symbol._rule.match(state, pos);
   }
 
-  bool get generatesValue() => true;
+  bool get generatesValue => true;
 
   toString() => '<${_symbol.name}>';
 }
 
 class _SkipRule extends _Rule {
   // A rule that has no value.
   _Rule _rule;
   _SkipRule(_Rule this._rule);
   _match(_ParserState state, int pos) {
     var match = _rule.matchAfterWS(state, pos);
@@ skipping 15 matching lines @@
   _match(_ParserState state, int pos) {
     if (pos + _len > state._end)
       return null;
     for (int i = 0; i < _len; i++) {
       if (state._text.charCodeAt(pos + i) != _string.charCodeAt(i))
         return null;
     }
     return [pos + _len, null];
   }
 
-  //get defaultValue() => _string;
+  //get defaultValue => _string;
 
   toString() => '"$_string"';
 
   description() => "'$_string'";
 }
 
 class _RegExpRule extends _Rule {
   RegExp _re;
   _RegExpRule(this._re) {
     // There is no convenient way to match an anchored substring.
@@ skipping 31 matching lines @@
 
   _match(_ParserState state, int pos) {
     var match = _rule.matchAfterWS(state, pos);
     if (match == null) {
       return null;
     }
     var endPos = match[0];
     return [endPos, _extract(state._text, pos, endPos)];
   }
 
-  bool get generatesValue() => true;
+  bool get generatesValue => true;
 
   toString() => 'TEXT($_rule)';
 }
 
 _Rule _compileMultiRule(List rules,
                         bool allowReducer,
                         finish(compiledRules, valueCount, reducer)) {
   int valueCount = 0;
   List compiledRules = new List<_Rule>();
   Function reducer;
@@ skipping 56 matching lines @@
       if (_generatingSubRules == 0)
         return [pos, null];
       if (_generatingSubRules == 1)
         return [pos, sequence[0]];
       return [pos, sequence];
     } else {
       return [pos, _apply(_reducer, sequence)];
     }
   }
 
-  bool get generatesValue() => _generatesValue;
+  bool get generatesValue => _generatesValue;
 
   toString() => _formatMultiRule('SEQ', _rules);
 }
 
 class _ChoiceRule extends _Rule {
   // This rule matches the first component rule that matches.
   List<_Rule> _rules;
   _ChoiceRule(List<_Rule> this._rules);
 
   _match(state, pos) {
     for (var rule in _rules) {
       var match = rule.match(state, pos);
       if (match != null) {
         /*
         if (!rule.generatesValue) {
           var value = rule.defaultValue;
           if (value != null)
             return [match[0], value];
         }
         */
         return match;
       }
     }
     return null;
   }
 
-  bool get generatesValue() => true;
+  bool get generatesValue => true;
 
   toString() => _formatMultiRule('OR', _rules);
 }
 
 class _OptionalRule extends _Rule {
   _Rule _rule;
   _OptionalRule(_Rule this._rule);
   _match(_ParserState state, int pos) {
     var match = _rule.match(state, pos);
     if (_rule.generatesValue)
       return match == null
           ? [pos, null]
           : match;
     return match == null
         ? [pos, false]
         : [match[0], true];
   }
 
-  bool get generatesValue() => true;
+  bool get generatesValue => true;
 
   toString() => 'MAYBE($_rule)';
 }
 
 class _ContextRule extends _Rule {
   _Rule _rule;
   _ContextRule(_Rule this._rule);
   _match(_ParserState state, int pos) {
     // TODO: protect error state.
     var match = _rule._match(state, pos);
@@ skipping 48 matching lines @@
         newPos = match[0];
       }
       match = _rule.match(state, newPos);
       if (match == null)
         return [pos, result];
       pos = match[0];
       result.add(match[1]);
     }
   }
 
-  bool get generatesValue() => true;
+  bool get generatesValue => true;
 
   toString() => 'MANY(min:$_min, $_rule${_separator==null?'':", sep: $_separator"})';
 }
 
 class _MemoRule extends _Rule {
   final _Rule _rule;
 
   var parseInstance;
 
   // A map from position to result.  Can this be replaced with something
@@ skipping 14 matching lines @@
     // inWhitespaceMode, error position info etc?)
     // Stored result can be null (memoized failure).
     if (map.containsKey(pos)) {
       return map[pos];
     }
     var match = _rule.match(state, pos);
     map[pos] = match;
     return match;
   }
 
-  bool get generatesValue() => _rule.generatesValue;
+  bool get generatesValue => _rule.generatesValue;
 
   toString() => 'MEMO($_rule)';
 }
 
 _apply(fn, List args) {
   switch (args.length) {
     case 0: return fn();
     case 1: return fn(args[0]);
     case 2: return fn(args[0], args[1]);
     case 3: return fn(args[0], args[1], args[2]);
@@ skipping 39 matching lines @@
   add(s);
   add(t);
   add(u);
   add(v);
   add(w);
   add(x);
   add(y);
   add(z);
   return list;
 }