diff --git a/pkg/analyzer/test/generated/parser_fasta_listener.dart b/pkg/analyzer/test/generated/parser_fasta_listener.dart
index 412de6e9be5..613cbb520cd 100644
--- a/pkg/analyzer/test/generated/parser_fasta_listener.dart
+++ b/pkg/analyzer/test/generated/parser_fasta_listener.dart
@@ -15,23 +15,44 @@ import 'package:test/test.dart';
  * Proxy implementation of the fasta parser listener that
  * asserts begin/end pairs of events and forwards all events
  * to the specified listener.
+ *
+ * When `parseUnit` is called, then all events are generated as expected.
+ * When "lower level" parse methods are called, then some "higher level"
+ * begin/end event pairs will not be generated. In this case,
+ * construct a new listener and call `begin('higher-level-event')`
+ * before calling the "lower level" parse method. Once the parse method returns,
+ * call `end('higher-level-event')` to assert that the stack is in the
+ * expected state.
+ *
+ * For example, when calling `parseTopLevelDeclaration`, the
+ * [beginCompilationUnit] and [endCompilationUnit] event pair is not generated.
+ * In this case, call `begin('CompilationUnit')` before calling
+ * `parseTopLevelDeclaration`, and call `end('CompilationUnit')` afterward.
+ *
+ * When calling `parseUnit`, do not call `begin` or `end`,
+ * but call `expectEmpty` after `parseUnit` returns.
  */
 class ForwardingTestListener implements fasta.Listener {
   final fasta.Listener listener;
   final _stack = <String>[];
 
-  void _begin(String event) {
+  void begin(String event) {
+    expect(event, isNotNull);
     _stack.add(event);
   }
 
-  void _in(String event) {
+  void expectEmpty() {
+    expect(_stack, isEmpty);
+  }
+
+  void expectIn(String event) {
     if (_stack.isEmpty || _stack.last != event) {
       fail('Expected $event, but found $_stack');
     }
   }
 
-  void _end(String event) {
-    _in(event);
+  void end(String event) {
+    expectIn(event);
     _stack.removeLast();
   }
 
@@ -40,493 +61,494 @@ class ForwardingTestListener implements fasta.Listener {
   @override
   void beginArguments(Token token) {
     listener.beginArguments(token);
-    _begin('Arguments');
+    begin('Arguments');
   }
 
   @override
   void beginAssert(Token assertKeyword, fasta.Assert kind) {
     listener.beginAssert(assertKeyword, kind);
-    _begin('Assert');
+    begin('Assert');
   }
 
   @override
   void beginAwaitExpression(Token token) {
     listener.beginAwaitExpression(token);
-    _begin('AwaitExpression');
+    begin('AwaitExpression');
   }
 
   @override
   void beginBlock(Token token) {
     listener.beginBlock(token);
-    _begin('Block');
+    begin('Block');
   }
 
   @override
   void beginBlockFunctionBody(Token token) {
     listener.beginBlockFunctionBody(token);
-    _begin('BlockFunctionBody');
+    begin('BlockFunctionBody');
   }
 
   @override
   void beginCascade(Token token) {
     listener.beginCascade(token);
-    _begin('Cascade');
+    begin('Cascade');
   }
 
   @override
   void beginCaseExpression(Token caseKeyword) {
     listener.beginCaseExpression(caseKeyword);
-    _begin('CaseExpression');
+    begin('CaseExpression');
   }
 
   @override
   void beginCatchClause(Token token) {
     listener.beginCatchClause(token);
-    _begin('CatchClause');
+    begin('CatchClause');
   }
 
   @override
   void beginClassBody(Token token) {
     listener.beginClassBody(token);
-    _begin('ClassBody');
+    begin('ClassBody');
   }
 
   @override
   void beginClassDeclaration(Token beginToken, Token name) {
     listener.beginClassDeclaration(beginToken, name);
-    _begin('ClassDeclaration');
+    begin('ClassDeclaration');
   }
 
   @override
   void beginClassOrNamedMixinApplication(Token token) {
     listener.beginClassOrNamedMixinApplication(token);
-    _begin('ClassOrNamedMixinApplication');
+    begin('ClassOrNamedMixinApplication');
   }
 
   @override
   void beginCombinators(Token token) {
     listener.beginCombinators(token);
-    _begin('Combinators');
+    begin('Combinators');
   }
 
   @override
   void beginCompilationUnit(Token token) {
+    expectEmpty();
     listener.beginCompilationUnit(token);
-    _begin('CompilationUnit');
+    begin('CompilationUnit');
   }
 
   @override
   void beginConditionalUri(Token ifKeyword) {
     listener.beginConditionalUri(ifKeyword);
-    _begin('ConditionalUri');
+    begin('ConditionalUri');
   }
 
   @override
   void beginConditionalUris(Token token) {
     listener.beginConditionalUris(token);
-    _begin('ConditionalUris');
+    begin('ConditionalUris');
   }
 
   @override
   void beginConstExpression(Token constKeyword) {
     listener.beginConstExpression(constKeyword);
-    _begin('ConstExpression');
+    begin('ConstExpression');
   }
 
   @override
   void beginConstLiteral(Token token) {
     listener.beginConstLiteral(token);
-    _begin('ConstLiteral');
+    begin('ConstLiteral');
   }
 
   @override
   void beginConstructorReference(Token start) {
     listener.beginConstructorReference(start);
-    _begin('ConstructorReference');
+    begin('ConstructorReference');
   }
 
   @override
   void beginDoWhileStatement(Token token) {
     listener.beginDoWhileStatement(token);
-    _begin('DoWhileStatement');
+    begin('DoWhileStatement');
   }
 
   @override
   void beginDoWhileStatementBody(Token token) {
     listener.beginDoWhileStatementBody(token);
-    _begin('DoWhileStatementBody');
+    begin('DoWhileStatementBody');
   }
 
   @override
   void beginDottedName(Token token) {
     listener.beginDottedName(token);
-    _begin('DottedName');
+    begin('DottedName');
   }
 
   @override
   void beginElseStatement(Token token) {
     listener.beginElseStatement(token);
-    _begin('ElseStatement');
+    begin('ElseStatement');
   }
 
   @override
   void beginEnum(Token enumKeyword) {
     listener.beginEnum(enumKeyword);
-    _begin('Enum');
+    begin('Enum');
   }
 
   @override
   void beginExport(Token token) {
     listener.beginExport(token);
-    _begin('Export');
+    begin('Export');
   }
 
   @override
   void beginExpressionStatement(Token token) {
     listener.beginExpressionStatement(token);
-    _begin('ExpressionStatement');
+    begin('ExpressionStatement');
   }
 
   @override
   void beginFactoryMethod(Token token) {
     listener.beginFactoryMethod(token);
-    _begin('FactoryMethod');
+    begin('FactoryMethod');
   }
 
   @override
   void beginFieldInitializer(Token token) {
     listener.beginFieldInitializer(token);
-    _begin('FieldInitializer');
+    begin('FieldInitializer');
   }
 
   @override
   void beginForInBody(Token token) {
     listener.beginForInBody(token);
-    _begin('ForInBody');
+    begin('ForInBody');
   }
 
   @override
   void beginForInExpression(Token token) {
     listener.beginForInExpression(token);
-    _begin('ForInExpression');
+    begin('ForInExpression');
   }
 
   @override
   void beginForStatement(Token token) {
     listener.beginForStatement(token);
-    _begin('ForStatement');
+    begin('ForStatement');
   }
 
   @override
   void beginForStatementBody(Token token) {
     listener.beginForStatementBody(token);
-    _begin('ForStatementBody');
+    begin('ForStatementBody');
   }
 
   @override
   void beginFormalParameter(Token token, fasta.MemberKind kind) {
     listener.beginFormalParameter(token, kind);
-    _begin('FormalParameter');
+    begin('FormalParameter');
   }
 
   @override
   void beginFormalParameters(Token token, fasta.MemberKind kind) {
     listener.beginFormalParameters(token, kind);
-    _begin('FormalParameters');
+    begin('FormalParameters');
   }
 
   @override
   void beginLocalFunctionDeclaration(Token token) {
     listener.beginLocalFunctionDeclaration(token);
-    _begin('LocalFunctionDeclaration');
+    begin('LocalFunctionDeclaration');
   }
 
   @override
   void beginFunctionExpression(Token token) {
     listener.beginFunctionExpression(token);
-    _begin('FunctionExpression');
+    begin('FunctionExpression');
   }
 
   @override
   void beginFunctionName(Token token) {
     listener.beginFunctionName(token);
-    _begin('FunctionName');
+    begin('FunctionName');
   }
 
   @override
   void beginFunctionType(Token beginToken) {
     listener.beginFunctionType(beginToken);
-    _begin('FunctionType');
+    begin('FunctionType');
   }
 
   @override
   void beginFunctionTypeAlias(Token token) {
     listener.beginFunctionTypeAlias(token);
-    _begin('FunctionTypeAlias');
+    begin('FunctionTypeAlias');
   }
 
   @override
   void beginFunctionTypedFormalParameter(Token token) {
     listener.beginFunctionTypedFormalParameter(token);
-    _begin('FunctionTypedFormalParameter');
+    begin('FunctionTypedFormalParameter');
   }
 
   @override
   void beginHide(Token hideKeyword) {
     listener.beginHide(hideKeyword);
-    _begin('Hide');
+    begin('Hide');
   }
 
   @override
   void beginIdentifierList(Token token) {
     listener.beginIdentifierList(token);
-    _begin('IdentifierList');
+    begin('IdentifierList');
   }
 
   @override
   void beginIfStatement(Token token) {
     listener.beginIfStatement(token);
-    _begin('IfStatement');
+    begin('IfStatement');
   }
 
   @override
   void beginImport(Token importKeyword) {
     listener.beginImport(importKeyword);
-    _begin('Import');
+    begin('Import');
   }
 
   @override
   void beginInitializedIdentifier(Token token) {
     listener.beginInitializedIdentifier(token);
-    _begin('InitializedIdentifier');
+    begin('InitializedIdentifier');
   }
 
   @override
   void beginInitializer(Token token) {
     listener.beginInitializer(token);
-    _begin('Initializer');
+    begin('Initializer');
   }
 
   @override
   void beginInitializers(Token token) {
     listener.beginInitializers(token);
-    _begin('Initializers');
+    begin('Initializers');
   }
 
   @override
   void beginLabeledStatement(Token token, int labelCount) {
     listener.beginLabeledStatement(token, labelCount);
-    _begin('LabeledStatement');
+    begin('LabeledStatement');
   }
 
   @override
   void beginLibraryName(Token token) {
     listener.beginLibraryName(token);
-    _begin('LibraryName');
+    begin('LibraryName');
   }
 
   @override
   void beginLiteralMapEntry(Token token) {
     listener.beginLiteralMapEntry(token);
-    _begin('LiteralMapEntry');
+    begin('LiteralMapEntry');
   }
 
   @override
   void beginLiteralString(Token token) {
     listener.beginLiteralString(token);
-    _begin('LiteralString');
+    begin('LiteralString');
   }
 
   @override
   void beginLiteralSymbol(Token token) {
     listener.beginLiteralSymbol(token);
-    _begin('LiteralSymbol');
+    begin('LiteralSymbol');
   }
 
   @override
   void beginMember(Token token) {
     listener.beginMember(token);
-    _begin('Member');
+    begin('Member');
   }
 
   @override
   void beginMetadata(Token token) {
     listener.beginMetadata(token);
-    _begin('Metadata');
+    begin('Metadata');
   }
 
   @override
   void beginMetadataStar(Token token) {
     listener.beginMetadataStar(token);
-    _begin('MetadataStar');
+    begin('MetadataStar');
   }
 
   @override
   void beginMethod(Token token, Token name) {
     listener.beginMethod(token, name);
-    _begin('Method');
+    begin('Method');
   }
 
   @override
   void beginMixinApplication(Token token) {
     listener.beginMixinApplication(token);
-    _begin('MixinApplication');
+    begin('MixinApplication');
   }
 
   @override
   void beginNamedFunctionExpression(Token token) {
     listener.beginNamedFunctionExpression(token);
-    _begin('NamedFunctionExpression');
+    begin('NamedFunctionExpression');
   }
 
   @override
   void beginNamedMixinApplication(Token beginToken, Token name) {
     listener.beginNamedMixinApplication(beginToken, name);
-    _begin('NamedMixinApplication');
+    begin('NamedMixinApplication');
   }
 
   @override
   void beginNewExpression(Token token) {
     listener.beginNewExpression(token);
-    _begin('NewExpression');
+    begin('NewExpression');
   }
 
   @override
   void beginOptionalFormalParameters(Token token) {
     listener.beginOptionalFormalParameters(token);
-    _begin('OptionalFormalParameters');
+    begin('OptionalFormalParameters');
   }
 
   @override
   void beginPart(Token token) {
     listener.beginPart(token);
-    _begin('Part');
+    begin('Part');
   }
 
   @override
   void beginPartOf(Token token) {
     listener.beginPartOf(token);
-    _begin('PartOf');
+    begin('PartOf');
   }
 
   @override
   void beginRedirectingFactoryBody(Token token) {
     listener.beginRedirectingFactoryBody(token);
-    _begin('RedirectingFactoryBody');
+    begin('RedirectingFactoryBody');
   }
 
   @override
   void beginRethrowStatement(Token token) {
     listener.beginRethrowStatement(token);
-    _begin('RethrowStatement');
+    begin('RethrowStatement');
   }
 
   @override
   void beginReturnStatement(Token token) {
     listener.beginReturnStatement(token);
-    _begin('ReturnStatement');
+    begin('ReturnStatement');
   }
 
   @override
   void beginShow(Token showKeyword) {
     listener.beginShow(showKeyword);
-    _begin('Show');
+    begin('Show');
   }
 
   @override
   void beginSwitchBlock(Token token) {
     listener.beginSwitchBlock(token);
-    _begin('SwitchBlock');
+    begin('SwitchBlock');
   }
 
   @override
   void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
     listener.beginSwitchCase(labelCount, expressionCount, firstToken);
-    _begin('SwitchCase');
+    begin('SwitchCase');
   }
 
   @override
   void beginSwitchStatement(Token token) {
     listener.beginSwitchStatement(token);
-    _begin('SwitchStatement');
+    begin('SwitchStatement');
   }
 
   @override
   void beginThenStatement(Token token) {
     listener.beginThenStatement(token);
-    _begin('ThenStatement');
+    begin('ThenStatement');
   }
 
   @override
   void beginTopLevelMember(Token token) {
     listener.beginTopLevelMember(token);
-    _begin('TopLevelMember');
+    begin('TopLevelMember');
   }
 
   @override
   void beginTopLevelMethod(Token token, Token name) {
     listener.beginTopLevelMethod(token, name);
-    _begin('TopLevelMethod');
+    begin('TopLevelMethod');
   }
 
   @override
   void beginTryStatement(Token token) {
     listener.beginTryStatement(token);
-    _begin('TryStatement');
+    begin('TryStatement');
   }
 
   @override
   void beginTypeArguments(Token token) {
     listener.beginTypeArguments(token);
-    _begin('TypeArguments');
+    begin('TypeArguments');
   }
 
   @override
   void beginTypeList(Token token) {
     listener.beginTypeList(token);
-    _begin('TypeList');
+    begin('TypeList');
   }
 
   @override
   void beginTypeVariable(Token token) {
     listener.beginTypeVariable(token);
-    _begin('TypeVariable');
+    begin('TypeVariable');
   }
 
   @override
   void beginTypeVariables(Token token) {
     listener.beginTypeVariables(token);
-    _begin('TypeVariables');
+    begin('TypeVariables');
   }
 
   @override
   void beginVariableInitializer(Token token) {
     listener.beginVariableInitializer(token);
-    _begin('VariableInitializer');
+    begin('VariableInitializer');
   }
 
   @override
   void beginVariablesDeclaration(Token token) {
     listener.beginVariablesDeclaration(token);
-    _begin('VariablesDeclaration');
+    begin('VariablesDeclaration');
   }
 
   @override
   void beginWhileStatement(Token token) {
     listener.beginWhileStatement(token);
-    _begin('WhileStatement');
+    begin('WhileStatement');
   }
 
   @override
   void beginWhileStatementBody(Token token) {
     listener.beginWhileStatementBody(token);
-    _begin('WhileStatementBody');
+    begin('WhileStatementBody');
   }
 
   @override
   void beginYieldStatement(Token token) {
     listener.beginYieldStatement(token);
-    _begin('YieldStatement');
+    begin('YieldStatement');
   }
 
   @override
@@ -537,57 +559,57 @@ class ForwardingTestListener implements fasta.Listener {
 
   @override
   void endArguments(int count, Token beginToken, Token endToken) {
-    _end('Arguments');
+    end('Arguments');
     listener.endArguments(count, beginToken, endToken);
   }
 
   @override
   void endAssert(Token assertKeyword, fasta.Assert kind, Token leftParenthesis,
       Token commaToken, Token rightParenthesis, Token semicolonToken) {
-    _end('Assert');
+    end('Assert');
     listener.endAssert(assertKeyword, kind, leftParenthesis, commaToken,
         rightParenthesis, semicolonToken);
   }
 
   @override
   void endAwaitExpression(Token beginToken, Token endToken) {
-    _end('AwaitExpression');
+    end('AwaitExpression');
     listener.endAwaitExpression(beginToken, endToken);
   }
 
   @override
   void endBlock(int count, Token beginToken, Token endToken) {
-    _end('Block');
+    end('Block');
     listener.endBlock(count, beginToken, endToken);
   }
 
   @override
   void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
-    _end('BlockFunctionBody');
+    end('BlockFunctionBody');
     listener.endBlockFunctionBody(count, beginToken, endToken);
   }
 
   @override
   void endCascade() {
-    _end('Cascade');
+    end('Cascade');
     listener.endCascade();
   }
 
   @override
   void endCaseExpression(Token colon) {
-    _end('CaseExpression');
+    end('CaseExpression');
     listener.endCaseExpression(colon);
   }
 
   @override
   void endCatchClause(Token token) {
-    _end('CatchClause');
+    end('CatchClause');
     listener.endCatchClause(token);
   }
 
   @override
   void endClassBody(int memberCount, Token beginToken, Token endToken) {
-    _end('ClassBody');
+    end('ClassBody');
     listener.endClassBody(memberCount, beginToken, endToken);
   }
 
@@ -599,394 +621,395 @@ class ForwardingTestListener implements fasta.Listener {
       Token extendsKeyword,
       Token implementsKeyword,
       Token endToken) {
-    _end('ClassDeclaration');
-    _end('ClassOrNamedMixinApplication');
+    end('ClassDeclaration');
+    end('ClassOrNamedMixinApplication');
     listener.endClassDeclaration(interfacesCount, beginToken, classKeyword,
         extendsKeyword, implementsKeyword, endToken);
   }
 
   @override
   void endCombinators(int count) {
-    _end('Combinators');
+    end('Combinators');
     listener.endCombinators(count);
   }
 
   @override
   void endCompilationUnit(int count, Token token) {
-    _end('CompilationUnit');
+    end('CompilationUnit');
     listener.endCompilationUnit(count, token);
+    expectEmpty();
   }
 
   @override
   void endConditionalUri(Token ifKeyword, Token equalitySign) {
-    _end('ConditionalUri');
+    end('ConditionalUri');
     listener.endConditionalUri(ifKeyword, equalitySign);
   }
 
   @override
   void endConditionalUris(int count) {
-    _end('ConditionalUris');
+    end('ConditionalUris');
     listener.endConditionalUris(count);
   }
 
   @override
   void endConstExpression(Token token) {
-    _end('ConstExpression');
+    end('ConstExpression');
     listener.endConstExpression(token);
   }
 
   @override
   void endConstLiteral(Token token) {
-    _end('ConstLiteral');
+    end('ConstLiteral');
     listener.endConstLiteral(token);
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
-    _end('ConstructorReference');
+    end('ConstructorReference');
     listener.endConstructorReference(start, periodBeforeName, endToken);
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
-    _end('DoWhileStatement');
+    end('DoWhileStatement');
     listener.endDoWhileStatement(doKeyword, whileKeyword, endToken);
   }
 
   @override
   void endDoWhileStatementBody(Token token) {
-    _end('DoWhileStatementBody');
+    end('DoWhileStatementBody');
     listener.endDoWhileStatementBody(token);
   }
 
   @override
   void endDottedName(int count, Token firstIdentifier) {
-    _end('DottedName');
+    end('DottedName');
     listener.endDottedName(count, firstIdentifier);
   }
 
   @override
   void endElseStatement(Token token) {
-    _end('ElseStatement');
+    end('ElseStatement');
     listener.endElseStatement(token);
   }
 
   @override
   void endEnum(Token enumKeyword, Token endBrace, int count) {
-    _end('Enum');
+    end('Enum');
     listener.endEnum(enumKeyword, endBrace, count);
   }
 
   @override
   void endExport(Token exportKeyword, Token semicolon) {
-    _end('Export');
+    end('Export');
     listener.endExport(exportKeyword, semicolon);
   }
 
   @override
   void endExpressionStatement(Token token) {
-    _end('ExpressionStatement');
+    end('ExpressionStatement');
     listener.endExpressionStatement(token);
   }
 
   @override
   void endFactoryMethod(
       Token beginToken, Token factoryKeyword, Token endToken) {
-    _end('FactoryMethod');
+    end('FactoryMethod');
     listener.endFactoryMethod(beginToken, factoryKeyword, endToken);
   }
 
   @override
   void endFieldInitializer(Token assignment, Token token) {
-    _end('FieldInitializer');
+    end('FieldInitializer');
     listener.endFieldInitializer(assignment, token);
   }
 
   @override
   void endFields(int count, Token beginToken, Token endToken) {
     // beginMember --> endFields, endMember
-    _in('Member');
+    expectIn('Member');
     listener.endFields(count, beginToken, endToken);
   }
 
   @override
   void endForIn(Token awaitToken, Token forToken, Token leftParenthesis,
       Token inKeyword, Token rightParenthesis, Token endToken) {
-    _end('ForStatement');
+    end('ForStatement');
     listener.endForIn(awaitToken, forToken, leftParenthesis, inKeyword,
         rightParenthesis, endToken);
   }
 
   @override
   void endForInBody(Token token) {
-    _end('ForInBody');
+    end('ForInBody');
     listener.endForInBody(token);
   }
 
   @override
   void endForInExpression(Token token) {
-    _end('ForInExpression');
+    end('ForInExpression');
     listener.endForInExpression(token);
   }
 
   @override
   void endForStatement(Token forKeyword, Token leftSeparator,
       int updateExpressionCount, Token endToken) {
-    _end('ForStatement');
+    end('ForStatement');
     listener.endForStatement(
         forKeyword, leftSeparator, updateExpressionCount, endToken);
   }
 
   @override
   void endForStatementBody(Token token) {
-    _end('ForStatementBody');
+    end('ForStatementBody');
     listener.endForStatementBody(token);
   }
 
   @override
   void endFormalParameter(Token thisKeyword, Token nameToken,
       fasta.FormalParameterKind kind, fasta.MemberKind memberKind) {
-    _end('FormalParameter');
+    end('FormalParameter');
     listener.endFormalParameter(thisKeyword, nameToken, kind, memberKind);
   }
 
   @override
   void endFormalParameters(
       int count, Token beginToken, Token endToken, fasta.MemberKind kind) {
-    _end('FormalParameters');
+    end('FormalParameters');
     listener.endFormalParameters(count, beginToken, endToken, kind);
   }
 
   @override
   void endLocalFunctionDeclaration(Token endToken) {
-    _end('LocalFunctionDeclaration');
+    end('LocalFunctionDeclaration');
     listener.endLocalFunctionDeclaration(endToken);
   }
 
   @override
   void endFunctionExpression(Token beginToken, Token token) {
-    _end('FunctionExpression');
+    end('FunctionExpression');
     listener.endFunctionExpression(beginToken, token);
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
-    _end('FunctionName');
+    end('FunctionName');
     listener.endFunctionName(beginToken, token);
   }
 
   @override
   void endFunctionType(Token functionToken, Token endToken) {
-    _end('FunctionType');
+    end('FunctionType');
     listener.endFunctionType(functionToken, endToken);
   }
 
   @override
   void endFunctionTypeAlias(
       Token typedefKeyword, Token equals, Token endToken) {
-    _end('FunctionTypeAlias');
+    end('FunctionTypeAlias');
     listener.endFunctionTypeAlias(typedefKeyword, equals, endToken);
   }
 
   @override
   void endFunctionTypedFormalParameter() {
-    _end('FunctionTypedFormalParameter');
+    end('FunctionTypedFormalParameter');
     listener.endFunctionTypedFormalParameter();
   }
 
   @override
   void endHide(Token hideKeyword) {
-    _end('Hide');
+    end('Hide');
     listener.endHide(hideKeyword);
   }
 
   @override
   void endIdentifierList(int count) {
-    _end('IdentifierList');
+    end('IdentifierList');
     listener.endIdentifierList(count);
   }
 
   @override
   void endIfStatement(Token ifToken, Token elseToken) {
-    _end('IfStatement');
+    end('IfStatement');
     listener.endIfStatement(ifToken, elseToken);
   }
 
   @override
   void endImport(Token importKeyword, Token DeferredKeyword, Token asKeyword,
       Token semicolon) {
-    _end('Import');
+    end('Import');
     listener.endImport(importKeyword, DeferredKeyword, asKeyword, semicolon);
   }
 
   @override
   void endInitializedIdentifier(Token nameToken) {
-    _end('InitializedIdentifier');
+    end('InitializedIdentifier');
     listener.endInitializedIdentifier(nameToken);
   }
 
   @override
   void endInitializer(Token token) {
-    _end('Initializer');
+    end('Initializer');
     listener.endInitializer(token);
   }
 
   @override
   void endInitializers(int count, Token beginToken, Token endToken) {
-    _end('Initializers');
+    end('Initializers');
     listener.endInitializers(count, beginToken, endToken);
   }
 
   @override
   void endLabeledStatement(int labelCount) {
-    _end('LabeledStatement');
+    end('LabeledStatement');
     listener.endLabeledStatement(labelCount);
   }
 
   @override
   void endLibraryName(Token libraryKeyword, Token semicolon) {
-    _end('LibraryName');
+    end('LibraryName');
     listener.endLibraryName(libraryKeyword, semicolon);
   }
 
   @override
   void endLiteralMapEntry(Token colon, Token endToken) {
-    _end('LiteralMapEntry');
+    end('LiteralMapEntry');
     listener.endLiteralMapEntry(colon, endToken);
   }
 
   @override
   void endLiteralString(int interpolationCount, Token endToken) {
-    _end('LiteralString');
+    end('LiteralString');
     listener.endLiteralString(interpolationCount, endToken);
   }
 
   @override
   void endLiteralSymbol(Token hashToken, int identifierCount) {
-    _end('LiteralSymbol');
+    end('LiteralSymbol');
     listener.endLiteralSymbol(hashToken, identifierCount);
   }
 
   @override
   void endMember() {
-    _end('Member');
+    end('Member');
     listener.endMember();
   }
 
   @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
-    _end('Metadata');
+    end('Metadata');
     listener.endMetadata(beginToken, periodBeforeName, endToken);
   }
 
   @override
   void endMetadataStar(int count, bool forParameter) {
-    _end('MetadataStar');
+    end('MetadataStar');
     listener.endMetadataStar(count, forParameter);
   }
 
   @override
   void endMethod(Token getOrSet, Token beginToken, Token endToken) {
-    _end('Method');
+    end('Method');
     listener.endMethod(getOrSet, beginToken, endToken);
   }
 
   @override
   void endMixinApplication(Token withKeyword) {
-    _end('MixinApplication');
+    end('MixinApplication');
     listener.endMixinApplication(withKeyword);
   }
 
   @override
   void endNamedFunctionExpression(Token endToken) {
-    _end('NamedFunctionExpression');
+    end('NamedFunctionExpression');
     listener.endNamedFunctionExpression(endToken);
   }
 
   @override
   void endNamedMixinApplication(Token begin, Token classKeyword, Token equals,
       Token implementsKeyword, Token endToken) {
-    _end('NamedMixinApplication');
-    _end('ClassOrNamedMixinApplication');
+    end('NamedMixinApplication');
+    end('ClassOrNamedMixinApplication');
     listener.endNamedMixinApplication(
         begin, classKeyword, equals, implementsKeyword, endToken);
   }
 
   @override
   void endNewExpression(Token token) {
-    _end('NewExpression');
+    end('NewExpression');
     listener.endNewExpression(token);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
-    _end('OptionalFormalParameters');
+    end('OptionalFormalParameters');
     listener.endOptionalFormalParameters(count, beginToken, endToken);
   }
 
   @override
   void endPart(Token partKeyword, Token semicolon) {
-    _end('Part');
+    end('Part');
     listener.endPart(partKeyword, semicolon);
   }
 
   @override
   void endPartOf(Token partKeyword, Token semicolon, bool hasName) {
-    _end('PartOf');
+    end('PartOf');
     listener.endPartOf(partKeyword, semicolon, hasName);
   }
 
   @override
   void endRedirectingFactoryBody(Token beginToken, Token endToken) {
-    _end('RedirectingFactoryBody');
+    end('RedirectingFactoryBody');
     listener.endRedirectingFactoryBody(beginToken, endToken);
   }
 
   @override
   void endRethrowStatement(Token rethrowToken, Token endToken) {
-    _end('RethrowStatement');
+    end('RethrowStatement');
     listener.endRethrowStatement(rethrowToken, endToken);
   }
 
   @override
   void endReturnStatement(
       bool hasExpression, Token beginToken, Token endToken) {
-    _end('ReturnStatement');
+    end('ReturnStatement');
     listener.endReturnStatement(hasExpression, beginToken, endToken);
   }
 
   @override
   void endShow(Token showKeyword) {
-    _end('Show');
+    end('Show');
     listener.endShow(showKeyword);
   }
 
   @override
   void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
-    _end('SwitchBlock');
+    end('SwitchBlock');
     listener.endSwitchBlock(caseCount, beginToken, endToken);
   }
 
   @override
   void endSwitchCase(int labelCount, int expressionCount, Token defaultKeyword,
       int statementCount, Token firstToken, Token endToken) {
-    _end('SwitchCase');
+    end('SwitchCase');
     listener.endSwitchCase(labelCount, expressionCount, defaultKeyword,
         statementCount, firstToken, endToken);
   }
 
   @override
   void endSwitchStatement(Token switchKeyword, Token endToken) {
-    _end('SwitchStatement');
+    end('SwitchStatement');
     listener.endSwitchStatement(switchKeyword, endToken);
   }
 
   @override
   void endThenStatement(Token token) {
-    _end('ThenStatement');
+    end('ThenStatement');
     listener.endThenStatement(token);
   }
 
@@ -994,79 +1017,80 @@ class ForwardingTestListener implements fasta.Listener {
   void endTopLevelDeclaration(Token token) {
     // There is no corresponding beginTopLevelDeclaration
     //_expectBegin('TopLevelDeclaration');
+    expectIn('CompilationUnit');
     listener.endTopLevelDeclaration(token);
   }
 
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
-    _end('TopLevelMember');
+    end('TopLevelMember');
     listener.endTopLevelFields(count, beginToken, endToken);
   }
 
   @override
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
-    _end('TopLevelMethod');
-    _end('TopLevelMember');
+    end('TopLevelMethod');
+    end('TopLevelMember');
     listener.endTopLevelMethod(beginToken, getOrSet, endToken);
   }
 
   @override
   void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
-    _end('TryStatement');
+    end('TryStatement');
     listener.endTryStatement(catchCount, tryKeyword, finallyKeyword);
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
-    _end('TypeArguments');
+    end('TypeArguments');
     listener.endTypeArguments(count, beginToken, endToken);
   }
 
   @override
   void endTypeList(int count) {
-    _end('TypeList');
+    end('TypeList');
     listener.endTypeList(count);
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
-    _end('TypeVariable');
+    end('TypeVariable');
     listener.endTypeVariable(token, extendsOrSuper);
   }
 
   @override
   void endTypeVariables(int count, Token beginToken, Token endToken) {
-    _end('TypeVariables');
+    end('TypeVariables');
     listener.endTypeVariables(count, beginToken, endToken);
   }
 
   @override
   void endVariableInitializer(Token assignmentOperator) {
-    _end('VariableInitializer');
+    end('VariableInitializer');
     listener.endVariableInitializer(assignmentOperator);
   }
 
   @override
   void endVariablesDeclaration(int count, Token endToken) {
-    _end('VariablesDeclaration');
+    end('VariablesDeclaration');
     listener.endVariablesDeclaration(count, endToken);
   }
 
   @override
   void endWhileStatement(Token whileKeyword, Token endToken) {
-    _end('WhileStatement');
+    end('WhileStatement');
     listener.endWhileStatement(whileKeyword, endToken);
   }
 
   @override
   void endWhileStatementBody(Token token) {
-    _end('WhileStatementBody');
+    end('WhileStatementBody');
     listener.endWhileStatementBody(token);
   }
 
   @override
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
-    _end('YieldStatement');
+    end('YieldStatement');
     listener.endYieldStatement(yieldToken, starToken, endToken);
   }
 
