Add --ast to mini_parser.dart.

dart/frog/leg/scanner/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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list.
  */
 class Parser {
   final Listener listener;
@@ skipping 160 matching lines @@
   Token skipBlock(Token token) {
     if (!optional('{', token)) {
       return listener.expectedBlock(token);
     }
     BeginGroupToken beginGroupToken = token;
     assert(beginGroupToken.endGroup === null ||
            beginGroupToken.endGroup.kind === $CLOSE_CURLY_BRACKET);
     return beginGroupToken.endGroup;
   }
 
-  Token skipFormals(BeginGroupToken token) {
-    expect('(', token);
-    return token.endGroup;
-  }
-
   Token parseClass(Token token) {
     Token begin = token;
     listener.beginClassDeclaration(token);
     if (optional('abstract', token)) {
       // TODO(ahe): Notify listener about abstract modifier.
       token = token.next;
     }
     token = parseIdentifier(token.next);
     token = parseTypeVariablesOpt(token);
     Token extendsKeyword;
@@ skipping 164 matching lines @@
       int fieldCount = 1;
       token = parseFieldInitializerOpt(token);
       while (optional(',', token)) {
         token = parseIdentifier(token.next);
         token = parseFieldInitializerOpt(token);
         ++fieldCount;
       }
       expectSemicolon(token);
       listener.endTopLevelFields(fieldCount, start, token);
     } else {
-      token = skipFormals(token).next;
+      token = parseFormalParameters(token);
       token = parseFunctionBody(token, false);
       listener.endTopLevelMethod(start, token);
     }
     return token.next;
   }
 
   Token parseFieldInitializerOpt(Token token) {
     if (optional('=', token)) {
       return parseExpression(token.next);
     } else {
@@ skipping 143 matching lines @@
       token = parseFieldInitializerOpt(token);
       while (optional(',', token)) {
         // TODO(ahe): Count these.
         token = parseIdentifier(token.next);
         token = parseFieldInitializerOpt(token);
         ++fieldCount;
       }
       expectSemicolon(token);
       listener.endFields(fieldCount, start, token);
     } else {
-      token = skipFormals(token).next;
+      token = parseFormalParameters(token);
       token = parseInitializersOpt(token);
-      if (!optional(';', token)) {
-        token = parseFunctionBody(token, false);
-      }
+      token = parseFunctionBody(token, false);
       listener.endMethod(start, token);
     }
     return token.next;
   }
 
   Token parseFactoryMethod(Token token) {
     assert(optional('factory', token));
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = token.next; // Skip 'factory'.
@@ skipping 56 matching lines @@
     token = parseFormalParameters(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true);
     listener.endFunction(token);
     return isBlock ? token.next : token;
   }
 
   Token parseFunctionBody(Token token, bool isExpression) {
     if (optional(';', token)) {
       listener.endFunctionBody(0, null, token);
-      return token.next;
+      return token;
     } else if (optional('=>', token)) {
       Token begin = token;
       token = parseExpression(token.next);
       if (!isExpression) {
         expectSemicolon(token);
         listener.endReturnStatement(true, begin, token);
       } else {
         listener.endReturnStatement(true, begin, null);
       }
       return token;
@@ skipping 301 matching lines @@
                (kind === OPEN_CURLY_BRACKET_TOKEN) ||
                token.stringValue === '[]') {
       return parseLiteralListOrMap(token);
     } else {
       listener.unexpected(token);
       throw 'not yet implemented';
     }
   }
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
-    Token beginGroup = token;
+    BeginGroupToken beginGroup = token;
     int kind = beginGroup.endGroup.next.kind;
     if (mayParseFunctionExpressions &&
         (kind === FUNCTION_TOKEN || kind === OPEN_CURLY_BRACKET_TOKEN)) {
       return parseUnamedFunction(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
@@ skipping 469 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }