pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart

// 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.

// @dart = 2.9

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';

// ignore_for_file: lines_longer_than_80_chars

// 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
*/

abstract class DirectParserASTContent {
  final String what;
  final DirectParserASTType type;
  Map<String, Object> get deprecatedArguments;
  List<DirectParserASTContent> children;

  DirectParserASTContent(this.what, this.type);

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

enum DirectParserASTType { BEGIN, END, HANDLE }

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

  void seen(DirectParserASTContent entry);

  void beginArguments(Token token) {
    DirectParserASTContentArgumentsBegin data =
        new DirectParserASTContentArgumentsBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endArguments(int count, Token beginToken, Token endToken) {
    DirectParserASTContentArgumentsEnd data =
        new DirectParserASTContentArgumentsEnd(DirectParserASTType.END,
            count: count, beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void handleAsyncModifier(Token asyncToken, Token starToken) {
    DirectParserASTContentAsyncModifierHandle data =
        new DirectParserASTContentAsyncModifierHandle(
            DirectParserASTType.HANDLE,
            asyncToken: asyncToken,
            starToken: starToken);
    seen(data);
  }

  void beginAwaitExpression(Token token) {
    DirectParserASTContentAwaitExpressionBegin data =
        new DirectParserASTContentAwaitExpressionBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endAwaitExpression(Token beginToken, Token endToken) {
    DirectParserASTContentAwaitExpressionEnd data =
        new DirectParserASTContentAwaitExpressionEnd(DirectParserASTType.END,
            beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void endInvalidAwaitExpression(
      Token beginToken, Token endToken, MessageCode errorCode) {
    DirectParserASTContentInvalidAwaitExpressionEnd data =
        new DirectParserASTContentInvalidAwaitExpressionEnd(
            DirectParserASTType.END,
            beginToken: beginToken,
            endToken: endToken,
            errorCode: errorCode);
    seen(data);
  }

  void beginBlock(Token token, BlockKind blockKind) {
    DirectParserASTContentBlockBegin data =
        new DirectParserASTContentBlockBegin(DirectParserASTType.BEGIN,
            token: token, blockKind: blockKind);
    seen(data);
  }

  void endBlock(
      int count, Token beginToken, Token endToken, BlockKind blockKind) {
    DirectParserASTContentBlockEnd data = new DirectParserASTContentBlockEnd(
        DirectParserASTType.END,
        count: count,
        beginToken: beginToken,
        endToken: endToken,
        blockKind: blockKind);
    seen(data);
  }

  void handleInvalidTopLevelBlock(Token token) {
    DirectParserASTContentInvalidTopLevelBlockHandle data =
        new DirectParserASTContentInvalidTopLevelBlockHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginCascade(Token token) {
    DirectParserASTContentCascadeBegin data =
        new DirectParserASTContentCascadeBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endCascade() {
    DirectParserASTContentCascadeEnd data =
        new DirectParserASTContentCascadeEnd(DirectParserASTType.END);
    seen(data);
  }

  void beginCaseExpression(Token caseKeyword) {
    DirectParserASTContentCaseExpressionBegin data =
        new DirectParserASTContentCaseExpressionBegin(DirectParserASTType.BEGIN,
            caseKeyword: caseKeyword);
    seen(data);
  }

  void endCaseExpression(Token colon) {
    DirectParserASTContentCaseExpressionEnd data =
        new DirectParserASTContentCaseExpressionEnd(DirectParserASTType.END,
            colon: colon);
    seen(data);
  }

  void beginClassOrMixinBody(DeclarationKind kind, Token token) {
    DirectParserASTContentClassOrMixinBodyBegin data =
        new DirectParserASTContentClassOrMixinBodyBegin(
            DirectParserASTType.BEGIN,
            kind: kind,
            token: token);
    seen(data);
  }

  void endClassOrMixinBody(
      DeclarationKind kind, int memberCount, Token beginToken, Token endToken) {
    DirectParserASTContentClassOrMixinBodyEnd data =
        new DirectParserASTContentClassOrMixinBodyEnd(DirectParserASTType.END,
            kind: kind,
            memberCount: memberCount,
            beginToken: beginToken,
            endToken: endToken);
    seen(data);
  }

  void beginClassOrNamedMixinApplicationPrelude(Token token) {
    DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin data =
        new DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void beginClassDeclaration(Token begin, Token abstractToken, Token name) {
    DirectParserASTContentClassDeclarationBegin data =
        new DirectParserASTContentClassDeclarationBegin(
            DirectParserASTType.BEGIN,
            begin: begin,
            abstractToken: abstractToken,
            name: name);
    seen(data);
  }

  void handleClassExtends(Token extendsKeyword, int typeCount) {
    DirectParserASTContentClassExtendsHandle data =
        new DirectParserASTContentClassExtendsHandle(DirectParserASTType.HANDLE,
            extendsKeyword: extendsKeyword, typeCount: typeCount);
    seen(data);
  }

  void handleClassOrMixinImplements(
      Token implementsKeyword, int interfacesCount) {
    DirectParserASTContentClassOrMixinImplementsHandle data =
        new DirectParserASTContentClassOrMixinImplementsHandle(
            DirectParserASTType.HANDLE,
            implementsKeyword: implementsKeyword,
            interfacesCount: interfacesCount);
    seen(data);
  }

  void handleClassHeader(Token begin, Token classKeyword, Token nativeToken) {
    DirectParserASTContentClassHeaderHandle data =
        new DirectParserASTContentClassHeaderHandle(DirectParserASTType.HANDLE,
            begin: begin, classKeyword: classKeyword, nativeToken: nativeToken);
    seen(data);
  }

  void handleRecoverClassHeader() {
    DirectParserASTContentRecoverClassHeaderHandle data =
        new DirectParserASTContentRecoverClassHeaderHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }

  void endClassDeclaration(Token beginToken, Token endToken) {
    DirectParserASTContentClassDeclarationEnd data =
        new DirectParserASTContentClassDeclarationEnd(DirectParserASTType.END,
            beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void beginMixinDeclaration(Token mixinKeyword, Token name) {
    DirectParserASTContentMixinDeclarationBegin data =
        new DirectParserASTContentMixinDeclarationBegin(
            DirectParserASTType.BEGIN,
            mixinKeyword: mixinKeyword,
            name: name);
    seen(data);
  }

  void handleMixinOn(Token onKeyword, int typeCount) {
    DirectParserASTContentMixinOnHandle data =
        new DirectParserASTContentMixinOnHandle(DirectParserASTType.HANDLE,
            onKeyword: onKeyword, typeCount: typeCount);
    seen(data);
  }

  void handleMixinHeader(Token mixinKeyword) {
    DirectParserASTContentMixinHeaderHandle data =
        new DirectParserASTContentMixinHeaderHandle(DirectParserASTType.HANDLE,
            mixinKeyword: mixinKeyword);
    seen(data);
  }

  void handleRecoverMixinHeader() {
    DirectParserASTContentRecoverMixinHeaderHandle data =
        new DirectParserASTContentRecoverMixinHeaderHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }

  void endMixinDeclaration(Token mixinKeyword, Token endToken) {
    DirectParserASTContentMixinDeclarationEnd data =
        new DirectParserASTContentMixinDeclarationEnd(DirectParserASTType.END,
            mixinKeyword: mixinKeyword, endToken: endToken);
    seen(data);
  }

  void beginUncategorizedTopLevelDeclaration(Token token) {
    DirectParserASTContentUncategorizedTopLevelDeclarationBegin data =
        new DirectParserASTContentUncategorizedTopLevelDeclarationBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void beginExtensionDeclarationPrelude(Token extensionKeyword) {
    DirectParserASTContentExtensionDeclarationPreludeBegin data =
        new DirectParserASTContentExtensionDeclarationPreludeBegin(
            DirectParserASTType.BEGIN,
            extensionKeyword: extensionKeyword);
    seen(data);
  }

  void beginExtensionDeclaration(Token extensionKeyword, Token name) {
    DirectParserASTContentExtensionDeclarationBegin data =
        new DirectParserASTContentExtensionDeclarationBegin(
            DirectParserASTType.BEGIN,
            extensionKeyword: extensionKeyword,
            name: name);
    seen(data);
  }

  void endExtensionDeclaration(
      Token extensionKeyword, Token onKeyword, Token endToken) {
    DirectParserASTContentExtensionDeclarationEnd data =
        new DirectParserASTContentExtensionDeclarationEnd(
            DirectParserASTType.END,
            extensionKeyword: extensionKeyword,
            onKeyword: onKeyword,
            endToken: endToken);
    seen(data);
  }

  void beginCombinators(Token token) {
    DirectParserASTContentCombinatorsBegin data =
        new DirectParserASTContentCombinatorsBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endCombinators(int count) {
    DirectParserASTContentCombinatorsEnd data =
        new DirectParserASTContentCombinatorsEnd(DirectParserASTType.END,
            count: count);
    seen(data);
  }

  void beginCompilationUnit(Token token) {
    DirectParserASTContentCompilationUnitBegin data =
        new DirectParserASTContentCompilationUnitBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void handleDirectivesOnly() {
    DirectParserASTContentDirectivesOnlyHandle data =
        new DirectParserASTContentDirectivesOnlyHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }

  void endCompilationUnit(int count, Token token) {
    DirectParserASTContentCompilationUnitEnd data =
        new DirectParserASTContentCompilationUnitEnd(DirectParserASTType.END,
            count: count, token: token);
    seen(data);
  }

  void beginConstLiteral(Token token) {
    DirectParserASTContentConstLiteralBegin data =
        new DirectParserASTContentConstLiteralBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endConstLiteral(Token token) {
    DirectParserASTContentConstLiteralEnd data =
        new DirectParserASTContentConstLiteralEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginConstructorReference(Token start) {
    DirectParserASTContentConstructorReferenceBegin data =
        new DirectParserASTContentConstructorReferenceBegin(
            DirectParserASTType.BEGIN,
            start: start);
    seen(data);
  }

  void endConstructorReference(
      Token start, Token periodBeforeName, Token endToken) {
    DirectParserASTContentConstructorReferenceEnd data =
        new DirectParserASTContentConstructorReferenceEnd(
            DirectParserASTType.END,
            start: start,
            periodBeforeName: periodBeforeName,
            endToken: endToken);
    seen(data);
  }

  void beginDoWhileStatement(Token token) {
    DirectParserASTContentDoWhileStatementBegin data =
        new DirectParserASTContentDoWhileStatementBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endDoWhileStatement(
      Token doKeyword, Token whileKeyword, Token endToken) {
    DirectParserASTContentDoWhileStatementEnd data =
        new DirectParserASTContentDoWhileStatementEnd(DirectParserASTType.END,
            doKeyword: doKeyword,
            whileKeyword: whileKeyword,
            endToken: endToken);
    seen(data);
  }

  void beginDoWhileStatementBody(Token token) {
    DirectParserASTContentDoWhileStatementBodyBegin data =
        new DirectParserASTContentDoWhileStatementBodyBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endDoWhileStatementBody(Token token) {
    DirectParserASTContentDoWhileStatementBodyEnd data =
        new DirectParserASTContentDoWhileStatementBodyEnd(
            DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginWhileStatementBody(Token token) {
    DirectParserASTContentWhileStatementBodyBegin data =
        new DirectParserASTContentWhileStatementBodyBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endWhileStatementBody(Token token) {
    DirectParserASTContentWhileStatementBodyEnd data =
        new DirectParserASTContentWhileStatementBodyEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginEnum(Token enumKeyword) {
    DirectParserASTContentEnumBegin data = new DirectParserASTContentEnumBegin(
        DirectParserASTType.BEGIN,
        enumKeyword: enumKeyword);
    seen(data);
  }

  void endEnum(Token enumKeyword, Token leftBrace, int count) {
    DirectParserASTContentEnumEnd data = new DirectParserASTContentEnumEnd(
        DirectParserASTType.END,
        enumKeyword: enumKeyword,
        leftBrace: leftBrace,
        count: count);
    seen(data);
  }

  void beginExport(Token token) {
    DirectParserASTContentExportBegin data =
        new DirectParserASTContentExportBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endExport(Token exportKeyword, Token semicolon) {
    DirectParserASTContentExportEnd data = new DirectParserASTContentExportEnd(
        DirectParserASTType.END,
        exportKeyword: exportKeyword,
        semicolon: semicolon);
    seen(data);
  }

  void handleExtraneousExpression(Token token, Message message) {
    DirectParserASTContentExtraneousExpressionHandle data =
        new DirectParserASTContentExtraneousExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token,
            message: message);
    seen(data);
  }

  void handleExpressionStatement(Token token) {
    DirectParserASTContentExpressionStatementHandle data =
        new DirectParserASTContentExpressionStatementHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginFactoryMethod(
      Token lastConsumed, Token externalToken, Token constToken) {
    DirectParserASTContentFactoryMethodBegin data =
        new DirectParserASTContentFactoryMethodBegin(DirectParserASTType.BEGIN,
            lastConsumed: lastConsumed,
            externalToken: externalToken,
            constToken: constToken);
    seen(data);
  }

  void endClassFactoryMethod(
      Token beginToken, Token factoryKeyword, Token endToken) {
    DirectParserASTContentClassFactoryMethodEnd data =
        new DirectParserASTContentClassFactoryMethodEnd(DirectParserASTType.END,
            beginToken: beginToken,
            factoryKeyword: factoryKeyword,
            endToken: endToken);
    seen(data);
  }

  void endMixinFactoryMethod(
      Token beginToken, Token factoryKeyword, Token endToken) {
    DirectParserASTContentMixinFactoryMethodEnd data =
        new DirectParserASTContentMixinFactoryMethodEnd(DirectParserASTType.END,
            beginToken: beginToken,
            factoryKeyword: factoryKeyword,
            endToken: endToken);
    seen(data);
  }

  void endExtensionFactoryMethod(
      Token beginToken, Token factoryKeyword, Token endToken) {
    DirectParserASTContentExtensionFactoryMethodEnd data =
        new DirectParserASTContentExtensionFactoryMethodEnd(
            DirectParserASTType.END,
            beginToken: beginToken,
            factoryKeyword: factoryKeyword,
            endToken: endToken);
    seen(data);
  }

  void beginFormalParameter(Token token, MemberKind kind, Token requiredToken,
      Token covariantToken, Token varFinalOrConst) {
    DirectParserASTContentFormalParameterBegin data =
        new DirectParserASTContentFormalParameterBegin(
            DirectParserASTType.BEGIN,
            token: token,
            kind: kind,
            requiredToken: requiredToken,
            covariantToken: covariantToken,
            varFinalOrConst: varFinalOrConst);
    seen(data);
  }

  void endFormalParameter(
      Token thisKeyword,
      Token periodAfterThis,
      Token nameToken,
      Token initializerStart,
      Token initializerEnd,
      FormalParameterKind kind,
      MemberKind memberKind) {
    DirectParserASTContentFormalParameterEnd data =
        new DirectParserASTContentFormalParameterEnd(DirectParserASTType.END,
            thisKeyword: thisKeyword,
            periodAfterThis: periodAfterThis,
            nameToken: nameToken,
            initializerStart: initializerStart,
            initializerEnd: initializerEnd,
            kind: kind,
            memberKind: memberKind);
    seen(data);
  }

  void handleNoFormalParameters(Token token, MemberKind kind) {
    DirectParserASTContentNoFormalParametersHandle data =
        new DirectParserASTContentNoFormalParametersHandle(
            DirectParserASTType.HANDLE,
            token: token,
            kind: kind);
    seen(data);
  }

  void beginFormalParameters(Token token, MemberKind kind) {
    DirectParserASTContentFormalParametersBegin data =
        new DirectParserASTContentFormalParametersBegin(
            DirectParserASTType.BEGIN,
            token: token,
            kind: kind);
    seen(data);
  }

  void endFormalParameters(
      int count, Token beginToken, Token endToken, MemberKind kind) {
    DirectParserASTContentFormalParametersEnd data =
        new DirectParserASTContentFormalParametersEnd(DirectParserASTType.END,
            count: count,
            beginToken: beginToken,
            endToken: endToken,
            kind: kind);
    seen(data);
  }

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

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

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

  void handleForInitializerEmptyStatement(Token token) {
    DirectParserASTContentForInitializerEmptyStatementHandle data =
        new DirectParserASTContentForInitializerEmptyStatementHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleForInitializerExpressionStatement(Token token, bool forIn) {
    DirectParserASTContentForInitializerExpressionStatementHandle data =
        new DirectParserASTContentForInitializerExpressionStatementHandle(
            DirectParserASTType.HANDLE,
            token: token,
            forIn: forIn);
    seen(data);
  }

  void handleForInitializerLocalVariableDeclaration(Token token, bool forIn) {
    DirectParserASTContentForInitializerLocalVariableDeclarationHandle data =
        new DirectParserASTContentForInitializerLocalVariableDeclarationHandle(
            DirectParserASTType.HANDLE,
            token: token,
            forIn: forIn);
    seen(data);
  }

  void beginForStatement(Token token) {
    DirectParserASTContentForStatementBegin data =
        new DirectParserASTContentForStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void handleForLoopParts(Token forKeyword, Token leftParen,
      Token leftSeparator, int updateExpressionCount) {
    DirectParserASTContentForLoopPartsHandle data =
        new DirectParserASTContentForLoopPartsHandle(DirectParserASTType.HANDLE,
            forKeyword: forKeyword,
            leftParen: leftParen,
            leftSeparator: leftSeparator,
            updateExpressionCount: updateExpressionCount);
    seen(data);
  }

  void endForStatement(Token endToken) {
    DirectParserASTContentForStatementEnd data =
        new DirectParserASTContentForStatementEnd(DirectParserASTType.END,
            endToken: endToken);
    seen(data);
  }

  void beginForStatementBody(Token token) {
    DirectParserASTContentForStatementBodyBegin data =
        new DirectParserASTContentForStatementBodyBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endForStatementBody(Token token) {
    DirectParserASTContentForStatementBodyEnd data =
        new DirectParserASTContentForStatementBodyEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void handleForInLoopParts(Token awaitToken, Token forToken,
      Token leftParenthesis, Token inKeyword) {
    DirectParserASTContentForInLoopPartsHandle data =
        new DirectParserASTContentForInLoopPartsHandle(
            DirectParserASTType.HANDLE,
            awaitToken: awaitToken,
            forToken: forToken,
            leftParenthesis: leftParenthesis,
            inKeyword: inKeyword);
    seen(data);
  }

  void endForIn(Token endToken) {
    DirectParserASTContentForInEnd data = new DirectParserASTContentForInEnd(
        DirectParserASTType.END,
        endToken: endToken);
    seen(data);
  }

  void beginForInExpression(Token token) {
    DirectParserASTContentForInExpressionBegin data =
        new DirectParserASTContentForInExpressionBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endForInExpression(Token token) {
    DirectParserASTContentForInExpressionEnd data =
        new DirectParserASTContentForInExpressionEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginForInBody(Token token) {
    DirectParserASTContentForInBodyBegin data =
        new DirectParserASTContentForInBodyBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endForInBody(Token token) {
    DirectParserASTContentForInBodyEnd data =
        new DirectParserASTContentForInBodyEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginNamedFunctionExpression(Token token) {
    DirectParserASTContentNamedFunctionExpressionBegin data =
        new DirectParserASTContentNamedFunctionExpressionBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endNamedFunctionExpression(Token endToken) {
    DirectParserASTContentNamedFunctionExpressionEnd data =
        new DirectParserASTContentNamedFunctionExpressionEnd(
            DirectParserASTType.END,
            endToken: endToken);
    seen(data);
  }

  void beginLocalFunctionDeclaration(Token token) {
    DirectParserASTContentLocalFunctionDeclarationBegin data =
        new DirectParserASTContentLocalFunctionDeclarationBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endLocalFunctionDeclaration(Token endToken) {
    DirectParserASTContentLocalFunctionDeclarationEnd data =
        new DirectParserASTContentLocalFunctionDeclarationEnd(
            DirectParserASTType.END,
            endToken: endToken);
    seen(data);
  }

  void beginBlockFunctionBody(Token token) {
    DirectParserASTContentBlockFunctionBodyBegin data =
        new DirectParserASTContentBlockFunctionBodyBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endBlockFunctionBody(int count, Token beginToken, Token endToken) {
    DirectParserASTContentBlockFunctionBodyEnd data =
        new DirectParserASTContentBlockFunctionBodyEnd(DirectParserASTType.END,
            count: count, beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void handleNoFunctionBody(Token token) {
    DirectParserASTContentNoFunctionBodyHandle data =
        new DirectParserASTContentNoFunctionBodyHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleFunctionBodySkipped(Token token, bool isExpressionBody) {
    DirectParserASTContentFunctionBodySkippedHandle data =
        new DirectParserASTContentFunctionBodySkippedHandle(
            DirectParserASTType.HANDLE,
            token: token,
            isExpressionBody: isExpressionBody);
    seen(data);
  }

  void beginFunctionName(Token token) {
    DirectParserASTContentFunctionNameBegin data =
        new DirectParserASTContentFunctionNameBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endFunctionName(Token beginToken, Token token) {
    DirectParserASTContentFunctionNameEnd data =
        new DirectParserASTContentFunctionNameEnd(DirectParserASTType.END,
            beginToken: beginToken, token: token);
    seen(data);
  }

  void beginFunctionTypeAlias(Token token) {
    DirectParserASTContentFunctionTypeAliasBegin data =
        new DirectParserASTContentFunctionTypeAliasBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endFunctionTypeAlias(
      Token typedefKeyword, Token equals, Token endToken) {
    DirectParserASTContentFunctionTypeAliasEnd data =
        new DirectParserASTContentFunctionTypeAliasEnd(DirectParserASTType.END,
            typedefKeyword: typedefKeyword, equals: equals, endToken: endToken);
    seen(data);
  }

  void handleClassWithClause(Token withKeyword) {
    DirectParserASTContentClassWithClauseHandle data =
        new DirectParserASTContentClassWithClauseHandle(
            DirectParserASTType.HANDLE,
            withKeyword: withKeyword);
    seen(data);
  }

  void handleClassNoWithClause() {
    DirectParserASTContentClassNoWithClauseHandle data =
        new DirectParserASTContentClassNoWithClauseHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }

  void beginNamedMixinApplication(
      Token begin, Token abstractToken, Token name) {
    DirectParserASTContentNamedMixinApplicationBegin data =
        new DirectParserASTContentNamedMixinApplicationBegin(
            DirectParserASTType.BEGIN,
            begin: begin,
            abstractToken: abstractToken,
            name: name);
    seen(data);
  }

  void handleNamedMixinApplicationWithClause(Token withKeyword) {
    DirectParserASTContentNamedMixinApplicationWithClauseHandle data =
        new DirectParserASTContentNamedMixinApplicationWithClauseHandle(
            DirectParserASTType.HANDLE,
            withKeyword: withKeyword);
    seen(data);
  }

  void endNamedMixinApplication(Token begin, Token classKeyword, Token equals,
      Token implementsKeyword, Token endToken) {
    DirectParserASTContentNamedMixinApplicationEnd data =
        new DirectParserASTContentNamedMixinApplicationEnd(
            DirectParserASTType.END,
            begin: begin,
            classKeyword: classKeyword,
            equals: equals,
            implementsKeyword: implementsKeyword,
            endToken: endToken);
    seen(data);
  }

  void beginHide(Token hideKeyword) {
    DirectParserASTContentHideBegin data = new DirectParserASTContentHideBegin(
        DirectParserASTType.BEGIN,
        hideKeyword: hideKeyword);
    seen(data);
  }

  void endHide(Token hideKeyword) {
    DirectParserASTContentHideEnd data = new DirectParserASTContentHideEnd(
        DirectParserASTType.END,
        hideKeyword: hideKeyword);
    seen(data);
  }

  void handleIdentifierList(int count) {
    DirectParserASTContentIdentifierListHandle data =
        new DirectParserASTContentIdentifierListHandle(
            DirectParserASTType.HANDLE,
            count: count);
    seen(data);
  }

  void beginTypeList(Token token) {
    DirectParserASTContentTypeListBegin data =
        new DirectParserASTContentTypeListBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endTypeList(int count) {
    DirectParserASTContentTypeListEnd data =
        new DirectParserASTContentTypeListEnd(DirectParserASTType.END,
            count: count);
    seen(data);
  }

  void beginIfStatement(Token token) {
    DirectParserASTContentIfStatementBegin data =
        new DirectParserASTContentIfStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endIfStatement(Token ifToken, Token elseToken) {
    DirectParserASTContentIfStatementEnd data =
        new DirectParserASTContentIfStatementEnd(DirectParserASTType.END,
            ifToken: ifToken, elseToken: elseToken);
    seen(data);
  }

  void beginThenStatement(Token token) {
    DirectParserASTContentThenStatementBegin data =
        new DirectParserASTContentThenStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endThenStatement(Token token) {
    DirectParserASTContentThenStatementEnd data =
        new DirectParserASTContentThenStatementEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginElseStatement(Token token) {
    DirectParserASTContentElseStatementBegin data =
        new DirectParserASTContentElseStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endElseStatement(Token token) {
    DirectParserASTContentElseStatementEnd data =
        new DirectParserASTContentElseStatementEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginImport(Token importKeyword) {
    DirectParserASTContentImportBegin data =
        new DirectParserASTContentImportBegin(DirectParserASTType.BEGIN,
            importKeyword: importKeyword);
    seen(data);
  }

  void handleImportPrefix(Token deferredKeyword, Token asKeyword) {
    DirectParserASTContentImportPrefixHandle data =
        new DirectParserASTContentImportPrefixHandle(DirectParserASTType.HANDLE,
            deferredKeyword: deferredKeyword, asKeyword: asKeyword);
    seen(data);
  }

  void endImport(Token importKeyword, Token semicolon) {
    DirectParserASTContentImportEnd data = new DirectParserASTContentImportEnd(
        DirectParserASTType.END,
        importKeyword: importKeyword,
        semicolon: semicolon);
    seen(data);
  }

  void handleRecoverImport(Token semicolon) {
    DirectParserASTContentRecoverImportHandle data =
        new DirectParserASTContentRecoverImportHandle(
            DirectParserASTType.HANDLE,
            semicolon: semicolon);
    seen(data);
  }

  void beginConditionalUris(Token token) {
    DirectParserASTContentConditionalUrisBegin data =
        new DirectParserASTContentConditionalUrisBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endConditionalUris(int count) {
    DirectParserASTContentConditionalUrisEnd data =
        new DirectParserASTContentConditionalUrisEnd(DirectParserASTType.END,
            count: count);
    seen(data);
  }

  void beginConditionalUri(Token ifKeyword) {
    DirectParserASTContentConditionalUriBegin data =
        new DirectParserASTContentConditionalUriBegin(DirectParserASTType.BEGIN,
            ifKeyword: ifKeyword);
    seen(data);
  }

  void endConditionalUri(Token ifKeyword, Token leftParen, Token equalSign) {
    DirectParserASTContentConditionalUriEnd data =
        new DirectParserASTContentConditionalUriEnd(DirectParserASTType.END,
            ifKeyword: ifKeyword, leftParen: leftParen, equalSign: equalSign);
    seen(data);
  }

  void handleDottedName(int count, Token firstIdentifier) {
    DirectParserASTContentDottedNameHandle data =
        new DirectParserASTContentDottedNameHandle(DirectParserASTType.HANDLE,
            count: count, firstIdentifier: firstIdentifier);
    seen(data);
  }

  void beginImplicitCreationExpression(Token token) {
    DirectParserASTContentImplicitCreationExpressionBegin data =
        new DirectParserASTContentImplicitCreationExpressionBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endImplicitCreationExpression(Token token) {
    DirectParserASTContentImplicitCreationExpressionEnd data =
        new DirectParserASTContentImplicitCreationExpressionEnd(
            DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginInitializedIdentifier(Token token) {
    DirectParserASTContentInitializedIdentifierBegin data =
        new DirectParserASTContentInitializedIdentifierBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endInitializedIdentifier(Token nameToken) {
    DirectParserASTContentInitializedIdentifierEnd data =
        new DirectParserASTContentInitializedIdentifierEnd(
            DirectParserASTType.END,
            nameToken: nameToken);
    seen(data);
  }

  void beginFieldInitializer(Token token) {
    DirectParserASTContentFieldInitializerBegin data =
        new DirectParserASTContentFieldInitializerBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endFieldInitializer(Token assignment, Token token) {
    DirectParserASTContentFieldInitializerEnd data =
        new DirectParserASTContentFieldInitializerEnd(DirectParserASTType.END,
            assignment: assignment, token: token);
    seen(data);
  }

  void handleNoFieldInitializer(Token token) {
    DirectParserASTContentNoFieldInitializerHandle data =
        new DirectParserASTContentNoFieldInitializerHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginVariableInitializer(Token token) {
    DirectParserASTContentVariableInitializerBegin data =
        new DirectParserASTContentVariableInitializerBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endVariableInitializer(Token assignmentOperator) {
    DirectParserASTContentVariableInitializerEnd data =
        new DirectParserASTContentVariableInitializerEnd(
            DirectParserASTType.END,
            assignmentOperator: assignmentOperator);
    seen(data);
  }

  void handleNoVariableInitializer(Token token) {
    DirectParserASTContentNoVariableInitializerHandle data =
        new DirectParserASTContentNoVariableInitializerHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginInitializer(Token token) {
    DirectParserASTContentInitializerBegin data =
        new DirectParserASTContentInitializerBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endInitializer(Token token) {
    DirectParserASTContentInitializerEnd data =
        new DirectParserASTContentInitializerEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginInitializers(Token token) {
    DirectParserASTContentInitializersBegin data =
        new DirectParserASTContentInitializersBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endInitializers(int count, Token beginToken, Token endToken) {
    DirectParserASTContentInitializersEnd data =
        new DirectParserASTContentInitializersEnd(DirectParserASTType.END,
            count: count, beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void handleNoInitializers() {
    DirectParserASTContentNoInitializersHandle data =
        new DirectParserASTContentNoInitializersHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }

  void handleInvalidExpression(Token token) {
    DirectParserASTContentInvalidExpressionHandle data =
        new DirectParserASTContentInvalidExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleInvalidFunctionBody(Token token) {
    DirectParserASTContentInvalidFunctionBodyHandle data =
        new DirectParserASTContentInvalidFunctionBodyHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleInvalidTypeReference(Token token) {
    DirectParserASTContentInvalidTypeReferenceHandle data =
        new DirectParserASTContentInvalidTypeReferenceHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleLabel(Token token) {
    DirectParserASTContentLabelHandle data =
        new DirectParserASTContentLabelHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginLabeledStatement(Token token, int labelCount) {
    DirectParserASTContentLabeledStatementBegin data =
        new DirectParserASTContentLabeledStatementBegin(
            DirectParserASTType.BEGIN,
            token: token,
            labelCount: labelCount);
    seen(data);
  }

  void endLabeledStatement(int labelCount) {
    DirectParserASTContentLabeledStatementEnd data =
        new DirectParserASTContentLabeledStatementEnd(DirectParserASTType.END,
            labelCount: labelCount);
    seen(data);
  }

  void beginLibraryName(Token token) {
    DirectParserASTContentLibraryNameBegin data =
        new DirectParserASTContentLibraryNameBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endLibraryName(Token libraryKeyword, Token semicolon) {
    DirectParserASTContentLibraryNameEnd data =
        new DirectParserASTContentLibraryNameEnd(DirectParserASTType.END,
            libraryKeyword: libraryKeyword, semicolon: semicolon);
    seen(data);
  }

  void handleLiteralMapEntry(Token colon, Token endToken) {
    DirectParserASTContentLiteralMapEntryHandle data =
        new DirectParserASTContentLiteralMapEntryHandle(
            DirectParserASTType.HANDLE,
            colon: colon,
            endToken: endToken);
    seen(data);
  }

  void beginLiteralString(Token token) {
    DirectParserASTContentLiteralStringBegin data =
        new DirectParserASTContentLiteralStringBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void handleInterpolationExpression(Token leftBracket, Token rightBracket) {
    DirectParserASTContentInterpolationExpressionHandle data =
        new DirectParserASTContentInterpolationExpressionHandle(
            DirectParserASTType.HANDLE,
            leftBracket: leftBracket,
            rightBracket: rightBracket);
    seen(data);
  }

  void endLiteralString(int interpolationCount, Token endToken) {
    DirectParserASTContentLiteralStringEnd data =
        new DirectParserASTContentLiteralStringEnd(DirectParserASTType.END,
            interpolationCount: interpolationCount, endToken: endToken);
    seen(data);
  }

  void handleStringJuxtaposition(Token startToken, int literalCount) {
    DirectParserASTContentStringJuxtapositionHandle data =
        new DirectParserASTContentStringJuxtapositionHandle(
            DirectParserASTType.HANDLE,
            startToken: startToken,
            literalCount: literalCount);
    seen(data);
  }

  void beginMember() {
    DirectParserASTContentMemberBegin data =
        new DirectParserASTContentMemberBegin(DirectParserASTType.BEGIN);
    seen(data);
  }

  void handleInvalidMember(Token endToken) {
    DirectParserASTContentInvalidMemberHandle data =
        new DirectParserASTContentInvalidMemberHandle(
            DirectParserASTType.HANDLE,
            endToken: endToken);
    seen(data);
  }

  void endMember() {
    DirectParserASTContentMemberEnd data =
        new DirectParserASTContentMemberEnd(DirectParserASTType.END);
    seen(data);
  }

  void beginMethod(Token externalToken, Token staticToken, Token covariantToken,
      Token varFinalOrConst, Token getOrSet, Token name) {
    DirectParserASTContentMethodBegin data =
        new DirectParserASTContentMethodBegin(DirectParserASTType.BEGIN,
            externalToken: externalToken,
            staticToken: staticToken,
            covariantToken: covariantToken,
            varFinalOrConst: varFinalOrConst,
            getOrSet: getOrSet,
            name: name);
    seen(data);
  }

  void endClassMethod(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    DirectParserASTContentClassMethodEnd data =
        new DirectParserASTContentClassMethodEnd(DirectParserASTType.END,
            getOrSet: getOrSet,
            beginToken: beginToken,
            beginParam: beginParam,
            beginInitializers: beginInitializers,
            endToken: endToken);
    seen(data);
  }

  void endMixinMethod(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    DirectParserASTContentMixinMethodEnd data =
        new DirectParserASTContentMixinMethodEnd(DirectParserASTType.END,
            getOrSet: getOrSet,
            beginToken: beginToken,
            beginParam: beginParam,
            beginInitializers: beginInitializers,
            endToken: endToken);
    seen(data);
  }

  void endExtensionMethod(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    DirectParserASTContentExtensionMethodEnd data =
        new DirectParserASTContentExtensionMethodEnd(DirectParserASTType.END,
            getOrSet: getOrSet,
            beginToken: beginToken,
            beginParam: beginParam,
            beginInitializers: beginInitializers,
            endToken: endToken);
    seen(data);
  }

  void endClassConstructor(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    DirectParserASTContentClassConstructorEnd data =
        new DirectParserASTContentClassConstructorEnd(DirectParserASTType.END,
            getOrSet: getOrSet,
            beginToken: beginToken,
            beginParam: beginParam,
            beginInitializers: beginInitializers,
            endToken: endToken);
    seen(data);
  }

  void endMixinConstructor(Token getOrSet, Token beginToken, Token beginParam,
      Token beginInitializers, Token endToken) {
    DirectParserASTContentMixinConstructorEnd data =
        new DirectParserASTContentMixinConstructorEnd(DirectParserASTType.END,
            getOrSet: getOrSet,
            beginToken: beginToken,
            beginParam: beginParam,
            beginInitializers: beginInitializers,
            endToken: endToken);
    seen(data);
  }

  void endExtensionConstructor(Token getOrSet, Token beginToken,
      Token beginParam, Token beginInitializers, Token endToken) {
    DirectParserASTContentExtensionConstructorEnd data =
        new DirectParserASTContentExtensionConstructorEnd(
            DirectParserASTType.END,
            getOrSet: getOrSet,
            beginToken: beginToken,
            beginParam: beginParam,
            beginInitializers: beginInitializers,
            endToken: endToken);
    seen(data);
  }

  void beginMetadataStar(Token token) {
    DirectParserASTContentMetadataStarBegin data =
        new DirectParserASTContentMetadataStarBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endMetadataStar(int count) {
    DirectParserASTContentMetadataStarEnd data =
        new DirectParserASTContentMetadataStarEnd(DirectParserASTType.END,
            count: count);
    seen(data);
  }

  void beginMetadata(Token token) {
    DirectParserASTContentMetadataBegin data =
        new DirectParserASTContentMetadataBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
    DirectParserASTContentMetadataEnd data =
        new DirectParserASTContentMetadataEnd(DirectParserASTType.END,
            beginToken: beginToken,
            periodBeforeName: periodBeforeName,
            endToken: endToken);
    seen(data);
  }

  void beginOptionalFormalParameters(Token token) {
    DirectParserASTContentOptionalFormalParametersBegin data =
        new DirectParserASTContentOptionalFormalParametersBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endOptionalFormalParameters(
      int count, Token beginToken, Token endToken) {
    DirectParserASTContentOptionalFormalParametersEnd data =
        new DirectParserASTContentOptionalFormalParametersEnd(
            DirectParserASTType.END,
            count: count,
            beginToken: beginToken,
            endToken: endToken);
    seen(data);
  }

  void beginPart(Token token) {
    DirectParserASTContentPartBegin data = new DirectParserASTContentPartBegin(
        DirectParserASTType.BEGIN,
        token: token);
    seen(data);
  }

  void endPart(Token partKeyword, Token semicolon) {
    DirectParserASTContentPartEnd data = new DirectParserASTContentPartEnd(
        DirectParserASTType.END,
        partKeyword: partKeyword,
        semicolon: semicolon);
    seen(data);
  }

  void beginPartOf(Token token) {
    DirectParserASTContentPartOfBegin data =
        new DirectParserASTContentPartOfBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endPartOf(
      Token partKeyword, Token ofKeyword, Token semicolon, bool hasName) {
    DirectParserASTContentPartOfEnd data = new DirectParserASTContentPartOfEnd(
        DirectParserASTType.END,
        partKeyword: partKeyword,
        ofKeyword: ofKeyword,
        semicolon: semicolon,
        hasName: hasName);
    seen(data);
  }

  void beginRedirectingFactoryBody(Token token) {
    DirectParserASTContentRedirectingFactoryBodyBegin data =
        new DirectParserASTContentRedirectingFactoryBodyBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endRedirectingFactoryBody(Token beginToken, Token endToken) {
    DirectParserASTContentRedirectingFactoryBodyEnd data =
        new DirectParserASTContentRedirectingFactoryBodyEnd(
            DirectParserASTType.END,
            beginToken: beginToken,
            endToken: endToken);
    seen(data);
  }

  void beginReturnStatement(Token token) {
    DirectParserASTContentReturnStatementBegin data =
        new DirectParserASTContentReturnStatementBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void handleNativeFunctionBody(Token nativeToken, Token semicolon) {
    DirectParserASTContentNativeFunctionBodyHandle data =
        new DirectParserASTContentNativeFunctionBodyHandle(
            DirectParserASTType.HANDLE,
            nativeToken: nativeToken,
            semicolon: semicolon);
    seen(data);
  }

  void handleNativeFunctionBodyIgnored(Token nativeToken, Token semicolon) {
    DirectParserASTContentNativeFunctionBodyIgnoredHandle data =
        new DirectParserASTContentNativeFunctionBodyIgnoredHandle(
            DirectParserASTType.HANDLE,
            nativeToken: nativeToken,
            semicolon: semicolon);
    seen(data);
  }

  void handleNativeFunctionBodySkipped(Token nativeToken, Token semicolon) {
    DirectParserASTContentNativeFunctionBodySkippedHandle data =
        new DirectParserASTContentNativeFunctionBodySkippedHandle(
            DirectParserASTType.HANDLE,
            nativeToken: nativeToken,
            semicolon: semicolon);
    seen(data);
  }

  void handleEmptyFunctionBody(Token semicolon) {
    DirectParserASTContentEmptyFunctionBodyHandle data =
        new DirectParserASTContentEmptyFunctionBodyHandle(
            DirectParserASTType.HANDLE,
            semicolon: semicolon);
    seen(data);
  }

  void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
    DirectParserASTContentExpressionFunctionBodyHandle data =
        new DirectParserASTContentExpressionFunctionBodyHandle(
            DirectParserASTType.HANDLE,
            arrowToken: arrowToken,
            endToken: endToken);
    seen(data);
  }

  void endReturnStatement(
      bool hasExpression, Token beginToken, Token endToken) {
    DirectParserASTContentReturnStatementEnd data =
        new DirectParserASTContentReturnStatementEnd(DirectParserASTType.END,
            hasExpression: hasExpression,
            beginToken: beginToken,
            endToken: endToken);
    seen(data);
  }

  void handleSend(Token beginToken, Token endToken) {
    DirectParserASTContentSendHandle data =
        new DirectParserASTContentSendHandle(DirectParserASTType.HANDLE,
            beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void beginShow(Token showKeyword) {
    DirectParserASTContentShowBegin data = new DirectParserASTContentShowBegin(
        DirectParserASTType.BEGIN,
        showKeyword: showKeyword);
    seen(data);
  }

  void endShow(Token showKeyword) {
    DirectParserASTContentShowEnd data = new DirectParserASTContentShowEnd(
        DirectParserASTType.END,
        showKeyword: showKeyword);
    seen(data);
  }

  void beginSwitchStatement(Token token) {
    DirectParserASTContentSwitchStatementBegin data =
        new DirectParserASTContentSwitchStatementBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endSwitchStatement(Token switchKeyword, Token endToken) {
    DirectParserASTContentSwitchStatementEnd data =
        new DirectParserASTContentSwitchStatementEnd(DirectParserASTType.END,
            switchKeyword: switchKeyword, endToken: endToken);
    seen(data);
  }

  void beginSwitchBlock(Token token) {
    DirectParserASTContentSwitchBlockBegin data =
        new DirectParserASTContentSwitchBlockBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
    DirectParserASTContentSwitchBlockEnd data =
        new DirectParserASTContentSwitchBlockEnd(DirectParserASTType.END,
            caseCount: caseCount, beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void beginLiteralSymbol(Token token) {
    DirectParserASTContentLiteralSymbolBegin data =
        new DirectParserASTContentLiteralSymbolBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endLiteralSymbol(Token hashToken, int identifierCount) {
    DirectParserASTContentLiteralSymbolEnd data =
        new DirectParserASTContentLiteralSymbolEnd(DirectParserASTType.END,
            hashToken: hashToken, identifierCount: identifierCount);
    seen(data);
  }

  void handleThrowExpression(Token throwToken, Token endToken) {
    DirectParserASTContentThrowExpressionHandle data =
        new DirectParserASTContentThrowExpressionHandle(
            DirectParserASTType.HANDLE,
            throwToken: throwToken,
            endToken: endToken);
    seen(data);
  }

  void beginRethrowStatement(Token token) {
    DirectParserASTContentRethrowStatementBegin data =
        new DirectParserASTContentRethrowStatementBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endRethrowStatement(Token rethrowToken, Token endToken) {
    DirectParserASTContentRethrowStatementEnd data =
        new DirectParserASTContentRethrowStatementEnd(DirectParserASTType.END,
            rethrowToken: rethrowToken, endToken: endToken);
    seen(data);
  }

  void endTopLevelDeclaration(Token nextToken) {
    DirectParserASTContentTopLevelDeclarationEnd data =
        new DirectParserASTContentTopLevelDeclarationEnd(
            DirectParserASTType.END,
            nextToken: nextToken);
    seen(data);
  }

  void handleInvalidTopLevelDeclaration(Token endToken) {
    DirectParserASTContentInvalidTopLevelDeclarationHandle data =
        new DirectParserASTContentInvalidTopLevelDeclarationHandle(
            DirectParserASTType.HANDLE,
            endToken: endToken);
    seen(data);
  }

  void beginTopLevelMember(Token token) {
    DirectParserASTContentTopLevelMemberBegin data =
        new DirectParserASTContentTopLevelMemberBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void beginFields(Token lastConsumed) {
    DirectParserASTContentFieldsBegin data =
        new DirectParserASTContentFieldsBegin(DirectParserASTType.BEGIN,
            lastConsumed: lastConsumed);
    seen(data);
  }

  void endTopLevelFields(
      Token externalToken,
      Token staticToken,
      Token covariantToken,
      Token lateToken,
      Token varFinalOrConst,
      int count,
      Token beginToken,
      Token endToken) {
    DirectParserASTContentTopLevelFieldsEnd data =
        new DirectParserASTContentTopLevelFieldsEnd(DirectParserASTType.END,
            externalToken: externalToken,
            staticToken: staticToken,
            covariantToken: covariantToken,
            lateToken: lateToken,
            varFinalOrConst: varFinalOrConst,
            count: count,
            beginToken: beginToken,
            endToken: endToken);
    seen(data);
  }

  void beginTopLevelMethod(Token lastConsumed, Token externalToken) {
    DirectParserASTContentTopLevelMethodBegin data =
        new DirectParserASTContentTopLevelMethodBegin(DirectParserASTType.BEGIN,
            lastConsumed: lastConsumed, externalToken: externalToken);
    seen(data);
  }

  void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
    DirectParserASTContentTopLevelMethodEnd data =
        new DirectParserASTContentTopLevelMethodEnd(DirectParserASTType.END,
            beginToken: beginToken, getOrSet: getOrSet, endToken: endToken);
    seen(data);
  }

  void beginTryStatement(Token token) {
    DirectParserASTContentTryStatementBegin data =
        new DirectParserASTContentTryStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void handleCaseMatch(Token caseKeyword, Token colon) {
    DirectParserASTContentCaseMatchHandle data =
        new DirectParserASTContentCaseMatchHandle(DirectParserASTType.HANDLE,
            caseKeyword: caseKeyword, colon: colon);
    seen(data);
  }

  void beginCatchClause(Token token) {
    DirectParserASTContentCatchClauseBegin data =
        new DirectParserASTContentCatchClauseBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endCatchClause(Token token) {
    DirectParserASTContentCatchClauseEnd data =
        new DirectParserASTContentCatchClauseEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void handleCatchBlock(Token onKeyword, Token catchKeyword, Token comma) {
    DirectParserASTContentCatchBlockHandle data =
        new DirectParserASTContentCatchBlockHandle(DirectParserASTType.HANDLE,
            onKeyword: onKeyword, catchKeyword: catchKeyword, comma: comma);
    seen(data);
  }

  void handleFinallyBlock(Token finallyKeyword) {
    DirectParserASTContentFinallyBlockHandle data =
        new DirectParserASTContentFinallyBlockHandle(DirectParserASTType.HANDLE,
            finallyKeyword: finallyKeyword);
    seen(data);
  }

  void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
    DirectParserASTContentTryStatementEnd data =
        new DirectParserASTContentTryStatementEnd(DirectParserASTType.END,
            catchCount: catchCount,
            tryKeyword: tryKeyword,
            finallyKeyword: finallyKeyword);
    seen(data);
  }

  void handleType(Token beginToken, Token questionMark) {
    DirectParserASTContentTypeHandle data =
        new DirectParserASTContentTypeHandle(DirectParserASTType.HANDLE,
            beginToken: beginToken, questionMark: questionMark);
    seen(data);
  }

  void handleNonNullAssertExpression(Token bang) {
    DirectParserASTContentNonNullAssertExpressionHandle data =
        new DirectParserASTContentNonNullAssertExpressionHandle(
            DirectParserASTType.HANDLE,
            bang: bang);
    seen(data);
  }

  void handleNoName(Token token) {
    DirectParserASTContentNoNameHandle data =
        new DirectParserASTContentNoNameHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginFunctionType(Token beginToken) {
    DirectParserASTContentFunctionTypeBegin data =
        new DirectParserASTContentFunctionTypeBegin(DirectParserASTType.BEGIN,
            beginToken: beginToken);
    seen(data);
  }

  void endFunctionType(Token functionToken, Token questionMark) {
    DirectParserASTContentFunctionTypeEnd data =
        new DirectParserASTContentFunctionTypeEnd(DirectParserASTType.END,
            functionToken: functionToken, questionMark: questionMark);
    seen(data);
  }

  void beginTypeArguments(Token token) {
    DirectParserASTContentTypeArgumentsBegin data =
        new DirectParserASTContentTypeArgumentsBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endTypeArguments(int count, Token beginToken, Token endToken) {
    DirectParserASTContentTypeArgumentsEnd data =
        new DirectParserASTContentTypeArgumentsEnd(DirectParserASTType.END,
            count: count, beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void handleInvalidTypeArguments(Token token) {
    DirectParserASTContentInvalidTypeArgumentsHandle data =
        new DirectParserASTContentInvalidTypeArgumentsHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleNoTypeArguments(Token token) {
    DirectParserASTContentNoTypeArgumentsHandle data =
        new DirectParserASTContentNoTypeArgumentsHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginTypeVariable(Token token) {
    DirectParserASTContentTypeVariableBegin data =
        new DirectParserASTContentTypeVariableBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void handleTypeVariablesDefined(Token token, int count) {
    DirectParserASTContentTypeVariablesDefinedHandle data =
        new DirectParserASTContentTypeVariablesDefinedHandle(
            DirectParserASTType.HANDLE,
            token: token,
            count: count);
    seen(data);
  }

  void endTypeVariable(
      Token token, int index, Token extendsOrSuper, Token variance) {
    DirectParserASTContentTypeVariableEnd data =
        new DirectParserASTContentTypeVariableEnd(DirectParserASTType.END,
            token: token,
            index: index,
            extendsOrSuper: extendsOrSuper,
            variance: variance);
    seen(data);
  }

  void beginTypeVariables(Token token) {
    DirectParserASTContentTypeVariablesBegin data =
        new DirectParserASTContentTypeVariablesBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endTypeVariables(Token beginToken, Token endToken) {
    DirectParserASTContentTypeVariablesEnd data =
        new DirectParserASTContentTypeVariablesEnd(DirectParserASTType.END,
            beginToken: beginToken, endToken: endToken);
    seen(data);
  }

  void beginFunctionExpression(Token token) {
    DirectParserASTContentFunctionExpressionBegin data =
        new DirectParserASTContentFunctionExpressionBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endFunctionExpression(Token beginToken, Token token) {
    DirectParserASTContentFunctionExpressionEnd data =
        new DirectParserASTContentFunctionExpressionEnd(DirectParserASTType.END,
            beginToken: beginToken, token: token);
    seen(data);
  }

  void beginVariablesDeclaration(
      Token token, Token lateToken, Token varFinalOrConst) {
    DirectParserASTContentVariablesDeclarationBegin data =
        new DirectParserASTContentVariablesDeclarationBegin(
            DirectParserASTType.BEGIN,
            token: token,
            lateToken: lateToken,
            varFinalOrConst: varFinalOrConst);
    seen(data);
  }

  void endVariablesDeclaration(int count, Token endToken) {
    DirectParserASTContentVariablesDeclarationEnd data =
        new DirectParserASTContentVariablesDeclarationEnd(
            DirectParserASTType.END,
            count: count,
            endToken: endToken);
    seen(data);
  }

  void beginWhileStatement(Token token) {
    DirectParserASTContentWhileStatementBegin data =
        new DirectParserASTContentWhileStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endWhileStatement(Token whileKeyword, Token endToken) {
    DirectParserASTContentWhileStatementEnd data =
        new DirectParserASTContentWhileStatementEnd(DirectParserASTType.END,
            whileKeyword: whileKeyword, endToken: endToken);
    seen(data);
  }

  void beginAsOperatorType(Token operator) {
    DirectParserASTContentAsOperatorTypeBegin data =
        new DirectParserASTContentAsOperatorTypeBegin(DirectParserASTType.BEGIN,
            operator: operator);
    seen(data);
  }

  void endAsOperatorType(Token operator) {
    DirectParserASTContentAsOperatorTypeEnd data =
        new DirectParserASTContentAsOperatorTypeEnd(DirectParserASTType.END,
            operator: operator);
    seen(data);
  }

  void handleAsOperator(Token operator) {
    DirectParserASTContentAsOperatorHandle data =
        new DirectParserASTContentAsOperatorHandle(DirectParserASTType.HANDLE,
            operator: operator);
    seen(data);
  }

  void handleAssignmentExpression(Token token) {
    DirectParserASTContentAssignmentExpressionHandle data =
        new DirectParserASTContentAssignmentExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginBinaryExpression(Token token) {
    DirectParserASTContentBinaryExpressionBegin data =
        new DirectParserASTContentBinaryExpressionBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endBinaryExpression(Token token) {
    DirectParserASTContentBinaryExpressionEnd data =
        new DirectParserASTContentBinaryExpressionEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void handleEndingBinaryExpression(Token token) {
    DirectParserASTContentEndingBinaryExpressionHandle data =
        new DirectParserASTContentEndingBinaryExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginConditionalExpression(Token question) {
    DirectParserASTContentConditionalExpressionBegin data =
        new DirectParserASTContentConditionalExpressionBegin(
            DirectParserASTType.BEGIN,
            question: question);
    seen(data);
  }

  void handleConditionalExpressionColon() {
    DirectParserASTContentConditionalExpressionColonHandle data =
        new DirectParserASTContentConditionalExpressionColonHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }

  void endConditionalExpression(Token question, Token colon) {
    DirectParserASTContentConditionalExpressionEnd data =
        new DirectParserASTContentConditionalExpressionEnd(
            DirectParserASTType.END,
            question: question,
            colon: colon);
    seen(data);
  }

  void beginConstExpression(Token constKeyword) {
    DirectParserASTContentConstExpressionBegin data =
        new DirectParserASTContentConstExpressionBegin(
            DirectParserASTType.BEGIN,
            constKeyword: constKeyword);
    seen(data);
  }

  void endConstExpression(Token token) {
    DirectParserASTContentConstExpressionEnd data =
        new DirectParserASTContentConstExpressionEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void handleConstFactory(Token constKeyword) {
    DirectParserASTContentConstFactoryHandle data =
        new DirectParserASTContentConstFactoryHandle(DirectParserASTType.HANDLE,
            constKeyword: constKeyword);
    seen(data);
  }

  void beginForControlFlow(Token awaitToken, Token forToken) {
    DirectParserASTContentForControlFlowBegin data =
        new DirectParserASTContentForControlFlowBegin(DirectParserASTType.BEGIN,
            awaitToken: awaitToken, forToken: forToken);
    seen(data);
  }

  void endForControlFlow(Token token) {
    DirectParserASTContentForControlFlowEnd data =
        new DirectParserASTContentForControlFlowEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void endForInControlFlow(Token token) {
    DirectParserASTContentForInControlFlowEnd data =
        new DirectParserASTContentForInControlFlowEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void beginIfControlFlow(Token ifToken) {
    DirectParserASTContentIfControlFlowBegin data =
        new DirectParserASTContentIfControlFlowBegin(DirectParserASTType.BEGIN,
            ifToken: ifToken);
    seen(data);
  }

  void handleThenControlFlow(Token token) {
    DirectParserASTContentThenControlFlowHandle data =
        new DirectParserASTContentThenControlFlowHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleElseControlFlow(Token elseToken) {
    DirectParserASTContentElseControlFlowHandle data =
        new DirectParserASTContentElseControlFlowHandle(
            DirectParserASTType.HANDLE,
            elseToken: elseToken);
    seen(data);
  }

  void endIfControlFlow(Token token) {
    DirectParserASTContentIfControlFlowEnd data =
        new DirectParserASTContentIfControlFlowEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void endIfElseControlFlow(Token token) {
    DirectParserASTContentIfElseControlFlowEnd data =
        new DirectParserASTContentIfElseControlFlowEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void handleSpreadExpression(Token spreadToken) {
    DirectParserASTContentSpreadExpressionHandle data =
        new DirectParserASTContentSpreadExpressionHandle(
            DirectParserASTType.HANDLE,
            spreadToken: spreadToken);
    seen(data);
  }

  void beginFunctionTypedFormalParameter(Token token) {
    DirectParserASTContentFunctionTypedFormalParameterBegin data =
        new DirectParserASTContentFunctionTypedFormalParameterBegin(
            DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endFunctionTypedFormalParameter(Token nameToken, Token question) {
    DirectParserASTContentFunctionTypedFormalParameterEnd data =
        new DirectParserASTContentFunctionTypedFormalParameterEnd(
            DirectParserASTType.END,
            nameToken: nameToken,
            question: question);
    seen(data);
  }

  void handleIdentifier(Token token, IdentifierContext context) {
    DirectParserASTContentIdentifierHandle data =
        new DirectParserASTContentIdentifierHandle(DirectParserASTType.HANDLE,
            token: token, context: context);
    seen(data);
  }

  void handleIndexedExpression(
      Token question, Token openSquareBracket, Token closeSquareBracket) {
    DirectParserASTContentIndexedExpressionHandle data =
        new DirectParserASTContentIndexedExpressionHandle(
            DirectParserASTType.HANDLE,
            question: question,
            openSquareBracket: openSquareBracket,
            closeSquareBracket: closeSquareBracket);
    seen(data);
  }

  void beginIsOperatorType(Token operator) {
    DirectParserASTContentIsOperatorTypeBegin data =
        new DirectParserASTContentIsOperatorTypeBegin(DirectParserASTType.BEGIN,
            operator: operator);
    seen(data);
  }

  void endIsOperatorType(Token operator) {
    DirectParserASTContentIsOperatorTypeEnd data =
        new DirectParserASTContentIsOperatorTypeEnd(DirectParserASTType.END,
            operator: operator);
    seen(data);
  }

  void handleIsOperator(Token isOperator, Token not) {
    DirectParserASTContentIsOperatorHandle data =
        new DirectParserASTContentIsOperatorHandle(DirectParserASTType.HANDLE,
            isOperator: isOperator, not: not);
    seen(data);
  }

  void handleLiteralBool(Token token) {
    DirectParserASTContentLiteralBoolHandle data =
        new DirectParserASTContentLiteralBoolHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleBreakStatement(
      bool hasTarget, Token breakKeyword, Token endToken) {
    DirectParserASTContentBreakStatementHandle data =
        new DirectParserASTContentBreakStatementHandle(
            DirectParserASTType.HANDLE,
            hasTarget: hasTarget,
            breakKeyword: breakKeyword,
            endToken: endToken);
    seen(data);
  }

  void handleContinueStatement(
      bool hasTarget, Token continueKeyword, Token endToken) {
    DirectParserASTContentContinueStatementHandle data =
        new DirectParserASTContentContinueStatementHandle(
            DirectParserASTType.HANDLE,
            hasTarget: hasTarget,
            continueKeyword: continueKeyword,
            endToken: endToken);
    seen(data);
  }

  void handleEmptyStatement(Token token) {
    DirectParserASTContentEmptyStatementHandle data =
        new DirectParserASTContentEmptyStatementHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginAssert(Token assertKeyword, Assert kind) {
    DirectParserASTContentAssertBegin data =
        new DirectParserASTContentAssertBegin(DirectParserASTType.BEGIN,
            assertKeyword: assertKeyword, kind: kind);
    seen(data);
  }

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

  void handleLiteralDouble(Token token) {
    DirectParserASTContentLiteralDoubleHandle data =
        new DirectParserASTContentLiteralDoubleHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleLiteralInt(Token token) {
    DirectParserASTContentLiteralIntHandle data =
        new DirectParserASTContentLiteralIntHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleLiteralList(
      int count, Token leftBracket, Token constKeyword, Token rightBracket) {
    DirectParserASTContentLiteralListHandle data =
        new DirectParserASTContentLiteralListHandle(DirectParserASTType.HANDLE,
            count: count,
            leftBracket: leftBracket,
            constKeyword: constKeyword,
            rightBracket: rightBracket);
    seen(data);
  }

  void handleLiteralSetOrMap(
    int count,
    Token leftBrace,
    Token constKeyword,
    Token rightBrace,
    bool hasSetEntry,
  ) {
    DirectParserASTContentLiteralSetOrMapHandle data =
        new DirectParserASTContentLiteralSetOrMapHandle(
            DirectParserASTType.HANDLE,
            count: count,
            leftBrace: leftBrace,
            constKeyword: constKeyword,
            rightBrace: rightBrace,
            hasSetEntry: hasSetEntry);
    seen(data);
  }

  void handleLiteralNull(Token token) {
    DirectParserASTContentLiteralNullHandle data =
        new DirectParserASTContentLiteralNullHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleNativeClause(Token nativeToken, bool hasName) {
    DirectParserASTContentNativeClauseHandle data =
        new DirectParserASTContentNativeClauseHandle(DirectParserASTType.HANDLE,
            nativeToken: nativeToken, hasName: hasName);
    seen(data);
  }

  void handleNamedArgument(Token colon) {
    DirectParserASTContentNamedArgumentHandle data =
        new DirectParserASTContentNamedArgumentHandle(
            DirectParserASTType.HANDLE,
            colon: colon);
    seen(data);
  }

  void beginNewExpression(Token token) {
    DirectParserASTContentNewExpressionBegin data =
        new DirectParserASTContentNewExpressionBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endNewExpression(Token token) {
    DirectParserASTContentNewExpressionEnd data =
        new DirectParserASTContentNewExpressionEnd(DirectParserASTType.END,
            token: token);
    seen(data);
  }

  void handleNoArguments(Token token) {
    DirectParserASTContentNoArgumentsHandle data =
        new DirectParserASTContentNoArgumentsHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
    DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle
        data =
        new DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleNoType(Token lastConsumed) {
    DirectParserASTContentNoTypeHandle data =
        new DirectParserASTContentNoTypeHandle(DirectParserASTType.HANDLE,
            lastConsumed: lastConsumed);
    seen(data);
  }

  void handleNoTypeVariables(Token token) {
    DirectParserASTContentNoTypeVariablesHandle data =
        new DirectParserASTContentNoTypeVariablesHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleOperator(Token token) {
    DirectParserASTContentOperatorHandle data =
        new DirectParserASTContentOperatorHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleSymbolVoid(Token token) {
    DirectParserASTContentSymbolVoidHandle data =
        new DirectParserASTContentSymbolVoidHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleOperatorName(Token operatorKeyword, Token token) {
    DirectParserASTContentOperatorNameHandle data =
        new DirectParserASTContentOperatorNameHandle(DirectParserASTType.HANDLE,
            operatorKeyword: operatorKeyword, token: token);
    seen(data);
  }

  void handleInvalidOperatorName(Token operatorKeyword, Token token) {
    DirectParserASTContentInvalidOperatorNameHandle data =
        new DirectParserASTContentInvalidOperatorNameHandle(
            DirectParserASTType.HANDLE,
            operatorKeyword: operatorKeyword,
            token: token);
    seen(data);
  }

  void handleParenthesizedCondition(Token token) {
    DirectParserASTContentParenthesizedConditionHandle data =
        new DirectParserASTContentParenthesizedConditionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleParenthesizedExpression(Token token) {
    DirectParserASTContentParenthesizedExpressionHandle data =
        new DirectParserASTContentParenthesizedExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleQualified(Token period) {
    DirectParserASTContentQualifiedHandle data =
        new DirectParserASTContentQualifiedHandle(DirectParserASTType.HANDLE,
            period: period);
    seen(data);
  }

  void handleStringPart(Token token) {
    DirectParserASTContentStringPartHandle data =
        new DirectParserASTContentStringPartHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleSuperExpression(Token token, IdentifierContext context) {
    DirectParserASTContentSuperExpressionHandle data =
        new DirectParserASTContentSuperExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token,
            context: context);
    seen(data);
  }

  void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
    DirectParserASTContentSwitchCaseBegin data =
        new DirectParserASTContentSwitchCaseBegin(DirectParserASTType.BEGIN,
            labelCount: labelCount,
            expressionCount: expressionCount,
            firstToken: firstToken);
    seen(data);
  }

  void endSwitchCase(
      int labelCount,
      int expressionCount,
      Token defaultKeyword,
      Token colonAfterDefault,
      int statementCount,
      Token firstToken,
      Token endToken) {
    DirectParserASTContentSwitchCaseEnd data =
        new DirectParserASTContentSwitchCaseEnd(DirectParserASTType.END,
            labelCount: labelCount,
            expressionCount: expressionCount,
            defaultKeyword: defaultKeyword,
            colonAfterDefault: colonAfterDefault,
            statementCount: statementCount,
            firstToken: firstToken,
            endToken: endToken);
    seen(data);
  }

  void handleThisExpression(Token token, IdentifierContext context) {
    DirectParserASTContentThisExpressionHandle data =
        new DirectParserASTContentThisExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token,
            context: context);
    seen(data);
  }

  void handleUnaryPostfixAssignmentExpression(Token token) {
    DirectParserASTContentUnaryPostfixAssignmentExpressionHandle data =
        new DirectParserASTContentUnaryPostfixAssignmentExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleUnaryPrefixExpression(Token token) {
    DirectParserASTContentUnaryPrefixExpressionHandle data =
        new DirectParserASTContentUnaryPrefixExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleUnaryPrefixAssignmentExpression(Token token) {
    DirectParserASTContentUnaryPrefixAssignmentExpressionHandle data =
        new DirectParserASTContentUnaryPrefixAssignmentExpressionHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginFormalParameterDefaultValueExpression() {
    DirectParserASTContentFormalParameterDefaultValueExpressionBegin data =
        new DirectParserASTContentFormalParameterDefaultValueExpressionBegin(
            DirectParserASTType.BEGIN);
    seen(data);
  }

  void endFormalParameterDefaultValueExpression() {
    DirectParserASTContentFormalParameterDefaultValueExpressionEnd data =
        new DirectParserASTContentFormalParameterDefaultValueExpressionEnd(
            DirectParserASTType.END);
    seen(data);
  }

  void handleValuedFormalParameter(Token equals, Token token) {
    DirectParserASTContentValuedFormalParameterHandle data =
        new DirectParserASTContentValuedFormalParameterHandle(
            DirectParserASTType.HANDLE,
            equals: equals,
            token: token);
    seen(data);
  }

  void handleFormalParameterWithoutValue(Token token) {
    DirectParserASTContentFormalParameterWithoutValueHandle data =
        new DirectParserASTContentFormalParameterWithoutValueHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleVoidKeyword(Token token) {
    DirectParserASTContentVoidKeywordHandle data =
        new DirectParserASTContentVoidKeywordHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleVoidKeywordWithTypeArguments(Token token) {
    DirectParserASTContentVoidKeywordWithTypeArgumentsHandle data =
        new DirectParserASTContentVoidKeywordWithTypeArgumentsHandle(
            DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void beginYieldStatement(Token token) {
    DirectParserASTContentYieldStatementBegin data =
        new DirectParserASTContentYieldStatementBegin(DirectParserASTType.BEGIN,
            token: token);
    seen(data);
  }

  void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
    DirectParserASTContentYieldStatementEnd data =
        new DirectParserASTContentYieldStatementEnd(DirectParserASTType.END,
            yieldToken: yieldToken, starToken: starToken, endToken: endToken);
    seen(data);
  }

  void endInvalidYieldStatement(Token beginToken, Token starToken,
      Token endToken, MessageCode errorCode) {
    DirectParserASTContentInvalidYieldStatementEnd data =
        new DirectParserASTContentInvalidYieldStatementEnd(
            DirectParserASTType.END,
            beginToken: beginToken,
            starToken: starToken,
            endToken: endToken,
            errorCode: errorCode);
    seen(data);
  }

  void handleRecoverableError(
      Message message, Token startToken, Token endToken) {
    DirectParserASTContentRecoverableErrorHandle data =
        new DirectParserASTContentRecoverableErrorHandle(
            DirectParserASTType.HANDLE,
            message: message,
            startToken: startToken,
            endToken: endToken);
    seen(data);
  }

  void handleErrorToken(ErrorToken token) {
    DirectParserASTContentErrorTokenHandle data =
        new DirectParserASTContentErrorTokenHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleUnescapeError(
      Message message, Token location, int stringOffset, int length) {
    DirectParserASTContentUnescapeErrorHandle data =
        new DirectParserASTContentUnescapeErrorHandle(
            DirectParserASTType.HANDLE,
            message: message,
            location: location,
            stringOffset: stringOffset,
            length: length);
    seen(data);
  }

  void handleInvalidStatement(Token token, Message message) {
    DirectParserASTContentInvalidStatementHandle data =
        new DirectParserASTContentInvalidStatementHandle(
            DirectParserASTType.HANDLE,
            token: token,
            message: message);
    seen(data);
  }

  void handleScript(Token token) {
    DirectParserASTContentScriptHandle data =
        new DirectParserASTContentScriptHandle(DirectParserASTType.HANDLE,
            token: token);
    seen(data);
  }

  void handleCommentReferenceText(String referenceSource, int referenceOffset) {
    DirectParserASTContentCommentReferenceTextHandle data =
        new DirectParserASTContentCommentReferenceTextHandle(
            DirectParserASTType.HANDLE,
            referenceSource: referenceSource,
            referenceOffset: referenceOffset);
    seen(data);
  }

  void handleCommentReference(
      Token newKeyword, Token prefix, Token period, Token token) {
    DirectParserASTContentCommentReferenceHandle data =
        new DirectParserASTContentCommentReferenceHandle(
            DirectParserASTType.HANDLE,
            newKeyword: newKeyword,
            prefix: prefix,
            period: period,
            token: token);
    seen(data);
  }

  void handleNoCommentReference() {
    DirectParserASTContentNoCommentReferenceHandle data =
        new DirectParserASTContentNoCommentReferenceHandle(
            DirectParserASTType.HANDLE);
    seen(data);
  }
}

class DirectParserASTContentArgumentsBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentArgumentsBegin(DirectParserASTType type, {this.token})
      : super("Arguments", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentArgumentsEnd extends DirectParserASTContent {
  final int count;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentArgumentsEnd(DirectParserASTType type,
      {this.count, this.beginToken, this.endToken})
      : super("Arguments", type);

  Map<String, Object> get deprecatedArguments => {
        "count": count,
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentAsyncModifierHandle extends DirectParserASTContent {
  final Token asyncToken;
  final Token starToken;

  DirectParserASTContentAsyncModifierHandle(DirectParserASTType type,
      {this.asyncToken, this.starToken})
      : super("AsyncModifier", type);

  Map<String, Object> get deprecatedArguments => {
        "asyncToken": asyncToken,
        "starToken": starToken,
      };
}

class DirectParserASTContentAwaitExpressionBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentAwaitExpressionBegin(DirectParserASTType type,
      {this.token})
      : super("AwaitExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentAwaitExpressionEnd extends DirectParserASTContent {
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentAwaitExpressionEnd(DirectParserASTType type,
      {this.beginToken, this.endToken})
      : super("AwaitExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentInvalidAwaitExpressionEnd
    extends DirectParserASTContent {
  final Token beginToken;
  final Token endToken;
  final MessageCode errorCode;

  DirectParserASTContentInvalidAwaitExpressionEnd(DirectParserASTType type,
      {this.beginToken, this.endToken, this.errorCode})
      : super("InvalidAwaitExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "beginToken": beginToken,
        "endToken": endToken,
        "errorCode": errorCode,
      };
}

class DirectParserASTContentBlockBegin extends DirectParserASTContent {
  final Token token;
  final BlockKind blockKind;

  DirectParserASTContentBlockBegin(DirectParserASTType type,
      {this.token, this.blockKind})
      : super("Block", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
        "blockKind": blockKind,
      };
}

class DirectParserASTContentBlockEnd extends DirectParserASTContent {
  final int count;
  final Token beginToken;
  final Token endToken;
  final BlockKind blockKind;

  DirectParserASTContentBlockEnd(DirectParserASTType type,
      {this.count, this.beginToken, this.endToken, this.blockKind})
      : super("Block", type);

  Map<String, Object> get deprecatedArguments => {
        "count": count,
        "beginToken": beginToken,
        "endToken": endToken,
        "blockKind": blockKind,
      };
}

class DirectParserASTContentInvalidTopLevelBlockHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInvalidTopLevelBlockHandle(DirectParserASTType type,
      {this.token})
      : super("InvalidTopLevelBlock", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentCascadeBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentCascadeBegin(DirectParserASTType type, {this.token})
      : super("Cascade", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentCascadeEnd extends DirectParserASTContent {
  DirectParserASTContentCascadeEnd(DirectParserASTType type)
      : super("Cascade", type);

  Map<String, Object> get deprecatedArguments => {};
}

class DirectParserASTContentCaseExpressionBegin extends DirectParserASTContent {
  final Token caseKeyword;

  DirectParserASTContentCaseExpressionBegin(DirectParserASTType type,
      {this.caseKeyword})
      : super("CaseExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "caseKeyword": caseKeyword,
      };
}

class DirectParserASTContentCaseExpressionEnd extends DirectParserASTContent {
  final Token colon;

  DirectParserASTContentCaseExpressionEnd(DirectParserASTType type,
      {this.colon})
      : super("CaseExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "colon": colon,
      };
}

class DirectParserASTContentClassOrMixinBodyBegin
    extends DirectParserASTContent {
  final DeclarationKind kind;
  final Token token;

  DirectParserASTContentClassOrMixinBodyBegin(DirectParserASTType type,
      {this.kind, this.token})
      : super("ClassOrMixinBody", type);

  Map<String, Object> get deprecatedArguments => {
        "kind": kind,
        "token": token,
      };
}

class DirectParserASTContentClassOrMixinBodyEnd extends DirectParserASTContent {
  final DeclarationKind kind;
  final int memberCount;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentClassOrMixinBodyEnd(DirectParserASTType type,
      {this.kind, this.memberCount, this.beginToken, this.endToken})
      : super("ClassOrMixinBody", type);

  Map<String, Object> get deprecatedArguments => {
        "kind": kind,
        "memberCount": memberCount,
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin(
      DirectParserASTType type,
      {this.token})
      : super("ClassOrNamedMixinApplicationPrelude", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentClassDeclarationBegin
    extends DirectParserASTContent {
  final Token begin;
  final Token abstractToken;
  final Token name;

  DirectParserASTContentClassDeclarationBegin(DirectParserASTType type,
      {this.begin, this.abstractToken, this.name})
      : super("ClassDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "begin": begin,
        "abstractToken": abstractToken,
        "name": name,
      };
}

class DirectParserASTContentClassExtendsHandle extends DirectParserASTContent {
  final Token extendsKeyword;
  final int typeCount;

  DirectParserASTContentClassExtendsHandle(DirectParserASTType type,
      {this.extendsKeyword, this.typeCount})
      : super("ClassExtends", type);

  Map<String, Object> get deprecatedArguments => {
        "extendsKeyword": extendsKeyword,
        "typeCount": typeCount,
      };
}

class DirectParserASTContentClassOrMixinImplementsHandle
    extends DirectParserASTContent {
  final Token implementsKeyword;
  final int interfacesCount;

  DirectParserASTContentClassOrMixinImplementsHandle(DirectParserASTType type,
      {this.implementsKeyword, this.interfacesCount})
      : super("ClassOrMixinImplements", type);

  Map<String, Object> get deprecatedArguments => {
        "implementsKeyword": implementsKeyword,
        "interfacesCount": interfacesCount,
      };
}

class DirectParserASTContentClassHeaderHandle extends DirectParserASTContent {
  final Token begin;
  final Token classKeyword;
  final Token nativeToken;

  DirectParserASTContentClassHeaderHandle(DirectParserASTType type,
      {this.begin, this.classKeyword, this.nativeToken})
      : super("ClassHeader", type);

  Map<String, Object> get deprecatedArguments => {
        "begin": begin,
        "classKeyword": classKeyword,
        "nativeToken": nativeToken,
      };
}

class DirectParserASTContentRecoverClassHeaderHandle
    extends DirectParserASTContent {
  DirectParserASTContentRecoverClassHeaderHandle(DirectParserASTType type)
      : super("RecoverClassHeader", type);

  Map<String, Object> get deprecatedArguments => {};
}

class DirectParserASTContentClassDeclarationEnd extends DirectParserASTContent {
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentClassDeclarationEnd(DirectParserASTType type,
      {this.beginToken, this.endToken})
      : super("ClassDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentMixinDeclarationBegin
    extends DirectParserASTContent {
  final Token mixinKeyword;
  final Token name;

  DirectParserASTContentMixinDeclarationBegin(DirectParserASTType type,
      {this.mixinKeyword, this.name})
      : super("MixinDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "mixinKeyword": mixinKeyword,
        "name": name,
      };
}

class DirectParserASTContentMixinOnHandle extends DirectParserASTContent {
  final Token onKeyword;
  final int typeCount;

  DirectParserASTContentMixinOnHandle(DirectParserASTType type,
      {this.onKeyword, this.typeCount})
      : super("MixinOn", type);

  Map<String, Object> get deprecatedArguments => {
        "onKeyword": onKeyword,
        "typeCount": typeCount,
      };
}

class DirectParserASTContentMixinHeaderHandle extends DirectParserASTContent {
  final Token mixinKeyword;

  DirectParserASTContentMixinHeaderHandle(DirectParserASTType type,
      {this.mixinKeyword})
      : super("MixinHeader", type);

  Map<String, Object> get deprecatedArguments => {
        "mixinKeyword": mixinKeyword,
      };
}

class DirectParserASTContentRecoverMixinHeaderHandle
    extends DirectParserASTContent {
  DirectParserASTContentRecoverMixinHeaderHandle(DirectParserASTType type)
      : super("RecoverMixinHeader", type);

  Map<String, Object> get deprecatedArguments => {};
}

class DirectParserASTContentMixinDeclarationEnd extends DirectParserASTContent {
  final Token mixinKeyword;
  final Token endToken;

  DirectParserASTContentMixinDeclarationEnd(DirectParserASTType type,
      {this.mixinKeyword, this.endToken})
      : super("MixinDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "mixinKeyword": mixinKeyword,
        "endToken": endToken,
      };
}

class DirectParserASTContentUncategorizedTopLevelDeclarationBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentUncategorizedTopLevelDeclarationBegin(
      DirectParserASTType type,
      {this.token})
      : super("UncategorizedTopLevelDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentExtensionDeclarationPreludeBegin
    extends DirectParserASTContent {
  final Token extensionKeyword;

  DirectParserASTContentExtensionDeclarationPreludeBegin(
      DirectParserASTType type,
      {this.extensionKeyword})
      : super("ExtensionDeclarationPrelude", type);

  Map<String, Object> get deprecatedArguments => {
        "extensionKeyword": extensionKeyword,
      };
}

class DirectParserASTContentExtensionDeclarationBegin
    extends DirectParserASTContent {
  final Token extensionKeyword;
  final Token name;

  DirectParserASTContentExtensionDeclarationBegin(DirectParserASTType type,
      {this.extensionKeyword, this.name})
      : super("ExtensionDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "extensionKeyword": extensionKeyword,
        "name": name,
      };
}

class DirectParserASTContentExtensionDeclarationEnd
    extends DirectParserASTContent {
  final Token extensionKeyword;
  final Token onKeyword;
  final Token endToken;

  DirectParserASTContentExtensionDeclarationEnd(DirectParserASTType type,
      {this.extensionKeyword, this.onKeyword, this.endToken})
      : super("ExtensionDeclaration", type);

  Map<String, Object> get deprecatedArguments => {
        "extensionKeyword": extensionKeyword,
        "onKeyword": onKeyword,
        "endToken": endToken,
      };
}

class DirectParserASTContentCombinatorsBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentCombinatorsBegin(DirectParserASTType type, {this.token})
      : super("Combinators", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentCombinatorsEnd extends DirectParserASTContent {
  final int count;

  DirectParserASTContentCombinatorsEnd(DirectParserASTType type, {this.count})
      : super("Combinators", type);

  Map<String, Object> get deprecatedArguments => {
        "count": count,
      };
}

class DirectParserASTContentCompilationUnitBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentCompilationUnitBegin(DirectParserASTType type,
      {this.token})
      : super("CompilationUnit", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentDirectivesOnlyHandle
    extends DirectParserASTContent {
  DirectParserASTContentDirectivesOnlyHandle(DirectParserASTType type)
      : super("DirectivesOnly", type);

  Map<String, Object> get deprecatedArguments => {};
}

class DirectParserASTContentCompilationUnitEnd extends DirectParserASTContent {
  final int count;
  final Token token;

  DirectParserASTContentCompilationUnitEnd(DirectParserASTType type,
      {this.count, this.token})
      : super("CompilationUnit", type);

  Map<String, Object> get deprecatedArguments => {
        "count": count,
        "token": token,
      };
}

class DirectParserASTContentConstLiteralBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentConstLiteralBegin(DirectParserASTType type,
      {this.token})
      : super("ConstLiteral", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentConstLiteralEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentConstLiteralEnd(DirectParserASTType type, {this.token})
      : super("ConstLiteral", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentConstructorReferenceBegin
    extends DirectParserASTContent {
  final Token start;

  DirectParserASTContentConstructorReferenceBegin(DirectParserASTType type,
      {this.start})
      : super("ConstructorReference", type);

  Map<String, Object> get deprecatedArguments => {
        "start": start,
      };
}

class DirectParserASTContentConstructorReferenceEnd
    extends DirectParserASTContent {
  final Token start;
  final Token periodBeforeName;
  final Token endToken;

  DirectParserASTContentConstructorReferenceEnd(DirectParserASTType type,
      {this.start, this.periodBeforeName, this.endToken})
      : super("ConstructorReference", type);

  Map<String, Object> get deprecatedArguments => {
        "start": start,
        "periodBeforeName": periodBeforeName,
        "endToken": endToken,
      };
}

class DirectParserASTContentDoWhileStatementBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentDoWhileStatementBegin(DirectParserASTType type,
      {this.token})
      : super("DoWhileStatement", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentDoWhileStatementEnd extends DirectParserASTContent {
  final Token doKeyword;
  final Token whileKeyword;
  final Token endToken;

  DirectParserASTContentDoWhileStatementEnd(DirectParserASTType type,
      {this.doKeyword, this.whileKeyword, this.endToken})
      : super("DoWhileStatement", type);

  Map<String, Object> get deprecatedArguments => {
        "doKeyword": doKeyword,
        "whileKeyword": whileKeyword,
        "endToken": endToken,
      };
}

class DirectParserASTContentDoWhileStatementBodyBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentDoWhileStatementBodyBegin(DirectParserASTType type,
      {this.token})
      : super("DoWhileStatementBody", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentDoWhileStatementBodyEnd
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentDoWhileStatementBodyEnd(DirectParserASTType type,
      {this.token})
      : super("DoWhileStatementBody", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentWhileStatementBodyBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentWhileStatementBodyBegin(DirectParserASTType type,
      {this.token})
      : super("WhileStatementBody", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentWhileStatementBodyEnd
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentWhileStatementBodyEnd(DirectParserASTType type,
      {this.token})
      : super("WhileStatementBody", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentEnumBegin extends DirectParserASTContent {
  final Token enumKeyword;

  DirectParserASTContentEnumBegin(DirectParserASTType type, {this.enumKeyword})
      : super("Enum", type);

  Map<String, Object> get deprecatedArguments => {
        "enumKeyword": enumKeyword,
      };
}

class DirectParserASTContentEnumEnd extends DirectParserASTContent {
  final Token enumKeyword;
  final Token leftBrace;
  final int count;

  DirectParserASTContentEnumEnd(DirectParserASTType type,
      {this.enumKeyword, this.leftBrace, this.count})
      : super("Enum", type);

  Map<String, Object> get deprecatedArguments => {
        "enumKeyword": enumKeyword,
        "leftBrace": leftBrace,
        "count": count,
      };
}

class DirectParserASTContentExportBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentExportBegin(DirectParserASTType type, {this.token})
      : super("Export", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentExportEnd extends DirectParserASTContent {
  final Token exportKeyword;
  final Token semicolon;

  DirectParserASTContentExportEnd(DirectParserASTType type,
      {this.exportKeyword, this.semicolon})
      : super("Export", type);

  Map<String, Object> get deprecatedArguments => {
        "exportKeyword": exportKeyword,
        "semicolon": semicolon,
      };
}

class DirectParserASTContentExtraneousExpressionHandle
    extends DirectParserASTContent {
  final Token token;
  final Message message;

  DirectParserASTContentExtraneousExpressionHandle(DirectParserASTType type,
      {this.token, this.message})
      : super("ExtraneousExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
        "message": message,
      };
}

class DirectParserASTContentExpressionStatementHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentExpressionStatementHandle(DirectParserASTType type,
      {this.token})
      : super("ExpressionStatement", type);

  Map<String, Object> get deprecatedArguments => {
        "token": token,
      };
}

class DirectParserASTContentFactoryMethodBegin extends DirectParserASTContent {
  final Token lastConsumed;
  final Token externalToken;
  final Token constToken;

  DirectParserASTContentFactoryMethodBegin(DirectParserASTType type,
      {this.lastConsumed, this.externalToken, this.constToken})
      : super("FactoryMethod", type);

  Map<String, Object> get deprecatedArguments => {
        "lastConsumed": lastConsumed,
        "externalToken": externalToken,
        "constToken": constToken,