diff --git a/pkg/analyzer/test/generated/parser_fasta_test.dart b/pkg/analyzer/test/generated/parser_fasta_test.dart
index 61508ae31f3..81d6fc71c9f 100644
--- a/pkg/analyzer/test/generated/parser_fasta_test.dart
+++ b/pkg/analyzer/test/generated/parser_fasta_test.dart
@@ -467,12 +467,12 @@ class FastaParserTestCase extends Object
 
   @override
   CompilationUnitMember parseFullCompilationUnitMember() {
-    return _parserProxy._run((parser) => parser.parseTopLevelDeclaration);
+    return _parserProxy.parseTopLevelDeclaration();
   }
 
   @override
   Directive parseFullDirective() {
-    return _parserProxy._run((parser) => parser.parseTopLevelDeclaration);
+    return _parserProxy.parseTopLevelDeclaration();
   }
 
   @override
@@ -792,6 +792,8 @@ class ParserProxy implements analyzer.Parser {
    */
   final GatheringErrorListener _errorListener;
 
+  final ForwardingTestListener _eventListener;
+
   /**
    * Creates a [ParserProxy] which is prepared to begin parsing at the given
    * Fasta token.
@@ -807,28 +809,40 @@ class ParserProxy implements analyzer.Parser {
     var astBuilder =
         new AstBuilder(errorReporter, library, member, scope, true);
     astBuilder.parseGenericMethodComments = enableGenericMethodComments;
-    var fastaParser = new fasta.Parser(new ForwardingTestListener(astBuilder));
+    var eventListener = new ForwardingTestListener(astBuilder);
+    var fastaParser = new fasta.Parser(eventListener);
     astBuilder.parser = fastaParser;
     return new ParserProxy._(
-        startingToken, fastaParser, astBuilder, errorListener);
+        startingToken, fastaParser, astBuilder, errorListener, eventListener);
   }
 
   ParserProxy._(this._currentFastaToken, this._fastaParser, this._astBuilder,
-      this._errorListener);
+      this._errorListener, this._eventListener);
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   ClassMember parseClassMember(String className) {
     _astBuilder.className = className;
+    _eventListener.begin('CompilationUnit');
     var result = _run((parser) => parser.parseMember) as ClassMember;
+    _eventListener.end('CompilationUnit');
     _astBuilder.className = null;
     return result;
   }
 
   @override
   CompilationUnit parseCompilationUnit2() {
-    return _run((parser) => parser.parseUnit) as CompilationUnit;
+    var result = _run((parser) => parser.parseUnit) as CompilationUnit;
+    _eventListener.expectEmpty();
+    return result;
+  }
+
+  AnnotatedNode parseTopLevelDeclaration() {
+    _eventListener.begin('CompilationUnit');
+    var result = _run((parser) => parser.parseTopLevelDeclaration);
+    _eventListener.end('CompilationUnit');
+    return result;
   }
 
   /**