Rename events.

pkg/dart_parser/lib/src/parser.dart

 // Copyright (c) 2012, 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 dart_parser;
 
 import 'package:dart_scanner/src/keyword.dart' show
     Keyword;
 
 import 'package:dart_scanner/src/precedence.dart' show
@@ skipping 449 matching lines @@
       thisKeyword = token;
       // TODO(ahe): Validate field initializers are only used in
       // constructors, and not for function-typed arguments.
       token = expect('.', token.next);
     }
     token = parseIdentifier(token);
     if (optional('(', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
-      listener.handleFunctionTypedFormalParameter(token);
+      listener.endFunctionTypedFormalParameter(token);
     } else if (optional('<', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
-      listener.handleFunctionTypedFormalParameter(token);
+      listener.endFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
         listener.reportError(
             equal, ErrorKind.RequiredParameterWithDefault);
@@ skipping 574 matching lines @@
       parseType(type);
       if (isVar) {
         listener.reportError(modifiers.head, ErrorKind.ExtraneousModifier,
             {'modifier': modifiers.head});
       }
     }
 
     Token token = parseIdentifier(name);
 
     int fieldCount = 1;
-    token = parseVariableInitializerOpt(token);
+    token = parseFieldInitializerOpt(token);
     while (optional(',', token)) {
       token = parseIdentifier(token.next);
-      token = parseVariableInitializerOpt(token);
+      token = parseFieldInitializerOpt(token);
       ++fieldCount;
     }
     Token semicolon = token;
     token = expectSemicolon(token);
     if (isTopLevel) {
       listener.endTopLevelFields(fieldCount, start, semicolon);
     } else {
       listener.endFields(fieldCount, start, semicolon);
     }
     return token;
@@ skipping 120 matching lines @@
             }
             token = beginGroup.endGroup;
           }
         }
       }
       token = token.next;
     }
     return const Link<Token>();
   }
 
+  Token parseFieldInitializerOpt(Token token) {
+    if (optional('=', token)) {
+      Token assignment = token;
+      listener.beginFieldInitializer(token);
+      token = parseExpression(token.next);
+      listener.endFieldInitializer(assignment);
+    }
+    return token;
+  }
+
   Token parseVariableInitializerOpt(Token token) {
     if (optional('=', token)) {
       Token assignment = token;
-      // TODO(ahe): Rename this to beginVariableInitializer.
-      listener.beginInitializer(token);
+      listener.beginVariableInitializer(token);
       token = parseExpression(token.next);
-      // TODO(ahe): Rename this to endVariableInitializer.
-      listener.endInitializer(assignment);
+      listener.endVariableInitializer(assignment);
     }
     return token;
   }
 
   Token parseInitializersOpt(Token token) {
     if (optional(':', token)) {
       return parseInitializers(token);
     } else {
       listener.handleNoInitializers();
       return token;
     }
   }
 
   Token parseInitializers(Token token) {
     Token begin = token;
     listener.beginInitializers(begin);
     expect(':', token);
     int count = 0;
     bool old = mayParseFunctionExpressions;
     mayParseFunctionExpressions = false;
     do {
       token = token.next;
-      listener.beginConstructorInitializer(token);
+      listener.beginInitializer(token);
       token = parseExpression(token);
-      listener.endConstructorInitializer(token);
+      listener.endInitializer(token);
       ++count;
     } while (optional(',', token));
     mayParseFunctionExpressions = old;
     listener.endInitializers(count, begin, token);
     return token;
   }
 
   Token parseLiteralStringOrRecoverExpression(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       return parseLiteralString(token);
@@ skipping 466 matching lines @@
     } else {
       if (identical(value, '=>')) {
         token = parseExpression(token.next);
         expectSemicolon(token);
       } else if (value == '=') {
         token = parseRedirectingFactoryBody(token);
         expectSemicolon(token);
       } else {
         token = skipBlock(token);
       }
-      listener.skippedFunctionBody(token);
+      listener.handleFunctionBodySkipped(token);
     }
     return token;
   }
 
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (optional(';', token)) {
       if (!allowAbstract) {
         listener.reportError(token, ErrorKind.ExpectedBody);
       }
       listener.endFunctionBody(0, null, token);
@@ skipping 1426 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }