Get rid of a lot of () for getters.

samples/markdown/block_parser.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.
 
 /// The line contains only whitespace or is empty.
 const _RE_EMPTY = const RegExp(@'^([ \t]*)$');
 
 /// A series of `=` or `-` (on the next line) define setext-style headers.
 const _RE_SETEXT = const RegExp(@'^((=+)|(-+))$');
 
@@ skipping 34 matching lines @@
   /// The markdown document this parser is parsing.
   final Document document;
 
   /// Index of the current line.
   int pos;
 
   BlockParser(this.lines, this.document)
     : pos = 0;
 
   /// Gets the current line.
-  String get current() => lines[pos];
+  String get current => lines[pos];
 
   /// Gets the line after the current one or `null` if there is none.
-  String get next() {
+  String get next {
     // Don't read past the end.
     if (pos >= lines.length - 1) return null;
     return lines[pos + 1];
   }
 
   void advance() {
     pos++;
   }
 
-  bool get isDone() => pos >= lines.length;
+  bool get isDone => pos >= lines.length;
 
   /// Gets whether or not the current line matches the given pattern.
   bool matches(RegExp regex) {
     if (isDone) return false;
     return regex.firstMatch(current) != null;
   }
 
   /// Gets whether or not the current line matches the given pattern.
   bool matchesNext(RegExp regex) {
     if (next == null) return false;
     return regex.firstMatch(next) != null;
   }
 }
 
 class BlockSyntax {
   /// Gets the collection of built-in block parsers. To turn a series of lines
   /// into blocks, each of these will be tried in turn. Order matters here.
-  static List<BlockSyntax> get syntaxes() {
+  static List<BlockSyntax> get syntaxes {
     // Lazy initialize.
     if (_syntaxes == null) {
       _syntaxes = [
           new EmptyBlockSyntax(),
           new BlockHtmlSyntax(),
           new SetextHeaderSyntax(),
           new HeaderSyntax(),
           new CodeBlockSyntax(),
           new BlockquoteSyntax(),
           new HorizontalRuleSyntax(),
           new UnorderedListSyntax(),
           new OrderedListSyntax(),
           new ParagraphSyntax()
         ];
     }
 
     return _syntaxes;
   }
 
   static List<BlockSyntax> _syntaxes;
 
   /// Gets the regex used to identify the beginning of this block, if any.
-  RegExp get pattern() => null;
+  RegExp get pattern => null;
 
-  bool get canEndBlock() => true;
+  bool get canEndBlock => true;
 
   bool canParse(BlockParser parser) {
     return pattern.firstMatch(parser.current) != null;
   }
 
   abstract Node parse(BlockParser parser);
 
   List<String> parseChildLines(BlockParser parser) {
     // Grab all of the lines that form the blockquote, stripping off the ">".
     final childLines = <String>[];
 
     while (!parser.isDone) {
       final match = pattern.firstMatch(parser.current);
       if (match == null) break;
       childLines.add(match[1]);
       parser.advance();
     }
 
     return childLines;
   }
 
   /// Gets whether or not [parser]'s current line should end the previous block.
   static bool isAtBlockEnd(BlockParser parser) {
     if (parser.isDone) return true;
     return syntaxes.some((s) => s.canParse(parser) && s.canEndBlock);
   }
 }
 
 class EmptyBlockSyntax extends BlockSyntax {
-  RegExp get pattern() => _RE_EMPTY;
+  RegExp get pattern => _RE_EMPTY;
 
   Node parse(BlockParser parser) {
     parser.advance();
 
     // Don't actually emit anything.
     return null;
   }
 }
 
 /// Parses setext-style headers.
@@ skipping 11 matching lines @@
     final contents = parser.document.parseInline(parser.current);
     parser.advance();
     parser.advance();
 
     return new Element(tag, contents);
   }
 }
 
 /// Parses atx-style headers: `## Header ##`.
 class HeaderSyntax extends BlockSyntax {
-  RegExp get pattern() => _RE_HEADER;
+  RegExp get pattern => _RE_HEADER;
 
   Node parse(BlockParser parser) {
     final match = pattern.firstMatch(parser.current);
     parser.advance();
     final level = match[1].length;
     final contents = parser.document.parseInline(match[2].trim());
     return new Element('h$level', contents);
   }
 }
 
 /// Parses email-style blockquotes: `> quote`.
 class BlockquoteSyntax extends BlockSyntax {
-  RegExp get pattern() => _RE_BLOCKQUOTE;
+  RegExp get pattern => _RE_BLOCKQUOTE;
 
   Node parse(BlockParser parser) {
     final childLines = parseChildLines(parser);
 
     // Recursively parse the contents of the blockquote.
     final children = parser.document.parseLines(childLines);
 
     return new Element('blockquote', children);
   }
 }
 
 /// Parses preformatted code blocks that are indented four spaces.
 class CodeBlockSyntax extends BlockSyntax {
-  RegExp get pattern() => _RE_INDENT;
+  RegExp get pattern => _RE_INDENT;
 
   Node parse(BlockParser parser) {
     final childLines = parseChildLines(parser);
 
     // The Markdown tests expect a trailing newline.
     childLines.add('');
 
     // Escape the code.
     final escaped = escapeHtml(Strings.join(childLines, '\n'));
 
     return new Element('pre', [new Element.text('code', escaped)]);
   }
 }
 
 /// Parses horizontal rules like `---`, `_ _ _`, `*  *  *`, etc.
 class HorizontalRuleSyntax extends BlockSyntax {
-  RegExp get pattern() => _RE_HR;
+  RegExp get pattern => _RE_HR;
 
   Node parse(BlockParser parser) {
     final match = pattern.firstMatch(parser.current);
     parser.advance();
     return new Element.empty('hr');
   }
 }
 
 /// Parses inline HTML at the block level. This differs from other markdown
 /// implementations in several ways:
 ///
 /// 1.  This one is way way WAY simpler.
 /// 2.  All HTML tags at the block level will be treated as blocks. If you
 ///     start a paragraph with `<em>`, it will not wrap it in a `<p>` for you.
 ///     As soon as it sees something like HTML, it stops mucking with it until
 ///     it hits the next block.
 /// 3.  Absolutely no HTML parsing or validation is done. We're a markdown
 ///     parser not an HTML parser!
 class BlockHtmlSyntax extends BlockSyntax {
-  RegExp get pattern() => _RE_HTML;
+  RegExp get pattern => _RE_HTML;
 
-  bool get canEndBlock() => false;
+  bool get canEndBlock => false;
 
   Node parse(BlockParser parser) {
     final childLines = [];
 
     // Eat until we hit a blank line.
     while (!parser.isDone && !parser.matches(_RE_EMPTY)) {
       childLines.add(parser.current);
       parser.advance();
     }
 
     return new Text(Strings.join(childLines, '\n'));
   }
 }
 
 class ListItem {
   bool forceBlock = false;
   final List<String> lines;
 
   ListItem(this.lines);
 }
 
 /// Base class for both ordered and unordered lists.
 class ListSyntax extends BlockSyntax {
-  bool get canEndBlock() => false;
+  bool get canEndBlock => false;
 
-  abstract String get listTag();
+  abstract String get listTag;
 
   Node parse(BlockParser parser) {
     final items = <ListItem>[];
     var childLines = <String>[];
 
     endItem() {
       if (childLines.length > 0) {
         items.add(new ListItem(childLines));
         childLines = <String>[];
       }
@@ skipping 121 matching lines @@
         itemNodes.add(new Element('li', contents));
       }
     }
 
     return new Element(listTag, itemNodes);
   }
 }
 
 /// Parses unordered lists.
 class UnorderedListSyntax extends ListSyntax {
-  RegExp get pattern() => _RE_UL;
-  String get listTag() => 'ul';
+  RegExp get pattern => _RE_UL;
+  String get listTag => 'ul';
 }
 
 /// Parses ordered lists.
 class OrderedListSyntax extends ListSyntax {
-  RegExp get pattern() => _RE_OL;
-  String get listTag() => 'ol';
+  RegExp get pattern => _RE_OL;
+  String get listTag => 'ol';
 }
 
 /// Parses paragraphs of regular text.
 class ParagraphSyntax extends BlockSyntax {
-  bool get canEndBlock() => false;
+  bool get canEndBlock => false;
 
   bool canParse(BlockParser parser) => true;
 
   Node parse(BlockParser parser) {
     final childLines = [];
 
     // Eat until we hit something that ends a paragraph.
     while (!BlockSyntax.isAtBlockEnd(parser)) {
       childLines.add(parser.current);
       parser.advance();
     }
 
     final contents = parser.document.parseInline(
         Strings.join(childLines, '\n'));
     return new Element('p', contents);
   }
 }