Index: pkg/analyzer/test/generated/parser_fasta_listener.dart |
diff --git a/pkg/analyzer/test/generated/parser_fasta_listener.dart b/pkg/analyzer/test/generated/parser_fasta_listener.dart |
index 412de6e9be5baef55918b9ddbb496ff3d2372939..613cbb520cd264388e95632c61a1133ab47d905e 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); |
} |