// Copyright (c) 2020, 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.

import 'package:_fe_analyzer_shared/src/parser/assert.dart';
import 'package:_fe_analyzer_shared/src/parser/block_kind.dart';
import 'package:_fe_analyzer_shared/src/parser/declaration_kind.dart';
import 'package:_fe_analyzer_shared/src/parser/formal_parameter_kind.dart';
import 'package:_fe_analyzer_shared/src/parser/identifier_context.dart';
import 'package:_fe_analyzer_shared/src/parser/listener.dart';
import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
import 'package:_fe_analyzer_shared/src/scanner/error_token.dart';
import 'package:_fe_analyzer_shared/src/scanner/token.dart';
import 'package:front_end/src/fasta/messages.dart';

// THIS FILE IS AUTO GENERATED BY
// 'tool/_fasta/direct_parser_ast_helper_creator.dart'
// Run e.g.
/*
   out/ReleaseX64/dart \
     pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart \
      > pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
*/

class DirectParserASTContent {
  final String what;
  final DirectParserASTType type;
  final Map<String, Object> arguments;
  List<DirectParserASTContent> content;

  DirectParserASTContent(this.what, this.type, this.arguments);

  // TODO(jensj): Compare two ASTs.
}

enum DirectParserASTType { BEGIN, END, HANDLE, DONE }

abstract class AbstractDirectParserASTListener implements Listener {
  List<DirectParserASTContent> data = [];

  void seen(
      String what, DirectParserASTType type, Map<String, Object> arguments);

  void beginArguments(Token token) {
    seen("Arguments", DirectParserASTType.BEGIN, {"token": token});
  }

  void endArguments(int count, Token beginToken, Token endToken) {
    seen("Arguments", DirectParserASTType.END,
        {"count": count, "beginToken": beginToken, "endToken": endToken});
  }

  void handleAsyncModifier(Token asyncToken, Token starToken) {
    seen("AsyncModifier", DirectParserASTType.HANDLE,
        {"asyncToken": asyncToken, "starToken": starToken});
  }

  void beginAwaitExpression(Token token) {
    seen("AwaitExpression", DirectParserASTType.BEGIN, {"token": token});
  }

  void endAwaitExpression(Token beginToken, Token endToken) {
    seen("AwaitExpression", DirectParserASTType.END,
        {"beginToken": beginToken, "endToken": endToken});
  }

  void endInvalidAwaitExpression(
      Token beginToken, Token endToken, MessageCode errorCode) {
    seen("InvalidAwaitExpression", DirectParserASTType.END, {
      "beginToken": beginToken,
      "endToken": endToken,
      "errorCode": errorCode
    });
  }

  void beginBlock(Token token, BlockKind blockKind) {
    seen("Block", DirectParserASTType.BEGIN,
        {"token": token, "blockKind": blockKind});
  }

  void endBlock(
      int count, Token beginToken, Token endToken, BlockKind blockKind) {
    seen("Block", DirectParserASTType.END, {
      "count": count,
      "beginToken": beginToken,
      "endToken": endToken,
      "blockKind": blockKind
    });
  }

  void handleInvalidTopLevelBlock(Token token) {
    seen("InvalidTopLevelBlock", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginCascade(Token token) {
    seen("Cascade", DirectParserASTType.BEGIN, {"token": token});
  }

  void endCascade() {
    seen("Cascade", DirectParserASTType.END, {});
  }

  void beginCaseExpression(Token caseKeyword) {
    seen("CaseExpression", DirectParserASTType.BEGIN,
        {"caseKeyword": caseKeyword});
  }

  void endCaseExpression(Token colon) {
    seen("CaseExpression", DirectParserASTType.END, {"colon": colon});
  }

  void beginClassOrMixinBody(DeclarationKind kind, Token token) {
    seen("ClassOrMixinBody", DirectParserASTType.BEGIN,
        {"kind": kind, "token": token});
  }

  void endClassOrMixinBody(
      DeclarationKind kind, int memberCount, Token beginToken, Token endToken) {
    seen("ClassOrMixinBody", DirectParserASTType.END, {
      "kind": kind,
      "memberCount": memberCount,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void beginClassOrNamedMixinApplicationPrelude(Token token) {
    seen("ClassOrNamedMixinApplicationPrelude", DirectParserASTType.BEGIN,
        {"token": token});
  }

  void beginClassDeclaration(Token begin, Token abstractToken, Token name) {
    seen("ClassDeclaration", DirectParserASTType.BEGIN,
        {"begin": begin, "abstractToken": abstractToken, "name": name});
  }

  void handleClassExtends(Token extendsKeyword, int typeCount) {
    seen("ClassExtends", DirectParserASTType.HANDLE,
        {"extendsKeyword": extendsKeyword, "typeCount": typeCount});
  }

  void handleClassOrMixinImplements(
      Token implementsKeyword, int interfacesCount) {
    seen("ClassOrMixinImplements", DirectParserASTType.HANDLE, {
      "implementsKeyword": implementsKeyword,
      "interfacesCount": interfacesCount
    });
  }

  void handleClassHeader(Token begin, Token classKeyword, Token nativeToken) {
    seen("ClassHeader", DirectParserASTType.HANDLE, {
      "begin": begin,
      "classKeyword": classKeyword,
      "nativeToken": nativeToken
    });
  }

  void handleRecoverClassHeader() {
    seen("RecoverClassHeader", DirectParserASTType.HANDLE, {});
  }

  void endClassDeclaration(Token beginToken, Token endToken) {
    seen("ClassDeclaration", DirectParserASTType.END,
        {"beginToken": beginToken, "endToken": endToken});
  }

  void beginMixinDeclaration(Token mixinKeyword, Token name) {
    seen("MixinDeclaration", DirectParserASTType.BEGIN,
        {"mixinKeyword": mixinKeyword, "name": name});
  }

  void handleMixinOn(Token onKeyword, int typeCount) {
    seen("MixinOn", DirectParserASTType.HANDLE,
        {"onKeyword": onKeyword, "typeCount": typeCount});
  }

  void handleMixinHeader(Token mixinKeyword) {
    seen("MixinHeader", DirectParserASTType.HANDLE,
        {"mixinKeyword": mixinKeyword});
  }

  void handleRecoverMixinHeader() {
    seen("RecoverMixinHeader", DirectParserASTType.HANDLE, {});
  }

  void endMixinDeclaration(Token mixinKeyword, Token endToken) {
    seen("MixinDeclaration", DirectParserASTType.END,
        {"mixinKeyword": mixinKeyword, "endToken": endToken});
  }

  void beginUncategorizedTopLevelDeclaration(Token token) {
    seen("UncategorizedTopLevelDeclaration", DirectParserASTType.BEGIN,
        {"token": token});
  }

  void beginExtensionDeclarationPrelude(Token extensionKeyword) {
    seen("ExtensionDeclarationPrelude", DirectParserASTType.BEGIN,
        {"extensionKeyword": extensionKeyword});
  }

  void beginExtensionDeclaration(Token extensionKeyword, Token name) {
    seen("ExtensionDeclaration", DirectParserASTType.BEGIN,
        {"extensionKeyword": extensionKeyword, "name": name});
  }

  void endExtensionDeclaration(
      Token extensionKeyword, Token onKeyword, Token endToken) {
    seen("ExtensionDeclaration", DirectParserASTType.END, {
      "extensionKeyword": extensionKeyword,
      "onKeyword": onKeyword,
      "endToken": endToken
    });
  }

  void beginCombinators(Token token) {
    seen("Combinators", DirectParserASTType.BEGIN, {"token": token});
  }

  void endCombinators(int count) {
    seen("Combinators", DirectParserASTType.END, {"count": count});
  }

  void beginCompilationUnit(Token token) {
    seen("CompilationUnit", DirectParserASTType.BEGIN, {"token": token});
  }

  void handleDirectivesOnly() {
    seen("DirectivesOnly", DirectParserASTType.HANDLE, {});
  }

  void endCompilationUnit(int count, Token token) {
    seen("CompilationUnit", DirectParserASTType.END,
        {"count": count, "token": token});
  }

  void beginConstLiteral(Token token) {
    seen("ConstLiteral", DirectParserASTType.BEGIN, {"token": token});
  }

  void endConstLiteral(Token token) {
    seen("ConstLiteral", DirectParserASTType.END, {"token": token});
  }

  void beginConstructorReference(Token start) {
    seen("ConstructorReference", DirectParserASTType.BEGIN, {"start": start});
  }

  void endConstructorReference(
      Token start, Token periodBeforeName, Token endToken) {
    seen("ConstructorReference", DirectParserASTType.END, {
      "start": start,
      "periodBeforeName": periodBeforeName,
      "endToken": endToken
    });
  }

  void beginDoWhileStatement(Token token) {
    seen("DoWhileStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endDoWhileStatement(
      Token doKeyword, Token whileKeyword, Token endToken) {
    seen("DoWhileStatement", DirectParserASTType.END, {
      "doKeyword": doKeyword,
      "whileKeyword": whileKeyword,
      "endToken": endToken
    });
  }

  void beginDoWhileStatementBody(Token token) {
    seen("DoWhileStatementBody", DirectParserASTType.BEGIN, {"token": token});
  }

  void endDoWhileStatementBody(Token token) {
    seen("DoWhileStatementBody", DirectParserASTType.END, {"token": token});
  }

  void beginWhileStatementBody(Token token) {
    seen("WhileStatementBody", DirectParserASTType.BEGIN, {"token": token});
  }

  void endWhileStatementBody(Token token) {
    seen("WhileStatementBody", DirectParserASTType.END, {"token": token});
  }

  void beginEnum(Token enumKeyword) {
    seen("Enum", DirectParserASTType.BEGIN, {"enumKeyword": enumKeyword});
  }

  void endEnum(Token enumKeyword, Token leftBrace, int count) {
    seen("Enum", DirectParserASTType.END,
        {"enumKeyword": enumKeyword, "leftBrace": leftBrace, "count": count});
  }

  void beginExport(Token token) {
    seen("Export", DirectParserASTType.BEGIN, {"token": token});
  }

  void endExport(Token exportKeyword, Token semicolon) {
    seen("Export", DirectParserASTType.END,
        {"exportKeyword": exportKeyword, "semicolon": semicolon});
  }

  void handleExtraneousExpression(Token token, Message message) {
    seen("ExtraneousExpression", DirectParserASTType.HANDLE,
        {"token": token, "message": message});
  }

  void handleExpressionStatement(Token token) {
    seen("ExpressionStatement", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginFactoryMethod(
      Token lastConsumed, Token externalToken, Token constToken) {
    seen("FactoryMethod", DirectParserASTType.BEGIN, {
      "lastConsumed": lastConsumed,
      "externalToken": externalToken,
      "constToken": constToken
    });
  }

  void endClassFactoryMethod(
      Token beginToken, Token factoryKeyword, Token endToken) {
    seen("ClassFactoryMethod", DirectParserASTType.END, {
      "beginToken": beginToken,
      "factoryKeyword": factoryKeyword,
      "endToken": endToken
    });
  }

  void endMixinFactoryMethod(
      Token beginToken, Token factoryKeyword, Token endToken) {
    seen("MixinFactoryMethod", DirectParserASTType.END, {
      "beginToken": beginToken,
      "factoryKeyword": factoryKeyword,
      "endToken": endToken
    });
  }

  void endExtensionFactoryMethod(
      Token beginToken, Token factoryKeyword, Token endToken) {
    seen("ExtensionFactoryMethod", DirectParserASTType.END, {
      "beginToken": beginToken,
      "factoryKeyword": factoryKeyword,
      "endToken": endToken
    });
  }

  void beginFormalParameter(Token token, MemberKind kind, Token requiredToken,
      Token covariantToken, Token varFinalOrConst) {
    seen("FormalParameter", DirectParserASTType.BEGIN, {
      "token": token,
      "kind": kind,
      "requiredToken": requiredToken,
      "covariantToken": covariantToken,
      "varFinalOrConst": varFinalOrConst
    });
  }

  void endFormalParameter(
      Token thisKeyword,
      Token periodAfterThis,
      Token nameToken,
      Token initializerStart,
      Token initializerEnd,
      FormalParameterKind kind,
      MemberKind memberKind) {
    seen("FormalParameter", DirectParserASTType.END, {
      "thisKeyword": thisKeyword,
      "periodAfterThis": periodAfterThis,
      "nameToken": nameToken,
      "initializerStart": initializerStart,
      "initializerEnd": initializerEnd,
      "kind": kind,
      "memberKind": memberKind
    });
  }

  void handleNoFormalParameters(Token token, MemberKind kind) {
    seen("NoFormalParameters", DirectParserASTType.HANDLE,
        {"token": token, "kind": kind});
  }

  void beginFormalParameters(Token token, MemberKind kind) {
    seen("FormalParameters", DirectParserASTType.BEGIN,
        {"token": token, "kind": kind});
  }

  void endFormalParameters(
      int count, Token beginToken, Token endToken, MemberKind kind) {
    seen("FormalParameters", DirectParserASTType.END, {
      "count": count,
      "beginToken": beginToken,
      "endToken": endToken,
      "kind": kind
    });
  }

  void endClassFields(
      Token abstractToken,
      Token externalToken,
      Token staticToken,
      Token covariantToken,
      Token lateToken,
      Token varFinalOrConst,
      int count,
      Token beginToken,
      Token endToken) {
    seen("ClassFields", DirectParserASTType.END, {
      "abstractToken": abstractToken,
      "externalToken": externalToken,
      "staticToken": staticToken,
      "covariantToken": covariantToken,
      "lateToken": lateToken,
      "varFinalOrConst": varFinalOrConst,
      "count": count,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void endMixinFields(
      Token abstractToken,
      Token externalToken,
      Token staticToken,
      Token covariantToken,
      Token lateToken,
      Token varFinalOrConst,
      int count,
      Token beginToken,
      Token endToken) {
    seen("MixinFields", DirectParserASTType.END, {
      "abstractToken": abstractToken,
      "externalToken": externalToken,
      "staticToken": staticToken,
      "covariantToken": covariantToken,
      "lateToken": lateToken,
      "varFinalOrConst": varFinalOrConst,
      "count": count,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void endExtensionFields(
      Token abstractToken,
      Token externalToken,
      Token staticToken,
      Token covariantToken,
      Token lateToken,
      Token varFinalOrConst,
      int count,
      Token beginToken,
      Token endToken) {
    seen("ExtensionFields", DirectParserASTType.END, {
      "abstractToken": abstractToken,
      "externalToken": externalToken,
      "staticToken": staticToken,
      "covariantToken": covariantToken,
      "lateToken": lateToken,
      "varFinalOrConst": varFinalOrConst,
      "count": count,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void handleForInitializerEmptyStatement(Token token) {
    seen("ForInitializerEmptyStatement", DirectParserASTType.HANDLE,
        {"token": token});
  }

  void handleForInitializerExpressionStatement(Token token, bool forIn) {
    seen("ForInitializerExpressionStatement", DirectParserASTType.HANDLE,
        {"token": token, "forIn": forIn});
  }

  void handleForInitializerLocalVariableDeclaration(Token token, bool forIn) {
    seen("ForInitializerLocalVariableDeclaration", DirectParserASTType.HANDLE,
        {"token": token, "forIn": forIn});
  }

  void beginForStatement(Token token) {
    seen("ForStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void handleForLoopParts(Token forKeyword, Token leftParen,
      Token leftSeparator, int updateExpressionCount) {
    seen("ForLoopParts", DirectParserASTType.HANDLE, {
      "forKeyword": forKeyword,
      "leftParen": leftParen,
      "leftSeparator": leftSeparator,
      "updateExpressionCount": updateExpressionCount
    });
  }

  void endForStatement(Token endToken) {
    seen("ForStatement", DirectParserASTType.END, {"endToken": endToken});
  }

  void beginForStatementBody(Token token) {
    seen("ForStatementBody", DirectParserASTType.BEGIN, {"token": token});
  }

  void endForStatementBody(Token token) {
    seen("ForStatementBody", DirectParserASTType.END, {"token": token});
  }

  void handleForInLoopParts(Token awaitToken, Token forToken,
      Token leftParenthesis, Token inKeyword) {
    seen("ForInLoopParts", DirectParserASTType.HANDLE, {
      "awaitToken": awaitToken,
      "forToken": forToken,
      "leftParenthesis": leftParenthesis,
      "inKeyword": inKeyword
    });
  }

  void endForIn(Token endToken) {
    seen("ForIn", DirectParserASTType.END, {"endToken": endToken});
  }

  void beginForInExpression(Token token) {
    seen("ForInExpression", DirectParserASTType.BEGIN, {"token": token});
  }

  void endForInExpression(Token token) {
    seen("ForInExpression", DirectParserASTType.END, {"token": token});
  }

  void beginForInBody(Token token) {
    seen("ForInBody", DirectParserASTType.BEGIN, {"token": token});
  }

  void endForInBody(Token token) {
    seen("ForInBody", DirectParserASTType.END, {"token": token});
  }

  void beginNamedFunctionExpression(Token token) {
    seen(
        "NamedFunctionExpression", DirectParserASTType.BEGIN, {"token": token});
  }

  void endNamedFunctionExpression(Token endToken) {
    seen("NamedFunctionExpression", DirectParserASTType.END,
        {"endToken": endToken});
  }

  void beginLocalFunctionDeclaration(Token token) {
    seen("LocalFunctionDeclaration", DirectParserASTType.BEGIN,
        {"token": token});
  }

  void endLocalFunctionDeclaration(Token endToken) {
    seen("LocalFunctionDeclaration", DirectParserASTType.END,
        {"endToken": endToken});
  }

  void beginBlockFunctionBody(Token token) {
    seen("BlockFunctionBody", DirectParserASTType.BEGIN, {"token": token});
  }

  void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
    seen("BlockFunctionBody", DirectParserASTType.END,
        {"count": count, "beginToken": beginToken, "endToken": endToken});
  }

  void handleNoFunctionBody(Token token) {
    seen("NoFunctionBody", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleFunctionBodySkipped(Token token, bool isExpressionBody) {
    seen("FunctionBodySkipped", DirectParserASTType.HANDLE,
        {"token": token, "isExpressionBody": isExpressionBody});
  }

  void beginFunctionName(Token token) {
    seen("FunctionName", DirectParserASTType.BEGIN, {"token": token});
  }

  void endFunctionName(Token beginToken, Token token) {
    seen("FunctionName", DirectParserASTType.END,
        {"beginToken": beginToken, "token": token});
  }

  void beginFunctionTypeAlias(Token token) {
    seen("FunctionTypeAlias", DirectParserASTType.BEGIN, {"token": token});
  }

  void endFunctionTypeAlias(
      Token typedefKeyword, Token equals, Token endToken) {
    seen("FunctionTypeAlias", DirectParserASTType.END, {
      "typedefKeyword": typedefKeyword,
      "equals": equals,
      "endToken": endToken
    });
  }

  void handleClassWithClause(Token withKeyword) {
    seen("ClassWithClause", DirectParserASTType.HANDLE,
        {"withKeyword": withKeyword});
  }

  void handleClassNoWithClause() {
    seen("ClassNoWithClause", DirectParserASTType.HANDLE, {});
  }

  void beginNamedMixinApplication(
      Token begin, Token abstractToken, Token name) {
    seen("NamedMixinApplication", DirectParserASTType.BEGIN,
        {"begin": begin, "abstractToken": abstractToken, "name": name});
  }

  void handleNamedMixinApplicationWithClause(Token withKeyword) {
    seen("NamedMixinApplicationWithClause", DirectParserASTType.HANDLE,
        {"withKeyword": withKeyword});
  }

  void endNamedMixinApplication(Token begin, Token classKeyword, Token equals,
      Token implementsKeyword, Token endToken) {
    seen("NamedMixinApplication", DirectParserASTType.END, {
      "begin": begin,
      "classKeyword": classKeyword,
      "equals": equals,
      "implementsKeyword": implementsKeyword,
      "endToken": endToken
    });
  }

  void beginHide(Token hideKeyword) {
    seen("Hide", DirectParserASTType.BEGIN, {"hideKeyword": hideKeyword});
  }

  void endHide(Token hideKeyword) {
    seen("Hide", DirectParserASTType.END, {"hideKeyword": hideKeyword});
  }

  void handleIdentifierList(int count) {
    seen("IdentifierList", DirectParserASTType.HANDLE, {"count": count});
  }

  void beginTypeList(Token token) {
    seen("TypeList", DirectParserASTType.BEGIN, {"token": token});
  }

  void endTypeList(int count) {
    seen("TypeList", DirectParserASTType.END, {"count": count});
  }

  void beginIfStatement(Token token) {
    seen("IfStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endIfStatement(Token ifToken, Token elseToken) {
    seen("IfStatement", DirectParserASTType.END,
        {"ifToken": ifToken, "elseToken": elseToken});
  }

  void beginThenStatement(Token token) {
    seen("ThenStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endThenStatement(Token token) {
    seen("ThenStatement", DirectParserASTType.END, {"token": token});
  }

  void beginElseStatement(Token token) {
    seen("ElseStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endElseStatement(Token token) {
    seen("ElseStatement", DirectParserASTType.END, {"token": token});
  }

  void beginImport(Token importKeyword) {
    seen("Import", DirectParserASTType.BEGIN, {"importKeyword": importKeyword});
  }

  void handleImportPrefix(Token deferredKeyword, Token asKeyword) {
    seen("ImportPrefix", DirectParserASTType.HANDLE,
        {"deferredKeyword": deferredKeyword, "asKeyword": asKeyword});
  }

  void endImport(Token importKeyword, Token semicolon) {
    seen("Import", DirectParserASTType.END,
        {"importKeyword": importKeyword, "semicolon": semicolon});
  }

  void handleRecoverImport(Token semicolon) {
    seen("RecoverImport", DirectParserASTType.HANDLE, {"semicolon": semicolon});
  }

  void beginConditionalUris(Token token) {
    seen("ConditionalUris", DirectParserASTType.BEGIN, {"token": token});
  }

  void endConditionalUris(int count) {
    seen("ConditionalUris", DirectParserASTType.END, {"count": count});
  }

  void beginConditionalUri(Token ifKeyword) {
    seen("ConditionalUri", DirectParserASTType.BEGIN, {"ifKeyword": ifKeyword});
  }

  void endConditionalUri(Token ifKeyword, Token leftParen, Token equalSign) {
    seen("ConditionalUri", DirectParserASTType.END, {
      "ifKeyword": ifKeyword,
      "leftParen": leftParen,
      "equalSign": equalSign
    });
  }

  void handleDottedName(int count, Token firstIdentifier) {
    seen("DottedName", DirectParserASTType.HANDLE,
        {"count": count, "firstIdentifier": firstIdentifier});
  }

  void beginImplicitCreationExpression(Token token) {
    seen("ImplicitCreationExpression", DirectParserASTType.BEGIN,
        {"token": token});
  }

  void endImplicitCreationExpression(Token token) {
    seen("ImplicitCreationExpression", DirectParserASTType.END,
        {"token": token});
  }

  void beginInitializedIdentifier(Token token) {
    seen("InitializedIdentifier", DirectParserASTType.BEGIN, {"token": token});
  }

  void endInitializedIdentifier(Token nameToken) {
    seen("InitializedIdentifier", DirectParserASTType.END,
        {"nameToken": nameToken});
  }

  void beginFieldInitializer(Token token) {
    seen("FieldInitializer", DirectParserASTType.BEGIN, {"token": token});
  }

  void endFieldInitializer(Token assignment, Token token) {
    seen("FieldInitializer", DirectParserASTType.END,
        {"assignment": assignment, "token": token});
  }

  void handleNoFieldInitializer(Token token) {
    seen("NoFieldInitializer", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginVariableInitializer(Token token) {
    seen("VariableInitializer", DirectParserASTType.BEGIN, {"token": token});
  }

  void endVariableInitializer(Token assignmentOperator) {
    seen("VariableInitializer", DirectParserASTType.END,
        {"assignmentOperator": assignmentOperator});
  }

  void handleNoVariableInitializer(Token token) {
    seen("NoVariableInitializer", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginInitializer(Token token) {
    seen("Initializer", DirectParserASTType.BEGIN, {"token": token});
  }

  void endInitializer(Token token) {
    seen("Initializer", DirectParserASTType.END, {"token": token});
  }

  void beginInitializers(Token token) {
    seen("Initializers", DirectParserASTType.BEGIN, {"token": token});
  }

  void endInitializers(int count, Token beginToken, Token endToken) {
    seen("Initializers", DirectParserASTType.END,
        {"count": count, "beginToken": beginToken, "endToken": endToken});
  }

  void handleNoInitializers() {
    seen("NoInitializers", DirectParserASTType.HANDLE, {});
  }

  void handleInvalidExpression(Token token) {
    seen("InvalidExpression", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleInvalidFunctionBody(Token token) {
    seen("InvalidFunctionBody", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleInvalidTypeReference(Token token) {
    seen("InvalidTypeReference", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleLabel(Token token) {
    seen("Label", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginLabeledStatement(Token token, int labelCount) {
    seen("LabeledStatement", DirectParserASTType.BEGIN,
        {"token": token, "labelCount": labelCount});
  }

  void endLabeledStatement(int labelCount) {
    seen("LabeledStatement", DirectParserASTType.END,
        {"labelCount": labelCount});
  }

  void beginLibraryName(Token token) {
    seen("LibraryName", DirectParserASTType.BEGIN, {"token": token});
  }

  void endLibraryName(Token libraryKeyword, Token semicolon) {
    seen("LibraryName", DirectParserASTType.END,
        {"libraryKeyword": libraryKeyword, "semicolon": semicolon});
  }

  void handleLiteralMapEntry(Token colon, Token endToken) {
    seen("LiteralMapEntry", DirectParserASTType.HANDLE,
        {"colon": colon, "endToken": endToken});
  }

  void beginLiteralString(Token token) {
    seen("LiteralString", DirectParserASTType.BEGIN, {"token": token});
  }

  void handleInterpolationExpression(Token leftBracket, Token rightBracket) {
    seen("InterpolationExpression", DirectParserASTType.HANDLE,
        {"leftBracket": leftBracket, "rightBracket": rightBracket});
  }

  void endLiteralString(int interpolationCount, Token endToken) {
    seen("LiteralString", DirectParserASTType.END,
        {"interpolationCount": interpolationCount, "endToken": endToken});
  }

  void handleStringJuxtaposition(Token startToken, int literalCount) {
    seen("StringJuxtaposition", DirectParserASTType.HANDLE,
        {"startToken": startToken, "literalCount": literalCount});
  }

  void beginMember() {
    seen("Member", DirectParserASTType.BEGIN, {});
  }

  void handleInvalidMember(Token endToken) {
    seen("InvalidMember", DirectParserASTType.HANDLE, {"endToken": endToken});
  }

  void endMember() {
    seen("Member", DirectParserASTType.END, {});
  }

  void beginMethod(Token externalToken, Token staticToken, Token covariantToken,
      Token varFinalOrConst, Token getOrSet, Token name) {
    seen("Method", DirectParserASTType.BEGIN, {
      "externalToken": externalToken,
      "staticToken": staticToken,
      "covariantToken": covariantToken,
      "varFinalOrConst": varFinalOrConst,
      "getOrSet": getOrSet,
      "name": name
    });
  }

  void endClassMethod(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    seen("ClassMethod", DirectParserASTType.END, {
      "getOrSet": getOrSet,
      "beginToken": beginToken,
      "beginParam": beginParam,
      "beginInitializers": beginInitializers,
      "endToken": endToken
    });
  }

  void endMixinMethod(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    seen("MixinMethod", DirectParserASTType.END, {
      "getOrSet": getOrSet,
      "beginToken": beginToken,
      "beginParam": beginParam,
      "beginInitializers": beginInitializers,
      "endToken": endToken
    });
  }

  void endExtensionMethod(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    seen("ExtensionMethod", DirectParserASTType.END, {
      "getOrSet": getOrSet,
      "beginToken": beginToken,
      "beginParam": beginParam,
      "beginInitializers": beginInitializers,
      "endToken": endToken
    });
  }

  void endClassConstructor(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    seen("ClassConstructor", DirectParserASTType.END, {
      "getOrSet": getOrSet,
      "beginToken": beginToken,
      "beginParam": beginParam,
      "beginInitializers": beginInitializers,
      "endToken": endToken
    });
  }

  void endMixinConstructor(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    seen("MixinConstructor", DirectParserASTType.END, {
      "getOrSet": getOrSet,
      "beginToken": beginToken,
      "beginParam": beginParam,
      "beginInitializers": beginInitializers,
      "endToken": endToken
    });
  }

  void endExtensionConstructor(Token getOrSet, Token beginToken,
      Token beginParam, Token beginInitializers, Token endToken) {
    seen("ExtensionConstructor", DirectParserASTType.END, {
      "getOrSet": getOrSet,
      "beginToken": beginToken,
      "beginParam": beginParam,
      "beginInitializers": beginInitializers,
      "endToken": endToken
    });
  }

  void beginMetadataStar(Token token) {
    seen("MetadataStar", DirectParserASTType.BEGIN, {"token": token});
  }

  void endMetadataStar(int count) {
    seen("MetadataStar", DirectParserASTType.END, {"count": count});
  }

  void beginMetadata(Token token) {
    seen("Metadata", DirectParserASTType.BEGIN, {"token": token});
  }

  void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
    seen("Metadata", DirectParserASTType.END, {
      "beginToken": beginToken,
      "periodBeforeName": periodBeforeName,
      "endToken": endToken
    });
  }

  void beginOptionalFormalParameters(Token token) {
    seen("OptionalFormalParameters", DirectParserASTType.BEGIN,
        {"token": token});
  }

  void endOptionalFormalParameters(
      int count, Token beginToken, Token endToken) {
    seen("OptionalFormalParameters", DirectParserASTType.END,
        {"count": count, "beginToken": beginToken, "endToken": endToken});
  }

  void beginPart(Token token) {
    seen("Part", DirectParserASTType.BEGIN, {"token": token});
  }

  void endPart(Token partKeyword, Token semicolon) {
    seen("Part", DirectParserASTType.END,
        {"partKeyword": partKeyword, "semicolon": semicolon});
  }

  void beginPartOf(Token token) {
    seen("PartOf", DirectParserASTType.BEGIN, {"token": token});
  }

  void endPartOf(
      Token partKeyword, Token ofKeyword, Token semicolon, bool hasName) {
    seen("PartOf", DirectParserASTType.END, {
      "partKeyword": partKeyword,
      "ofKeyword": ofKeyword,
      "semicolon": semicolon,
      "hasName": hasName
    });
  }

  void beginRedirectingFactoryBody(Token token) {
    seen("RedirectingFactoryBody", DirectParserASTType.BEGIN, {"token": token});
  }

  void endRedirectingFactoryBody(Token beginToken, Token endToken) {
    seen("RedirectingFactoryBody", DirectParserASTType.END,
        {"beginToken": beginToken, "endToken": endToken});
  }

  void beginReturnStatement(Token token) {
    seen("ReturnStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void handleNativeFunctionBody(Token nativeToken, Token semicolon) {
    seen("NativeFunctionBody", DirectParserASTType.HANDLE,
        {"nativeToken": nativeToken, "semicolon": semicolon});
  }

  void handleNativeFunctionBodyIgnored(Token nativeToken, Token semicolon) {
    seen("NativeFunctionBodyIgnored", DirectParserASTType.HANDLE,
        {"nativeToken": nativeToken, "semicolon": semicolon});
  }

  void handleNativeFunctionBodySkipped(Token nativeToken, Token semicolon) {
    seen("NativeFunctionBodySkipped", DirectParserASTType.HANDLE,
        {"nativeToken": nativeToken, "semicolon": semicolon});
  }

  void handleEmptyFunctionBody(Token semicolon) {
    seen("EmptyFunctionBody", DirectParserASTType.HANDLE,
        {"semicolon": semicolon});
  }

  void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
    seen("ExpressionFunctionBody", DirectParserASTType.HANDLE,
        {"arrowToken": arrowToken, "endToken": endToken});
  }

  void endReturnStatement(
      bool hasExpression, Token beginToken, Token endToken) {
    seen("ReturnStatement", DirectParserASTType.END, {
      "hasExpression": hasExpression,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void handleSend(Token beginToken, Token endToken) {
    seen("Send", DirectParserASTType.HANDLE,
        {"beginToken": beginToken, "endToken": endToken});
  }

  void beginShow(Token showKeyword) {
    seen("Show", DirectParserASTType.BEGIN, {"showKeyword": showKeyword});
  }

  void endShow(Token showKeyword) {
    seen("Show", DirectParserASTType.END, {"showKeyword": showKeyword});
  }

  void beginSwitchStatement(Token token) {
    seen("SwitchStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endSwitchStatement(Token switchKeyword, Token endToken) {
    seen("SwitchStatement", DirectParserASTType.END,
        {"switchKeyword": switchKeyword, "endToken": endToken});
  }

  void beginSwitchBlock(Token token) {
    seen("SwitchBlock", DirectParserASTType.BEGIN, {"token": token});
  }

  void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
    seen("SwitchBlock", DirectParserASTType.END, {
      "caseCount": caseCount,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void beginLiteralSymbol(Token token) {
    seen("LiteralSymbol", DirectParserASTType.BEGIN, {"token": token});
  }

  void endLiteralSymbol(Token hashToken, int identifierCount) {
    seen("LiteralSymbol", DirectParserASTType.END,
        {"hashToken": hashToken, "identifierCount": identifierCount});
  }

  void handleThrowExpression(Token throwToken, Token endToken) {
    seen("ThrowExpression", DirectParserASTType.HANDLE,
        {"throwToken": throwToken, "endToken": endToken});
  }

  void beginRethrowStatement(Token token) {
    seen("RethrowStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endRethrowStatement(Token rethrowToken, Token endToken) {
    seen("RethrowStatement", DirectParserASTType.END,
        {"rethrowToken": rethrowToken, "endToken": endToken});
  }

  void endTopLevelDeclaration(Token nextToken) {
    seen("TopLevelDeclaration", DirectParserASTType.END,
        {"nextToken": nextToken});
  }

  void handleInvalidTopLevelDeclaration(Token endToken) {
    seen("InvalidTopLevelDeclaration", DirectParserASTType.HANDLE,
        {"endToken": endToken});
  }

  void beginTopLevelMember(Token token) {
    seen("TopLevelMember", DirectParserASTType.BEGIN, {"token": token});
  }

  void beginFields(Token lastConsumed) {
    seen("Fields", DirectParserASTType.BEGIN, {"lastConsumed": lastConsumed});
  }

  void endTopLevelFields(
      Token externalToken,
      Token staticToken,
      Token covariantToken,
      Token lateToken,
      Token varFinalOrConst,
      int count,
      Token beginToken,
      Token endToken) {
    seen("TopLevelFields", DirectParserASTType.END, {
      "externalToken": externalToken,
      "staticToken": staticToken,
      "covariantToken": covariantToken,
      "lateToken": lateToken,
      "varFinalOrConst": varFinalOrConst,
      "count": count,
      "beginToken": beginToken,
      "endToken": endToken
    });
  }

  void beginTopLevelMethod(Token lastConsumed, Token externalToken) {
    seen("TopLevelMethod", DirectParserASTType.BEGIN,
        {"lastConsumed": lastConsumed, "externalToken": externalToken});
  }

  void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
    seen("TopLevelMethod", DirectParserASTType.END,
        {"beginToken": beginToken, "getOrSet": getOrSet, "endToken": endToken});
  }

  void beginTryStatement(Token token) {
    seen("TryStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void handleCaseMatch(Token caseKeyword, Token colon) {
    seen("CaseMatch", DirectParserASTType.HANDLE,
        {"caseKeyword": caseKeyword, "colon": colon});
  }

  void beginCatchClause(Token token) {
    seen("CatchClause", DirectParserASTType.BEGIN, {"token": token});
  }

  void endCatchClause(Token token) {
    seen("CatchClause", DirectParserASTType.END, {"token": token});
  }

  void handleCatchBlock(Token onKeyword, Token catchKeyword, Token comma) {
    seen("CatchBlock", DirectParserASTType.HANDLE,
        {"onKeyword": onKeyword, "catchKeyword": catchKeyword, "comma": comma});
  }

  void handleFinallyBlock(Token finallyKeyword) {
    seen("FinallyBlock", DirectParserASTType.HANDLE,
        {"finallyKeyword": finallyKeyword});
  }

  void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
    seen("TryStatement", DirectParserASTType.END, {
      "catchCount": catchCount,
      "tryKeyword": tryKeyword,
      "finallyKeyword": finallyKeyword
    });
  }

  void handleType(Token beginToken, Token questionMark) {
    seen("Type", DirectParserASTType.HANDLE,
        {"beginToken": beginToken, "questionMark": questionMark});
  }

  void handleNonNullAssertExpression(Token bang) {
    seen("NonNullAssertExpression", DirectParserASTType.HANDLE, {"bang": bang});
  }

  void handleNoName(Token token) {
    seen("NoName", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginFunctionType(Token beginToken) {
    seen("FunctionType", DirectParserASTType.BEGIN, {"beginToken": beginToken});
  }

  void endFunctionType(Token functionToken, Token questionMark) {
    seen("FunctionType", DirectParserASTType.END,
        {"functionToken": functionToken, "questionMark": questionMark});
  }

  void beginTypeArguments(Token token) {
    seen("TypeArguments", DirectParserASTType.BEGIN, {"token": token});
  }

  void endTypeArguments(int count, Token beginToken, Token endToken) {
    seen("TypeArguments", DirectParserASTType.END,
        {"count": count, "beginToken": beginToken, "endToken": endToken});
  }

  void handleInvalidTypeArguments(Token token) {
    seen("InvalidTypeArguments", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleNoTypeArguments(Token token) {
    seen("NoTypeArguments", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginTypeVariable(Token token) {
    seen("TypeVariable", DirectParserASTType.BEGIN, {"token": token});
  }

  void handleTypeVariablesDefined(Token token, int count) {
    seen("TypeVariablesDefined", DirectParserASTType.HANDLE,
        {"token": token, "count": count});
  }

  void endTypeVariable(
      Token token, int index, Token extendsOrSuper, Token variance) {
    seen("TypeVariable", DirectParserASTType.END, {
      "token": token,
      "index": index,
      "extendsOrSuper": extendsOrSuper,
      "variance": variance
    });
  }

  void beginTypeVariables(Token token) {
    seen("TypeVariables", DirectParserASTType.BEGIN, {"token": token});
  }

  void endTypeVariables(Token beginToken, Token endToken) {
    seen("TypeVariables", DirectParserASTType.END,
        {"beginToken": beginToken, "endToken": endToken});
  }

  void beginFunctionExpression(Token token) {
    seen("FunctionExpression", DirectParserASTType.BEGIN, {"token": token});
  }

  void endFunctionExpression(Token beginToken, Token token) {
    seen("FunctionExpression", DirectParserASTType.END,
        {"beginToken": beginToken, "token": token});
  }

  void beginVariablesDeclaration(
      Token token, Token lateToken, Token varFinalOrConst) {
    seen("VariablesDeclaration", DirectParserASTType.BEGIN, {
      "token": token,
      "lateToken": lateToken,
      "varFinalOrConst": varFinalOrConst
    });
  }

  void endVariablesDeclaration(int count, Token endToken) {
    seen("VariablesDeclaration", DirectParserASTType.END,
        {"count": count, "endToken": endToken});
  }

  void beginWhileStatement(Token token) {
    seen("WhileStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endWhileStatement(Token whileKeyword, Token endToken) {
    seen("WhileStatement", DirectParserASTType.END,
        {"whileKeyword": whileKeyword, "endToken": endToken});
  }

  void beginAsOperatorType(Token operator) {
    seen("AsOperatorType", DirectParserASTType.BEGIN, {"operator": operator});
  }

  void endAsOperatorType(Token operator) {
    seen("AsOperatorType", DirectParserASTType.END, {"operator": operator});
  }

  void handleAsOperator(Token operator) {
    seen("AsOperator", DirectParserASTType.HANDLE, {"operator": operator});
  }

  void handleAssignmentExpression(Token token) {
    seen("AssignmentExpression", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginBinaryExpression(Token token) {
    seen("BinaryExpression", DirectParserASTType.BEGIN, {"token": token});
  }

  void endBinaryExpression(Token token) {
    seen("BinaryExpression", DirectParserASTType.END, {"token": token});
  }

  void handleEndingBinaryExpression(Token token) {
    seen(
        "EndingBinaryExpression", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginConditionalExpression(Token question) {
    seen("ConditionalExpression", DirectParserASTType.BEGIN,
        {"question": question});
  }

  void handleConditionalExpressionColon() {
    seen("ConditionalExpressionColon", DirectParserASTType.HANDLE, {});
  }

  void endConditionalExpression(Token question, Token colon) {
    seen("ConditionalExpression", DirectParserASTType.END,
        {"question": question, "colon": colon});
  }

  void beginConstExpression(Token constKeyword) {
    seen("ConstExpression", DirectParserASTType.BEGIN,
        {"constKeyword": constKeyword});
  }

  void endConstExpression(Token token) {
    seen("ConstExpression", DirectParserASTType.END, {"token": token});
  }

  void beginForControlFlow(Token awaitToken, Token forToken) {
    seen("ForControlFlow", DirectParserASTType.BEGIN,
        {"awaitToken": awaitToken, "forToken": forToken});
  }

  void endForControlFlow(Token token) {
    seen("ForControlFlow", DirectParserASTType.END, {"token": token});
  }

  void endForInControlFlow(Token token) {
    seen("ForInControlFlow", DirectParserASTType.END, {"token": token});
  }

  void beginIfControlFlow(Token ifToken) {
    seen("IfControlFlow", DirectParserASTType.BEGIN, {"ifToken": ifToken});
  }

  void handleThenControlFlow(Token token) {
    seen("ThenControlFlow", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleElseControlFlow(Token elseToken) {
    seen("ElseControlFlow", DirectParserASTType.HANDLE,
        {"elseToken": elseToken});
  }

  void endIfControlFlow(Token token) {
    seen("IfControlFlow", DirectParserASTType.END, {"token": token});
  }

  void endIfElseControlFlow(Token token) {
    seen("IfElseControlFlow", DirectParserASTType.END, {"token": token});
  }

  void handleSpreadExpression(Token spreadToken) {
    seen("SpreadExpression", DirectParserASTType.HANDLE,
        {"spreadToken": spreadToken});
  }

  void beginFunctionTypedFormalParameter(Token token) {
    seen("FunctionTypedFormalParameter", DirectParserASTType.BEGIN,
        {"token": token});
  }

  void endFunctionTypedFormalParameter(Token nameToken, Token question) {
    seen("FunctionTypedFormalParameter", DirectParserASTType.END,
        {"nameToken": nameToken, "question": question});
  }

  void handleIdentifier(Token token, IdentifierContext context) {
    seen("Identifier", DirectParserASTType.HANDLE,
        {"token": token, "context": context});
  }

  void handleIndexedExpression(
      Token question, Token openSquareBracket, Token closeSquareBracket) {
    seen("IndexedExpression", DirectParserASTType.HANDLE, {
      "question": question,
      "openSquareBracket": openSquareBracket,
      "closeSquareBracket": closeSquareBracket
    });
  }

  void beginIsOperatorType(Token operator) {
    seen("IsOperatorType", DirectParserASTType.BEGIN, {"operator": operator});
  }

  void endIsOperatorType(Token operator) {
    seen("IsOperatorType", DirectParserASTType.END, {"operator": operator});
  }

  void handleIsOperator(Token isOperator, Token not) {
    seen("IsOperator", DirectParserASTType.HANDLE,
        {"isOperator": isOperator, "not": not});
  }

  void handleLiteralBool(Token token) {
    seen("LiteralBool", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleBreakStatement(
      bool hasTarget, Token breakKeyword, Token endToken) {
    seen("BreakStatement", DirectParserASTType.HANDLE, {
      "hasTarget": hasTarget,
      "breakKeyword": breakKeyword,
      "endToken": endToken
    });
  }

  void handleContinueStatement(
      bool hasTarget, Token continueKeyword, Token endToken) {
    seen("ContinueStatement", DirectParserASTType.HANDLE, {
      "hasTarget": hasTarget,
      "continueKeyword": continueKeyword,
      "endToken": endToken
    });
  }

  void handleEmptyStatement(Token token) {
    seen("EmptyStatement", DirectParserASTType.HANDLE, {"token": token});
  }

  void beginAssert(Token assertKeyword, Assert kind) {
    seen("Assert", DirectParserASTType.BEGIN,
        {"assertKeyword": assertKeyword, "kind": kind});
  }

  void endAssert(Token assertKeyword, Assert kind, Token leftParenthesis,
      Token commaToken, Token semicolonToken) {
    seen("Assert", DirectParserASTType.END, {
      "assertKeyword": assertKeyword,
      "kind": kind,
      "leftParenthesis": leftParenthesis,
      "commaToken": commaToken,
      "semicolonToken": semicolonToken
    });
  }

  void handleLiteralDouble(Token token) {
    seen("LiteralDouble", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleLiteralInt(Token token) {
    seen("LiteralInt", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleLiteralList(
      int count, Token leftBracket, Token constKeyword, Token rightBracket) {
    seen("LiteralList", DirectParserASTType.HANDLE, {
      "count": count,
      "leftBracket": leftBracket,
      "constKeyword": constKeyword,
      "rightBracket": rightBracket
    });
  }

  void handleLiteralSetOrMap(
    int count,
    Token leftBrace,
    Token constKeyword,
    Token rightBrace,
    bool hasSetEntry,
  ) {
    seen("LiteralSetOrMap", DirectParserASTType.HANDLE, {
      "count": count,
      "leftBrace": leftBrace,
      "constKeyword": constKeyword,
      "rightBrace": rightBrace,
      "hasSetEntry": hasSetEntry
    });
  }

  void handleLiteralNull(Token token) {
    seen("LiteralNull", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleNativeClause(Token nativeToken, bool hasName) {
    seen("NativeClause", DirectParserASTType.HANDLE,
        {"nativeToken": nativeToken, "hasName": hasName});
  }

  void handleNamedArgument(Token colon) {
    seen("NamedArgument", DirectParserASTType.HANDLE, {"colon": colon});
  }

  void beginNewExpression(Token token) {
    seen("NewExpression", DirectParserASTType.BEGIN, {"token": token});
  }

  void endNewExpression(Token token) {
    seen("NewExpression", DirectParserASTType.END, {"token": token});
  }

  void handleNoArguments(Token token) {
    seen("NoArguments", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
    seen("NoConstructorReferenceContinuationAfterTypeArguments",
        DirectParserASTType.HANDLE, {"token": token});
  }

  void handleNoType(Token lastConsumed) {
    seen("NoType", DirectParserASTType.HANDLE, {"lastConsumed": lastConsumed});
  }

  void handleNoTypeVariables(Token token) {
    seen("NoTypeVariables", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleOperator(Token token) {
    seen("Operator", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleSymbolVoid(Token token) {
    seen("SymbolVoid", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleOperatorName(Token operatorKeyword, Token token) {
    seen("OperatorName", DirectParserASTType.HANDLE,
        {"operatorKeyword": operatorKeyword, "token": token});
  }

  void handleInvalidOperatorName(Token operatorKeyword, Token token) {
    seen("InvalidOperatorName", DirectParserASTType.HANDLE,
        {"operatorKeyword": operatorKeyword, "token": token});
  }

  void handleParenthesizedCondition(Token token) {
    seen(
        "ParenthesizedCondition", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleParenthesizedExpression(Token token) {
    seen("ParenthesizedExpression", DirectParserASTType.HANDLE,
        {"token": token});
  }

  void handleQualified(Token period) {
    seen("Qualified", DirectParserASTType.HANDLE, {"period": period});
  }

  void handleStringPart(Token token) {
    seen("StringPart", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleSuperExpression(Token token, IdentifierContext context) {
    seen("SuperExpression", DirectParserASTType.HANDLE,
        {"token": token, "context": context});
  }

  void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
    seen("SwitchCase", DirectParserASTType.BEGIN, {
      "labelCount": labelCount,
      "expressionCount": expressionCount,
      "firstToken": firstToken
    });
  }

  void endSwitchCase(
      int labelCount,
      int expressionCount,
      Token defaultKeyword,
      Token colonAfterDefault,
      int statementCount,
      Token firstToken,
      Token endToken) {
    seen("SwitchCase", DirectParserASTType.END, {
      "labelCount": labelCount,
      "expressionCount": expressionCount,
      "defaultKeyword": defaultKeyword,
      "colonAfterDefault": colonAfterDefault,
      "statementCount": statementCount,
      "firstToken": firstToken,
      "endToken": endToken
    });
  }

  void handleThisExpression(Token token, IdentifierContext context) {
    seen("ThisExpression", DirectParserASTType.HANDLE,
        {"token": token, "context": context});
  }

  void handleUnaryPostfixAssignmentExpression(Token token) {
    seen("UnaryPostfixAssignmentExpression", DirectParserASTType.HANDLE,
        {"token": token});
  }

  void handleUnaryPrefixExpression(Token token) {
    seen("UnaryPrefixExpression", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleUnaryPrefixAssignmentExpression(Token token) {
    seen("UnaryPrefixAssignmentExpression", DirectParserASTType.HANDLE,
        {"token": token});
  }

  void beginFormalParameterDefaultValueExpression() {
    seen(
        "FormalParameterDefaultValueExpression", DirectParserASTType.BEGIN, {});
  }

  void endFormalParameterDefaultValueExpression() {
    seen("FormalParameterDefaultValueExpression", DirectParserASTType.END, {});
  }

  void handleValuedFormalParameter(Token equals, Token token) {
    seen("ValuedFormalParameter", DirectParserASTType.HANDLE,
        {"equals": equals, "token": token});
  }

  void handleFormalParameterWithoutValue(Token token) {
    seen("FormalParameterWithoutValue", DirectParserASTType.HANDLE,
        {"token": token});
  }

  void handleVoidKeyword(Token token) {
    seen("VoidKeyword", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleVoidKeywordWithTypeArguments(Token token) {
    seen("VoidKeywordWithTypeArguments", DirectParserASTType.HANDLE,
        {"token": token});
  }

  void beginYieldStatement(Token token) {
    seen("YieldStatement", DirectParserASTType.BEGIN, {"token": token});
  }

  void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
    seen("YieldStatement", DirectParserASTType.END, {
      "yieldToken": yieldToken,
      "starToken": starToken,
      "endToken": endToken
    });
  }

  void endInvalidYieldStatement(Token beginToken, Token starToken,
      Token endToken, MessageCode errorCode) {
    seen("InvalidYieldStatement", DirectParserASTType.END, {
      "beginToken": beginToken,
      "starToken": starToken,
      "endToken": endToken,
      "errorCode": errorCode
    });
  }

  void handleRecoverableError(
      Message message, Token startToken, Token endToken) {
    seen("RecoverableError", DirectParserASTType.HANDLE,
        {"message": message, "startToken": startToken, "endToken": endToken});
  }

  void handleErrorToken(ErrorToken token) {
    seen("ErrorToken", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleUnescapeError(
      Message message, Token location, int stringOffset, int length) {
    seen("UnescapeError", DirectParserASTType.HANDLE, {
      "message": message,
      "location": location,
      "stringOffset": stringOffset,
      "length": length
    });
  }

  void handleInvalidStatement(Token token, Message message) {
    seen("InvalidStatement", DirectParserASTType.HANDLE,
        {"token": token, "message": message});
  }

  void handleScript(Token token) {
    seen("Script", DirectParserASTType.HANDLE, {"token": token});
  }

  void handleCommentReferenceText(String referenceSource, int referenceOffset) {
    seen("CommentReferenceText", DirectParserASTType.HANDLE, {
      "referenceSource": referenceSource,
      "referenceOffset": referenceOffset
    });
  }

  void handleCommentReference(
      Token newKeyword, Token prefix, Token period, Token token) {
    seen("CommentReference", DirectParserASTType.HANDLE, {
      "newKeyword": newKeyword,
      "prefix": prefix,
      "period": period,
      "token": token
    });
  }

  void handleNoCommentReference() {
    seen("NoCommentReference", DirectParserASTType.HANDLE, {});
  }
}