// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

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

// 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 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,
      };
}

class DirectParserASTContentClassFactoryMethodEnd
    extends DirectParserASTContent {
  final Token beginToken;
  final Token factoryKeyword;
  final Token endToken;

  DirectParserASTContentClassFactoryMethodEnd(DirectParserASTType type,
      {this.beginToken, this.factoryKeyword, this.endToken})
      : super("ClassFactoryMethod", type);

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

class DirectParserASTContentMixinFactoryMethodEnd
    extends DirectParserASTContent {
  final Token beginToken;
  final Token factoryKeyword;
  final Token endToken;

  DirectParserASTContentMixinFactoryMethodEnd(DirectParserASTType type,
      {this.beginToken, this.factoryKeyword, this.endToken})
      : super("MixinFactoryMethod", type);

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

class DirectParserASTContentExtensionFactoryMethodEnd
    extends DirectParserASTContent {
  final Token beginToken;
  final Token factoryKeyword;
  final Token endToken;

  DirectParserASTContentExtensionFactoryMethodEnd(DirectParserASTType type,
      {this.beginToken, this.factoryKeyword, this.endToken})
      : super("ExtensionFactoryMethod", type);

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

class DirectParserASTContentFormalParameterBegin
    extends DirectParserASTContent {
  final Token token;
  final MemberKind kind;
  final Token requiredToken;
  final Token covariantToken;
  final Token varFinalOrConst;

  DirectParserASTContentFormalParameterBegin(DirectParserASTType type,
      {this.token,
      this.kind,
      this.requiredToken,
      this.covariantToken,
      this.varFinalOrConst})
      : super("FormalParameter", type);

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

class DirectParserASTContentFormalParameterEnd extends DirectParserASTContent {
  final Token thisKeyword;
  final Token periodAfterThis;
  final Token nameToken;
  final Token initializerStart;
  final Token initializerEnd;
  final FormalParameterKind kind;
  final MemberKind memberKind;

  DirectParserASTContentFormalParameterEnd(DirectParserASTType type,
      {this.thisKeyword,
      this.periodAfterThis,
      this.nameToken,
      this.initializerStart,
      this.initializerEnd,
      this.kind,
      this.memberKind})
      : super("FormalParameter", type);

  Map<String, Object> get deprecatedArguments => {
        "thisKeyword": thisKeyword,
        "periodAfterThis": periodAfterThis,
        "nameToken": nameToken,
        "initializerStart": initializerStart,
        "initializerEnd": initializerEnd,
        "kind": kind,
        "memberKind": memberKind,
      };
}

class DirectParserASTContentNoFormalParametersHandle
    extends DirectParserASTContent {
  final Token token;
  final MemberKind kind;

  DirectParserASTContentNoFormalParametersHandle(DirectParserASTType type,
      {this.token, this.kind})
      : super("NoFormalParameters", type);

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

class DirectParserASTContentFormalParametersBegin
    extends DirectParserASTContent {
  final Token token;
  final MemberKind kind;

  DirectParserASTContentFormalParametersBegin(DirectParserASTType type,
      {this.token, this.kind})
      : super("FormalParameters", type);

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

class DirectParserASTContentFormalParametersEnd extends DirectParserASTContent {
  final int count;
  final Token beginToken;
  final Token endToken;
  final MemberKind kind;

  DirectParserASTContentFormalParametersEnd(DirectParserASTType type,
      {this.count, this.beginToken, this.endToken, this.kind})
      : super("FormalParameters", type);

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

class DirectParserASTContentClassFieldsEnd extends DirectParserASTContent {
  final Token abstractToken;
  final Token externalToken;
  final Token staticToken;
  final Token covariantToken;
  final Token lateToken;
  final Token varFinalOrConst;
  final int count;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentClassFieldsEnd(DirectParserASTType type,
      {this.abstractToken,
      this.externalToken,
      this.staticToken,
      this.covariantToken,
      this.lateToken,
      this.varFinalOrConst,
      this.count,
      this.beginToken,
      this.endToken})
      : super("ClassFields", type);

  Map<String, Object> get deprecatedArguments => {
        "abstractToken": abstractToken,
        "externalToken": externalToken,
        "staticToken": staticToken,
        "covariantToken": covariantToken,
        "lateToken": lateToken,
        "varFinalOrConst": varFinalOrConst,
        "count": count,
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentMixinFieldsEnd extends DirectParserASTContent {
  final Token abstractToken;
  final Token externalToken;
  final Token staticToken;
  final Token covariantToken;
  final Token lateToken;
  final Token varFinalOrConst;
  final int count;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentMixinFieldsEnd(DirectParserASTType type,
      {this.abstractToken,
      this.externalToken,
      this.staticToken,
      this.covariantToken,
      this.lateToken,
      this.varFinalOrConst,
      this.count,
      this.beginToken,
      this.endToken})
      : super("MixinFields", type);

  Map<String, Object> get deprecatedArguments => {
        "abstractToken": abstractToken,
        "externalToken": externalToken,
        "staticToken": staticToken,
        "covariantToken": covariantToken,
        "lateToken": lateToken,
        "varFinalOrConst": varFinalOrConst,
        "count": count,
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentExtensionFieldsEnd extends DirectParserASTContent {
  final Token abstractToken;
  final Token externalToken;
  final Token staticToken;
  final Token covariantToken;
  final Token lateToken;
  final Token varFinalOrConst;
  final int count;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentExtensionFieldsEnd(DirectParserASTType type,
      {this.abstractToken,
      this.externalToken,
      this.staticToken,
      this.covariantToken,
      this.lateToken,
      this.varFinalOrConst,
      this.count,
      this.beginToken,
      this.endToken})
      : super("ExtensionFields", type);

  Map<String, Object> get deprecatedArguments => {
        "abstractToken": abstractToken,
        "externalToken": externalToken,
        "staticToken": staticToken,
        "covariantToken": covariantToken,
        "lateToken": lateToken,
        "varFinalOrConst": varFinalOrConst,
        "count": count,
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentForInitializerEmptyStatementHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForInitializerEmptyStatementHandle(
      DirectParserASTType type,
      {this.token})
      : super("ForInitializerEmptyStatement", type);

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

class DirectParserASTContentForInitializerExpressionStatementHandle
    extends DirectParserASTContent {
  final Token token;
  final bool forIn;

  DirectParserASTContentForInitializerExpressionStatementHandle(
      DirectParserASTType type,
      {this.token,
      this.forIn})
      : super("ForInitializerExpressionStatement", type);

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

class DirectParserASTContentForInitializerLocalVariableDeclarationHandle
    extends DirectParserASTContent {
  final Token token;
  final bool forIn;

  DirectParserASTContentForInitializerLocalVariableDeclarationHandle(
      DirectParserASTType type,
      {this.token,
      this.forIn})
      : super("ForInitializerLocalVariableDeclaration", type);

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

class DirectParserASTContentForStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForStatementBegin(DirectParserASTType type,
      {this.token})
      : super("ForStatement", type);

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

class DirectParserASTContentForLoopPartsHandle extends DirectParserASTContent {
  final Token forKeyword;
  final Token leftParen;
  final Token leftSeparator;
  final int updateExpressionCount;

  DirectParserASTContentForLoopPartsHandle(DirectParserASTType type,
      {this.forKeyword,
      this.leftParen,
      this.leftSeparator,
      this.updateExpressionCount})
      : super("ForLoopParts", type);

  Map<String, Object> get deprecatedArguments => {
        "forKeyword": forKeyword,
        "leftParen": leftParen,
        "leftSeparator": leftSeparator,
        "updateExpressionCount": updateExpressionCount,
      };
}

class DirectParserASTContentForStatementEnd extends DirectParserASTContent {
  final Token endToken;

  DirectParserASTContentForStatementEnd(DirectParserASTType type,
      {this.endToken})
      : super("ForStatement", type);

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

class DirectParserASTContentForStatementBodyBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForStatementBodyBegin(DirectParserASTType type,
      {this.token})
      : super("ForStatementBody", type);

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

class DirectParserASTContentForStatementBodyEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForStatementBodyEnd(DirectParserASTType type,
      {this.token})
      : super("ForStatementBody", type);

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

class DirectParserASTContentForInLoopPartsHandle
    extends DirectParserASTContent {
  final Token awaitToken;
  final Token forToken;
  final Token leftParenthesis;
  final Token inKeyword;

  DirectParserASTContentForInLoopPartsHandle(DirectParserASTType type,
      {this.awaitToken, this.forToken, this.leftParenthesis, this.inKeyword})
      : super("ForInLoopParts", type);

  Map<String, Object> get deprecatedArguments => {
        "awaitToken": awaitToken,
        "forToken": forToken,
        "leftParenthesis": leftParenthesis,
        "inKeyword": inKeyword,
      };
}

class DirectParserASTContentForInEnd extends DirectParserASTContent {
  final Token endToken;

  DirectParserASTContentForInEnd(DirectParserASTType type, {this.endToken})
      : super("ForIn", type);

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

class DirectParserASTContentForInExpressionBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForInExpressionBegin(DirectParserASTType type,
      {this.token})
      : super("ForInExpression", type);

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

class DirectParserASTContentForInExpressionEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForInExpressionEnd(DirectParserASTType type,
      {this.token})
      : super("ForInExpression", type);

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

class DirectParserASTContentForInBodyBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForInBodyBegin(DirectParserASTType type, {this.token})
      : super("ForInBody", type);

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

class DirectParserASTContentForInBodyEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForInBodyEnd(DirectParserASTType type, {this.token})
      : super("ForInBody", type);

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

class DirectParserASTContentNamedFunctionExpressionBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNamedFunctionExpressionBegin(DirectParserASTType type,
      {this.token})
      : super("NamedFunctionExpression", type);

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

class DirectParserASTContentNamedFunctionExpressionEnd
    extends DirectParserASTContent {
  final Token endToken;

  DirectParserASTContentNamedFunctionExpressionEnd(DirectParserASTType type,
      {this.endToken})
      : super("NamedFunctionExpression", type);

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

class DirectParserASTContentLocalFunctionDeclarationBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLocalFunctionDeclarationBegin(DirectParserASTType type,
      {this.token})
      : super("LocalFunctionDeclaration", type);

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

class DirectParserASTContentLocalFunctionDeclarationEnd
    extends DirectParserASTContent {
  final Token endToken;

  DirectParserASTContentLocalFunctionDeclarationEnd(DirectParserASTType type,
      {this.endToken})
      : super("LocalFunctionDeclaration", type);

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

class DirectParserASTContentBlockFunctionBodyBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentBlockFunctionBodyBegin(DirectParserASTType type,
      {this.token})
      : super("BlockFunctionBody", type);

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

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

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

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

class DirectParserASTContentNoFunctionBodyHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoFunctionBodyHandle(DirectParserASTType type,
      {this.token})
      : super("NoFunctionBody", type);

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

class DirectParserASTContentFunctionBodySkippedHandle
    extends DirectParserASTContent {
  final Token token;
  final bool isExpressionBody;

  DirectParserASTContentFunctionBodySkippedHandle(DirectParserASTType type,
      {this.token, this.isExpressionBody})
      : super("FunctionBodySkipped", type);

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

class DirectParserASTContentFunctionNameBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentFunctionNameBegin(DirectParserASTType type,
      {this.token})
      : super("FunctionName", type);

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

class DirectParserASTContentFunctionNameEnd extends DirectParserASTContent {
  final Token beginToken;
  final Token token;

  DirectParserASTContentFunctionNameEnd(DirectParserASTType type,
      {this.beginToken, this.token})
      : super("FunctionName", type);

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

class DirectParserASTContentFunctionTypeAliasBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentFunctionTypeAliasBegin(DirectParserASTType type,
      {this.token})
      : super("FunctionTypeAlias", type);

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

class DirectParserASTContentFunctionTypeAliasEnd
    extends DirectParserASTContent {
  final Token typedefKeyword;
  final Token equals;
  final Token endToken;

  DirectParserASTContentFunctionTypeAliasEnd(DirectParserASTType type,
      {this.typedefKeyword, this.equals, this.endToken})
      : super("FunctionTypeAlias", type);

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

class DirectParserASTContentClassWithClauseHandle
    extends DirectParserASTContent {
  final Token withKeyword;

  DirectParserASTContentClassWithClauseHandle(DirectParserASTType type,
      {this.withKeyword})
      : super("ClassWithClause", type);

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

class DirectParserASTContentClassNoWithClauseHandle
    extends DirectParserASTContent {
  DirectParserASTContentClassNoWithClauseHandle(DirectParserASTType type)
      : super("ClassNoWithClause", type);

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

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

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

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

class DirectParserASTContentNamedMixinApplicationWithClauseHandle
    extends DirectParserASTContent {
  final Token withKeyword;

  DirectParserASTContentNamedMixinApplicationWithClauseHandle(
      DirectParserASTType type,
      {this.withKeyword})
      : super("NamedMixinApplicationWithClause", type);

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

class DirectParserASTContentNamedMixinApplicationEnd
    extends DirectParserASTContent {
  final Token begin;
  final Token classKeyword;
  final Token equals;
  final Token implementsKeyword;
  final Token endToken;

  DirectParserASTContentNamedMixinApplicationEnd(DirectParserASTType type,
      {this.begin,
      this.classKeyword,
      this.equals,
      this.implementsKeyword,
      this.endToken})
      : super("NamedMixinApplication", type);

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

class DirectParserASTContentHideBegin extends DirectParserASTContent {
  final Token hideKeyword;

  DirectParserASTContentHideBegin(DirectParserASTType type, {this.hideKeyword})
      : super("Hide", type);

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

class DirectParserASTContentHideEnd extends DirectParserASTContent {
  final Token hideKeyword;

  DirectParserASTContentHideEnd(DirectParserASTType type, {this.hideKeyword})
      : super("Hide", type);

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

class DirectParserASTContentIdentifierListHandle
    extends DirectParserASTContent {
  final int count;

  DirectParserASTContentIdentifierListHandle(DirectParserASTType type,
      {this.count})
      : super("IdentifierList", type);

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

class DirectParserASTContentTypeListBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentTypeListBegin(DirectParserASTType type, {this.token})
      : super("TypeList", type);

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

class DirectParserASTContentTypeListEnd extends DirectParserASTContent {
  final int count;

  DirectParserASTContentTypeListEnd(DirectParserASTType type, {this.count})
      : super("TypeList", type);

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

class DirectParserASTContentIfStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentIfStatementBegin(DirectParserASTType type, {this.token})
      : super("IfStatement", type);

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

class DirectParserASTContentIfStatementEnd extends DirectParserASTContent {
  final Token ifToken;
  final Token elseToken;

  DirectParserASTContentIfStatementEnd(DirectParserASTType type,
      {this.ifToken, this.elseToken})
      : super("IfStatement", type);

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

class DirectParserASTContentThenStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentThenStatementBegin(DirectParserASTType type,
      {this.token})
      : super("ThenStatement", type);

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

class DirectParserASTContentThenStatementEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentThenStatementEnd(DirectParserASTType type, {this.token})
      : super("ThenStatement", type);

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

class DirectParserASTContentElseStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentElseStatementBegin(DirectParserASTType type,
      {this.token})
      : super("ElseStatement", type);

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

class DirectParserASTContentElseStatementEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentElseStatementEnd(DirectParserASTType type, {this.token})
      : super("ElseStatement", type);

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

class DirectParserASTContentImportBegin extends DirectParserASTContent {
  final Token importKeyword;

  DirectParserASTContentImportBegin(DirectParserASTType type,
      {this.importKeyword})
      : super("Import", type);

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

class DirectParserASTContentImportPrefixHandle extends DirectParserASTContent {
  final Token deferredKeyword;
  final Token asKeyword;

  DirectParserASTContentImportPrefixHandle(DirectParserASTType type,
      {this.deferredKeyword, this.asKeyword})
      : super("ImportPrefix", type);

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

class DirectParserASTContentImportEnd extends DirectParserASTContent {
  final Token importKeyword;
  final Token semicolon;

  DirectParserASTContentImportEnd(DirectParserASTType type,
      {this.importKeyword, this.semicolon})
      : super("Import", type);

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

class DirectParserASTContentRecoverImportHandle extends DirectParserASTContent {
  final Token semicolon;

  DirectParserASTContentRecoverImportHandle(DirectParserASTType type,
      {this.semicolon})
      : super("RecoverImport", type);

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

class DirectParserASTContentConditionalUrisBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentConditionalUrisBegin(DirectParserASTType type,
      {this.token})
      : super("ConditionalUris", type);

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

class DirectParserASTContentConditionalUrisEnd extends DirectParserASTContent {
  final int count;

  DirectParserASTContentConditionalUrisEnd(DirectParserASTType type,
      {this.count})
      : super("ConditionalUris", type);

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

class DirectParserASTContentConditionalUriBegin extends DirectParserASTContent {
  final Token ifKeyword;

  DirectParserASTContentConditionalUriBegin(DirectParserASTType type,
      {this.ifKeyword})
      : super("ConditionalUri", type);

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

class DirectParserASTContentConditionalUriEnd extends DirectParserASTContent {
  final Token ifKeyword;
  final Token leftParen;
  final Token equalSign;

  DirectParserASTContentConditionalUriEnd(DirectParserASTType type,
      {this.ifKeyword, this.leftParen, this.equalSign})
      : super("ConditionalUri", type);

  Map<String, Object> get deprecatedArguments => {
        "ifKeyword": ifKeyword,
        "leftParen": leftParen,
        "equalSign": equalSign,
      };
}

class DirectParserASTContentDottedNameHandle extends DirectParserASTContent {
  final int count;
  final Token firstIdentifier;

  DirectParserASTContentDottedNameHandle(DirectParserASTType type,
      {this.count, this.firstIdentifier})
      : super("DottedName", type);

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

class DirectParserASTContentImplicitCreationExpressionBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentImplicitCreationExpressionBegin(
      DirectParserASTType type,
      {this.token})
      : super("ImplicitCreationExpression", type);

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

class DirectParserASTContentImplicitCreationExpressionEnd
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentImplicitCreationExpressionEnd(DirectParserASTType type,
      {this.token})
      : super("ImplicitCreationExpression", type);

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

class DirectParserASTContentInitializedIdentifierBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInitializedIdentifierBegin(DirectParserASTType type,
      {this.token})
      : super("InitializedIdentifier", type);

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

class DirectParserASTContentInitializedIdentifierEnd
    extends DirectParserASTContent {
  final Token nameToken;

  DirectParserASTContentInitializedIdentifierEnd(DirectParserASTType type,
      {this.nameToken})
      : super("InitializedIdentifier", type);

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

class DirectParserASTContentFieldInitializerBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentFieldInitializerBegin(DirectParserASTType type,
      {this.token})
      : super("FieldInitializer", type);

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

class DirectParserASTContentFieldInitializerEnd extends DirectParserASTContent {
  final Token assignment;
  final Token token;

  DirectParserASTContentFieldInitializerEnd(DirectParserASTType type,
      {this.assignment, this.token})
      : super("FieldInitializer", type);

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

class DirectParserASTContentNoFieldInitializerHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoFieldInitializerHandle(DirectParserASTType type,
      {this.token})
      : super("NoFieldInitializer", type);

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

class DirectParserASTContentVariableInitializerBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentVariableInitializerBegin(DirectParserASTType type,
      {this.token})
      : super("VariableInitializer", type);

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

class DirectParserASTContentVariableInitializerEnd
    extends DirectParserASTContent {
  final Token assignmentOperator;

  DirectParserASTContentVariableInitializerEnd(DirectParserASTType type,
      {this.assignmentOperator})
      : super("VariableInitializer", type);

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

class DirectParserASTContentNoVariableInitializerHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoVariableInitializerHandle(DirectParserASTType type,
      {this.token})
      : super("NoVariableInitializer", type);

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

class DirectParserASTContentInitializerBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInitializerBegin(DirectParserASTType type, {this.token})
      : super("Initializer", type);

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

class DirectParserASTContentInitializerEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInitializerEnd(DirectParserASTType type, {this.token})
      : super("Initializer", type);

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

class DirectParserASTContentInitializersBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInitializersBegin(DirectParserASTType type,
      {this.token})
      : super("Initializers", type);

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

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

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

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

class DirectParserASTContentNoInitializersHandle
    extends DirectParserASTContent {
  DirectParserASTContentNoInitializersHandle(DirectParserASTType type)
      : super("NoInitializers", type);

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

class DirectParserASTContentInvalidExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInvalidExpressionHandle(DirectParserASTType type,
      {this.token})
      : super("InvalidExpression", type);

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

class DirectParserASTContentInvalidFunctionBodyHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInvalidFunctionBodyHandle(DirectParserASTType type,
      {this.token})
      : super("InvalidFunctionBody", type);

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

class DirectParserASTContentInvalidTypeReferenceHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInvalidTypeReferenceHandle(DirectParserASTType type,
      {this.token})
      : super("InvalidTypeReference", type);

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

class DirectParserASTContentLabelHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLabelHandle(DirectParserASTType type, {this.token})
      : super("Label", type);

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

class DirectParserASTContentLabeledStatementBegin
    extends DirectParserASTContent {
  final Token token;
  final int labelCount;

  DirectParserASTContentLabeledStatementBegin(DirectParserASTType type,
      {this.token, this.labelCount})
      : super("LabeledStatement", type);

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

class DirectParserASTContentLabeledStatementEnd extends DirectParserASTContent {
  final int labelCount;

  DirectParserASTContentLabeledStatementEnd(DirectParserASTType type,
      {this.labelCount})
      : super("LabeledStatement", type);

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

class DirectParserASTContentLibraryNameBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLibraryNameBegin(DirectParserASTType type, {this.token})
      : super("LibraryName", type);

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

class DirectParserASTContentLibraryNameEnd extends DirectParserASTContent {
  final Token libraryKeyword;
  final Token semicolon;

  DirectParserASTContentLibraryNameEnd(DirectParserASTType type,
      {this.libraryKeyword, this.semicolon})
      : super("LibraryName", type);

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

class DirectParserASTContentLiteralMapEntryHandle
    extends DirectParserASTContent {
  final Token colon;
  final Token endToken;

  DirectParserASTContentLiteralMapEntryHandle(DirectParserASTType type,
      {this.colon, this.endToken})
      : super("LiteralMapEntry", type);

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

class DirectParserASTContentLiteralStringBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLiteralStringBegin(DirectParserASTType type,
      {this.token})
      : super("LiteralString", type);

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

class DirectParserASTContentInterpolationExpressionHandle
    extends DirectParserASTContent {
  final Token leftBracket;
  final Token rightBracket;

  DirectParserASTContentInterpolationExpressionHandle(DirectParserASTType type,
      {this.leftBracket, this.rightBracket})
      : super("InterpolationExpression", type);

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

class DirectParserASTContentLiteralStringEnd extends DirectParserASTContent {
  final int interpolationCount;
  final Token endToken;

  DirectParserASTContentLiteralStringEnd(DirectParserASTType type,
      {this.interpolationCount, this.endToken})
      : super("LiteralString", type);

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

class DirectParserASTContentStringJuxtapositionHandle
    extends DirectParserASTContent {
  final Token startToken;
  final int literalCount;

  DirectParserASTContentStringJuxtapositionHandle(DirectParserASTType type,
      {this.startToken, this.literalCount})
      : super("StringJuxtaposition", type);

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

class DirectParserASTContentMemberBegin extends DirectParserASTContent {
  DirectParserASTContentMemberBegin(DirectParserASTType type)
      : super("Member", type);

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

class DirectParserASTContentInvalidMemberHandle extends DirectParserASTContent {
  final Token endToken;

  DirectParserASTContentInvalidMemberHandle(DirectParserASTType type,
      {this.endToken})
      : super("InvalidMember", type);

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

class DirectParserASTContentMemberEnd extends DirectParserASTContent {
  DirectParserASTContentMemberEnd(DirectParserASTType type)
      : super("Member", type);

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

class DirectParserASTContentMethodBegin extends DirectParserASTContent {
  final Token externalToken;
  final Token staticToken;
  final Token covariantToken;
  final Token varFinalOrConst;
  final Token getOrSet;
  final Token name;

  DirectParserASTContentMethodBegin(DirectParserASTType type,
      {this.externalToken,
      this.staticToken,
      this.covariantToken,
      this.varFinalOrConst,
      this.getOrSet,
      this.name})
      : super("Method", type);

  Map<String, Object> get deprecatedArguments => {
        "externalToken": externalToken,
        "staticToken": staticToken,
        "covariantToken": covariantToken,
        "varFinalOrConst": varFinalOrConst,
        "getOrSet": getOrSet,
        "name": name,
      };
}

class DirectParserASTContentClassMethodEnd extends DirectParserASTContent {
  final Token getOrSet;
  final Token beginToken;
  final Token beginParam;
  final Token beginInitializers;
  final Token endToken;

  DirectParserASTContentClassMethodEnd(DirectParserASTType type,
      {this.getOrSet,
      this.beginToken,
      this.beginParam,
      this.beginInitializers,
      this.endToken})
      : super("ClassMethod", type);

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

class DirectParserASTContentMixinMethodEnd extends DirectParserASTContent {
  final Token getOrSet;
  final Token beginToken;
  final Token beginParam;
  final Token beginInitializers;
  final Token endToken;

  DirectParserASTContentMixinMethodEnd(DirectParserASTType type,
      {this.getOrSet,
      this.beginToken,
      this.beginParam,
      this.beginInitializers,
      this.endToken})
      : super("MixinMethod", type);

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

class DirectParserASTContentExtensionMethodEnd extends DirectParserASTContent {
  final Token getOrSet;
  final Token beginToken;
  final Token beginParam;
  final Token beginInitializers;
  final Token endToken;

  DirectParserASTContentExtensionMethodEnd(DirectParserASTType type,
      {this.getOrSet,
      this.beginToken,
      this.beginParam,
      this.beginInitializers,
      this.endToken})
      : super("ExtensionMethod", type);

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

class DirectParserASTContentClassConstructorEnd extends DirectParserASTContent {
  final Token getOrSet;
  final Token beginToken;
  final Token beginParam;
  final Token beginInitializers;
  final Token endToken;

  DirectParserASTContentClassConstructorEnd(DirectParserASTType type,
      {this.getOrSet,
      this.beginToken,
      this.beginParam,
      this.beginInitializers,
      this.endToken})
      : super("ClassConstructor", type);

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

class DirectParserASTContentMixinConstructorEnd extends DirectParserASTContent {
  final Token getOrSet;
  final Token beginToken;
  final Token beginParam;
  final Token beginInitializers;
  final Token endToken;

  DirectParserASTContentMixinConstructorEnd(DirectParserASTType type,
      {this.getOrSet,
      this.beginToken,
      this.beginParam,
      this.beginInitializers,
      this.endToken})
      : super("MixinConstructor", type);

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

class DirectParserASTContentExtensionConstructorEnd
    extends DirectParserASTContent {
  final Token getOrSet;
  final Token beginToken;
  final Token beginParam;
  final Token beginInitializers;
  final Token endToken;

  DirectParserASTContentExtensionConstructorEnd(DirectParserASTType type,
      {this.getOrSet,
      this.beginToken,
      this.beginParam,
      this.beginInitializers,
      this.endToken})
      : super("ExtensionConstructor", type);

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

class DirectParserASTContentMetadataStarBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentMetadataStarBegin(DirectParserASTType type,
      {this.token})
      : super("MetadataStar", type);

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

class DirectParserASTContentMetadataStarEnd extends DirectParserASTContent {
  final int count;

  DirectParserASTContentMetadataStarEnd(DirectParserASTType type, {this.count})
      : super("MetadataStar", type);

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

class DirectParserASTContentMetadataBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentMetadataBegin(DirectParserASTType type, {this.token})
      : super("Metadata", type);

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

class DirectParserASTContentMetadataEnd extends DirectParserASTContent {
  final Token beginToken;
  final Token periodBeforeName;
  final Token endToken;

  DirectParserASTContentMetadataEnd(DirectParserASTType type,
      {this.beginToken, this.periodBeforeName, this.endToken})
      : super("Metadata", type);

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

class DirectParserASTContentOptionalFormalParametersBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentOptionalFormalParametersBegin(DirectParserASTType type,
      {this.token})
      : super("OptionalFormalParameters", type);

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

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

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

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

class DirectParserASTContentPartBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentPartBegin(DirectParserASTType type, {this.token})
      : super("Part", type);

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

class DirectParserASTContentPartEnd extends DirectParserASTContent {
  final Token partKeyword;
  final Token semicolon;

  DirectParserASTContentPartEnd(DirectParserASTType type,
      {this.partKeyword, this.semicolon})
      : super("Part", type);

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

class DirectParserASTContentPartOfBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentPartOfBegin(DirectParserASTType type, {this.token})
      : super("PartOf", type);

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

class DirectParserASTContentPartOfEnd extends DirectParserASTContent {
  final Token partKeyword;
  final Token ofKeyword;
  final Token semicolon;
  final bool hasName;

  DirectParserASTContentPartOfEnd(DirectParserASTType type,
      {this.partKeyword, this.ofKeyword, this.semicolon, this.hasName})
      : super("PartOf", type);

  Map<String, Object> get deprecatedArguments => {
        "partKeyword": partKeyword,
        "ofKeyword": ofKeyword,
        "semicolon": semicolon,
        "hasName": hasName,
      };
}

class DirectParserASTContentRedirectingFactoryBodyBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentRedirectingFactoryBodyBegin(DirectParserASTType type,
      {this.token})
      : super("RedirectingFactoryBody", type);

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

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

  DirectParserASTContentRedirectingFactoryBodyEnd(DirectParserASTType type,
      {this.beginToken, this.endToken})
      : super("RedirectingFactoryBody", type);

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

class DirectParserASTContentReturnStatementBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentReturnStatementBegin(DirectParserASTType type,
      {this.token})
      : super("ReturnStatement", type);

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

class DirectParserASTContentNativeFunctionBodyHandle
    extends DirectParserASTContent {
  final Token nativeToken;
  final Token semicolon;

  DirectParserASTContentNativeFunctionBodyHandle(DirectParserASTType type,
      {this.nativeToken, this.semicolon})
      : super("NativeFunctionBody", type);

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

class DirectParserASTContentNativeFunctionBodyIgnoredHandle
    extends DirectParserASTContent {
  final Token nativeToken;
  final Token semicolon;

  DirectParserASTContentNativeFunctionBodyIgnoredHandle(
      DirectParserASTType type,
      {this.nativeToken,
      this.semicolon})
      : super("NativeFunctionBodyIgnored", type);

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

class DirectParserASTContentNativeFunctionBodySkippedHandle
    extends DirectParserASTContent {
  final Token nativeToken;
  final Token semicolon;

  DirectParserASTContentNativeFunctionBodySkippedHandle(
      DirectParserASTType type,
      {this.nativeToken,
      this.semicolon})
      : super("NativeFunctionBodySkipped", type);

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

class DirectParserASTContentEmptyFunctionBodyHandle
    extends DirectParserASTContent {
  final Token semicolon;

  DirectParserASTContentEmptyFunctionBodyHandle(DirectParserASTType type,
      {this.semicolon})
      : super("EmptyFunctionBody", type);

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

class DirectParserASTContentExpressionFunctionBodyHandle
    extends DirectParserASTContent {
  final Token arrowToken;
  final Token endToken;

  DirectParserASTContentExpressionFunctionBodyHandle(DirectParserASTType type,
      {this.arrowToken, this.endToken})
      : super("ExpressionFunctionBody", type);

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

class DirectParserASTContentReturnStatementEnd extends DirectParserASTContent {
  final bool hasExpression;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentReturnStatementEnd(DirectParserASTType type,
      {this.hasExpression, this.beginToken, this.endToken})
      : super("ReturnStatement", type);

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

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

  DirectParserASTContentSendHandle(DirectParserASTType type,
      {this.beginToken, this.endToken})
      : super("Send", type);

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

class DirectParserASTContentShowBegin extends DirectParserASTContent {
  final Token showKeyword;

  DirectParserASTContentShowBegin(DirectParserASTType type, {this.showKeyword})
      : super("Show", type);

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

class DirectParserASTContentShowEnd extends DirectParserASTContent {
  final Token showKeyword;

  DirectParserASTContentShowEnd(DirectParserASTType type, {this.showKeyword})
      : super("Show", type);

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

class DirectParserASTContentSwitchStatementBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentSwitchStatementBegin(DirectParserASTType type,
      {this.token})
      : super("SwitchStatement", type);

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

class DirectParserASTContentSwitchStatementEnd extends DirectParserASTContent {
  final Token switchKeyword;
  final Token endToken;

  DirectParserASTContentSwitchStatementEnd(DirectParserASTType type,
      {this.switchKeyword, this.endToken})
      : super("SwitchStatement", type);

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

class DirectParserASTContentSwitchBlockBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentSwitchBlockBegin(DirectParserASTType type, {this.token})
      : super("SwitchBlock", type);

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

class DirectParserASTContentSwitchBlockEnd extends DirectParserASTContent {
  final int caseCount;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentSwitchBlockEnd(DirectParserASTType type,
      {this.caseCount, this.beginToken, this.endToken})
      : super("SwitchBlock", type);

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

class DirectParserASTContentLiteralSymbolBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLiteralSymbolBegin(DirectParserASTType type,
      {this.token})
      : super("LiteralSymbol", type);

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

class DirectParserASTContentLiteralSymbolEnd extends DirectParserASTContent {
  final Token hashToken;
  final int identifierCount;

  DirectParserASTContentLiteralSymbolEnd(DirectParserASTType type,
      {this.hashToken, this.identifierCount})
      : super("LiteralSymbol", type);

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

class DirectParserASTContentThrowExpressionHandle
    extends DirectParserASTContent {
  final Token throwToken;
  final Token endToken;

  DirectParserASTContentThrowExpressionHandle(DirectParserASTType type,
      {this.throwToken, this.endToken})
      : super("ThrowExpression", type);

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

class DirectParserASTContentRethrowStatementBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentRethrowStatementBegin(DirectParserASTType type,
      {this.token})
      : super("RethrowStatement", type);

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

class DirectParserASTContentRethrowStatementEnd extends DirectParserASTContent {
  final Token rethrowToken;
  final Token endToken;

  DirectParserASTContentRethrowStatementEnd(DirectParserASTType type,
      {this.rethrowToken, this.endToken})
      : super("RethrowStatement", type);

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

class DirectParserASTContentTopLevelDeclarationEnd
    extends DirectParserASTContent {
  final Token nextToken;

  DirectParserASTContentTopLevelDeclarationEnd(DirectParserASTType type,
      {this.nextToken})
      : super("TopLevelDeclaration", type);

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

class DirectParserASTContentInvalidTopLevelDeclarationHandle
    extends DirectParserASTContent {
  final Token endToken;

  DirectParserASTContentInvalidTopLevelDeclarationHandle(
      DirectParserASTType type,
      {this.endToken})
      : super("InvalidTopLevelDeclaration", type);

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

class DirectParserASTContentTopLevelMemberBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentTopLevelMemberBegin(DirectParserASTType type,
      {this.token})
      : super("TopLevelMember", type);

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

class DirectParserASTContentFieldsBegin extends DirectParserASTContent {
  final Token lastConsumed;

  DirectParserASTContentFieldsBegin(DirectParserASTType type,
      {this.lastConsumed})
      : super("Fields", type);

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

class DirectParserASTContentTopLevelFieldsEnd extends DirectParserASTContent {
  final Token externalToken;
  final Token staticToken;
  final Token covariantToken;
  final Token lateToken;
  final Token varFinalOrConst;
  final int count;
  final Token beginToken;
  final Token endToken;

  DirectParserASTContentTopLevelFieldsEnd(DirectParserASTType type,
      {this.externalToken,
      this.staticToken,
      this.covariantToken,
      this.lateToken,
      this.varFinalOrConst,
      this.count,
      this.beginToken,
      this.endToken})
      : super("TopLevelFields", type);

  Map<String, Object> get deprecatedArguments => {
        "externalToken": externalToken,
        "staticToken": staticToken,
        "covariantToken": covariantToken,
        "lateToken": lateToken,
        "varFinalOrConst": varFinalOrConst,
        "count": count,
        "beginToken": beginToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentTopLevelMethodBegin extends DirectParserASTContent {
  final Token lastConsumed;
  final Token externalToken;

  DirectParserASTContentTopLevelMethodBegin(DirectParserASTType type,
      {this.lastConsumed, this.externalToken})
      : super("TopLevelMethod", type);

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

class DirectParserASTContentTopLevelMethodEnd extends DirectParserASTContent {
  final Token beginToken;
  final Token getOrSet;
  final Token endToken;

  DirectParserASTContentTopLevelMethodEnd(DirectParserASTType type,
      {this.beginToken, this.getOrSet, this.endToken})
      : super("TopLevelMethod", type);

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

class DirectParserASTContentTryStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentTryStatementBegin(DirectParserASTType type,
      {this.token})
      : super("TryStatement", type);

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

class DirectParserASTContentCaseMatchHandle extends DirectParserASTContent {
  final Token caseKeyword;
  final Token colon;

  DirectParserASTContentCaseMatchHandle(DirectParserASTType type,
      {this.caseKeyword, this.colon})
      : super("CaseMatch", type);

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

class DirectParserASTContentCatchClauseBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentCatchClauseBegin(DirectParserASTType type, {this.token})
      : super("CatchClause", type);

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

class DirectParserASTContentCatchClauseEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentCatchClauseEnd(DirectParserASTType type, {this.token})
      : super("CatchClause", type);

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

class DirectParserASTContentCatchBlockHandle extends DirectParserASTContent {
  final Token onKeyword;
  final Token catchKeyword;
  final Token comma;

  DirectParserASTContentCatchBlockHandle(DirectParserASTType type,
      {this.onKeyword, this.catchKeyword, this.comma})
      : super("CatchBlock", type);

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

class DirectParserASTContentFinallyBlockHandle extends DirectParserASTContent {
  final Token finallyKeyword;

  DirectParserASTContentFinallyBlockHandle(DirectParserASTType type,
      {this.finallyKeyword})
      : super("FinallyBlock", type);

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

class DirectParserASTContentTryStatementEnd extends DirectParserASTContent {
  final int catchCount;
  final Token tryKeyword;
  final Token finallyKeyword;

  DirectParserASTContentTryStatementEnd(DirectParserASTType type,
      {this.catchCount, this.tryKeyword, this.finallyKeyword})
      : super("TryStatement", type);

  Map<String, Object> get deprecatedArguments => {
        "catchCount": catchCount,
        "tryKeyword": tryKeyword,
        "finallyKeyword": finallyKeyword,
      };
}

class DirectParserASTContentTypeHandle extends DirectParserASTContent {
  final Token beginToken;
  final Token questionMark;

  DirectParserASTContentTypeHandle(DirectParserASTType type,
      {this.beginToken, this.questionMark})
      : super("Type", type);

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

class DirectParserASTContentNonNullAssertExpressionHandle
    extends DirectParserASTContent {
  final Token bang;

  DirectParserASTContentNonNullAssertExpressionHandle(DirectParserASTType type,
      {this.bang})
      : super("NonNullAssertExpression", type);

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

class DirectParserASTContentNoNameHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoNameHandle(DirectParserASTType type, {this.token})
      : super("NoName", type);

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

class DirectParserASTContentFunctionTypeBegin extends DirectParserASTContent {
  final Token beginToken;

  DirectParserASTContentFunctionTypeBegin(DirectParserASTType type,
      {this.beginToken})
      : super("FunctionType", type);

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

class DirectParserASTContentFunctionTypeEnd extends DirectParserASTContent {
  final Token functionToken;
  final Token questionMark;

  DirectParserASTContentFunctionTypeEnd(DirectParserASTType type,
      {this.functionToken, this.questionMark})
      : super("FunctionType", type);

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

class DirectParserASTContentTypeArgumentsBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentTypeArgumentsBegin(DirectParserASTType type,
      {this.token})
      : super("TypeArguments", type);

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

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

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

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

class DirectParserASTContentInvalidTypeArgumentsHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentInvalidTypeArgumentsHandle(DirectParserASTType type,
      {this.token})
      : super("InvalidTypeArguments", type);

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

class DirectParserASTContentNoTypeArgumentsHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoTypeArgumentsHandle(DirectParserASTType type,
      {this.token})
      : super("NoTypeArguments", type);

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

class DirectParserASTContentTypeVariableBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentTypeVariableBegin(DirectParserASTType type,
      {this.token})
      : super("TypeVariable", type);

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

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

  DirectParserASTContentTypeVariablesDefinedHandle(DirectParserASTType type,
      {this.token, this.count})
      : super("TypeVariablesDefined", type);

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

class DirectParserASTContentTypeVariableEnd extends DirectParserASTContent {
  final Token token;
  final int index;
  final Token extendsOrSuper;
  final Token variance;

  DirectParserASTContentTypeVariableEnd(DirectParserASTType type,
      {this.token, this.index, this.extendsOrSuper, this.variance})
      : super("TypeVariable", type);

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

class DirectParserASTContentTypeVariablesBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentTypeVariablesBegin(DirectParserASTType type,
      {this.token})
      : super("TypeVariables", type);

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

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

  DirectParserASTContentTypeVariablesEnd(DirectParserASTType type,
      {this.beginToken, this.endToken})
      : super("TypeVariables", type);

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

class DirectParserASTContentFunctionExpressionBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentFunctionExpressionBegin(DirectParserASTType type,
      {this.token})
      : super("FunctionExpression", type);

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

class DirectParserASTContentFunctionExpressionEnd
    extends DirectParserASTContent {
  final Token beginToken;
  final Token token;

  DirectParserASTContentFunctionExpressionEnd(DirectParserASTType type,
      {this.beginToken, this.token})
      : super("FunctionExpression", type);

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

class DirectParserASTContentVariablesDeclarationBegin
    extends DirectParserASTContent {
  final Token token;
  final Token lateToken;
  final Token varFinalOrConst;

  DirectParserASTContentVariablesDeclarationBegin(DirectParserASTType type,
      {this.token, this.lateToken, this.varFinalOrConst})
      : super("VariablesDeclaration", type);

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

class DirectParserASTContentVariablesDeclarationEnd
    extends DirectParserASTContent {
  final int count;
  final Token endToken;

  DirectParserASTContentVariablesDeclarationEnd(DirectParserASTType type,
      {this.count, this.endToken})
      : super("VariablesDeclaration", type);

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

class DirectParserASTContentWhileStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentWhileStatementBegin(DirectParserASTType type,
      {this.token})
      : super("WhileStatement", type);

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

class DirectParserASTContentWhileStatementEnd extends DirectParserASTContent {
  final Token whileKeyword;
  final Token endToken;

  DirectParserASTContentWhileStatementEnd(DirectParserASTType type,
      {this.whileKeyword, this.endToken})
      : super("WhileStatement", type);

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

class DirectParserASTContentAsOperatorTypeBegin extends DirectParserASTContent {
  final Token operator;

  DirectParserASTContentAsOperatorTypeBegin(DirectParserASTType type,
      {this.operator})
      : super("AsOperatorType", type);

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

class DirectParserASTContentAsOperatorTypeEnd extends DirectParserASTContent {
  final Token operator;

  DirectParserASTContentAsOperatorTypeEnd(DirectParserASTType type,
      {this.operator})
      : super("AsOperatorType", type);

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

class DirectParserASTContentAsOperatorHandle extends DirectParserASTContent {
  final Token operator;

  DirectParserASTContentAsOperatorHandle(DirectParserASTType type,
      {this.operator})
      : super("AsOperator", type);

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

class DirectParserASTContentAssignmentExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentAssignmentExpressionHandle(DirectParserASTType type,
      {this.token})
      : super("AssignmentExpression", type);

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

class DirectParserASTContentBinaryExpressionBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentBinaryExpressionBegin(DirectParserASTType type,
      {this.token})
      : super("BinaryExpression", type);

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

class DirectParserASTContentBinaryExpressionEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentBinaryExpressionEnd(DirectParserASTType type,
      {this.token})
      : super("BinaryExpression", type);

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

class DirectParserASTContentEndingBinaryExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentEndingBinaryExpressionHandle(DirectParserASTType type,
      {this.token})
      : super("EndingBinaryExpression", type);

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

class DirectParserASTContentConditionalExpressionBegin
    extends DirectParserASTContent {
  final Token question;

  DirectParserASTContentConditionalExpressionBegin(DirectParserASTType type,
      {this.question})
      : super("ConditionalExpression", type);

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

class DirectParserASTContentConditionalExpressionColonHandle
    extends DirectParserASTContent {
  DirectParserASTContentConditionalExpressionColonHandle(
      DirectParserASTType type)
      : super("ConditionalExpressionColon", type);

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

class DirectParserASTContentConditionalExpressionEnd
    extends DirectParserASTContent {
  final Token question;
  final Token colon;

  DirectParserASTContentConditionalExpressionEnd(DirectParserASTType type,
      {this.question, this.colon})
      : super("ConditionalExpression", type);

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

class DirectParserASTContentConstExpressionBegin
    extends DirectParserASTContent {
  final Token constKeyword;

  DirectParserASTContentConstExpressionBegin(DirectParserASTType type,
      {this.constKeyword})
      : super("ConstExpression", type);

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

class DirectParserASTContentConstExpressionEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentConstExpressionEnd(DirectParserASTType type,
      {this.token})
      : super("ConstExpression", type);

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

class DirectParserASTContentForControlFlowBegin extends DirectParserASTContent {
  final Token awaitToken;
  final Token forToken;

  DirectParserASTContentForControlFlowBegin(DirectParserASTType type,
      {this.awaitToken, this.forToken})
      : super("ForControlFlow", type);

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

class DirectParserASTContentForControlFlowEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForControlFlowEnd(DirectParserASTType type,
      {this.token})
      : super("ForControlFlow", type);

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

class DirectParserASTContentForInControlFlowEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentForInControlFlowEnd(DirectParserASTType type,
      {this.token})
      : super("ForInControlFlow", type);

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

class DirectParserASTContentIfControlFlowBegin extends DirectParserASTContent {
  final Token ifToken;

  DirectParserASTContentIfControlFlowBegin(DirectParserASTType type,
      {this.ifToken})
      : super("IfControlFlow", type);

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

class DirectParserASTContentThenControlFlowHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentThenControlFlowHandle(DirectParserASTType type,
      {this.token})
      : super("ThenControlFlow", type);

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

class DirectParserASTContentElseControlFlowHandle
    extends DirectParserASTContent {
  final Token elseToken;

  DirectParserASTContentElseControlFlowHandle(DirectParserASTType type,
      {this.elseToken})
      : super("ElseControlFlow", type);

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

class DirectParserASTContentIfControlFlowEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentIfControlFlowEnd(DirectParserASTType type, {this.token})
      : super("IfControlFlow", type);

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

class DirectParserASTContentIfElseControlFlowEnd
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentIfElseControlFlowEnd(DirectParserASTType type,
      {this.token})
      : super("IfElseControlFlow", type);

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

class DirectParserASTContentSpreadExpressionHandle
    extends DirectParserASTContent {
  final Token spreadToken;

  DirectParserASTContentSpreadExpressionHandle(DirectParserASTType type,
      {this.spreadToken})
      : super("SpreadExpression", type);

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

class DirectParserASTContentFunctionTypedFormalParameterBegin
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentFunctionTypedFormalParameterBegin(
      DirectParserASTType type,
      {this.token})
      : super("FunctionTypedFormalParameter", type);

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

class DirectParserASTContentFunctionTypedFormalParameterEnd
    extends DirectParserASTContent {
  final Token nameToken;
  final Token question;

  DirectParserASTContentFunctionTypedFormalParameterEnd(
      DirectParserASTType type,
      {this.nameToken,
      this.question})
      : super("FunctionTypedFormalParameter", type);

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

class DirectParserASTContentIdentifierHandle extends DirectParserASTContent {
  final Token token;
  final IdentifierContext context;

  DirectParserASTContentIdentifierHandle(DirectParserASTType type,
      {this.token, this.context})
      : super("Identifier", type);

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

class DirectParserASTContentIndexedExpressionHandle
    extends DirectParserASTContent {
  final Token question;
  final Token openSquareBracket;
  final Token closeSquareBracket;

  DirectParserASTContentIndexedExpressionHandle(DirectParserASTType type,
      {this.question, this.openSquareBracket, this.closeSquareBracket})
      : super("IndexedExpression", type);

  Map<String, Object> get deprecatedArguments => {
        "question": question,
        "openSquareBracket": openSquareBracket,
        "closeSquareBracket": closeSquareBracket,
      };
}

class DirectParserASTContentIsOperatorTypeBegin extends DirectParserASTContent {
  final Token operator;

  DirectParserASTContentIsOperatorTypeBegin(DirectParserASTType type,
      {this.operator})
      : super("IsOperatorType", type);

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

class DirectParserASTContentIsOperatorTypeEnd extends DirectParserASTContent {
  final Token operator;

  DirectParserASTContentIsOperatorTypeEnd(DirectParserASTType type,
      {this.operator})
      : super("IsOperatorType", type);

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

class DirectParserASTContentIsOperatorHandle extends DirectParserASTContent {
  final Token isOperator;
  final Token not;

  DirectParserASTContentIsOperatorHandle(DirectParserASTType type,
      {this.isOperator, this.not})
      : super("IsOperator", type);

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

class DirectParserASTContentLiteralBoolHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLiteralBoolHandle(DirectParserASTType type,
      {this.token})
      : super("LiteralBool", type);

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

class DirectParserASTContentBreakStatementHandle
    extends DirectParserASTContent {
  final bool hasTarget;
  final Token breakKeyword;
  final Token endToken;

  DirectParserASTContentBreakStatementHandle(DirectParserASTType type,
      {this.hasTarget, this.breakKeyword, this.endToken})
      : super("BreakStatement", type);

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

class DirectParserASTContentContinueStatementHandle
    extends DirectParserASTContent {
  final bool hasTarget;
  final Token continueKeyword;
  final Token endToken;

  DirectParserASTContentContinueStatementHandle(DirectParserASTType type,
      {this.hasTarget, this.continueKeyword, this.endToken})
      : super("ContinueStatement", type);

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

class DirectParserASTContentEmptyStatementHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentEmptyStatementHandle(DirectParserASTType type,
      {this.token})
      : super("EmptyStatement", type);

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

class DirectParserASTContentAssertBegin extends DirectParserASTContent {
  final Token assertKeyword;
  final Assert kind;

  DirectParserASTContentAssertBegin(DirectParserASTType type,
      {this.assertKeyword, this.kind})
      : super("Assert", type);

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

class DirectParserASTContentAssertEnd extends DirectParserASTContent {
  final Token assertKeyword;
  final Assert kind;
  final Token leftParenthesis;
  final Token commaToken;
  final Token semicolonToken;

  DirectParserASTContentAssertEnd(DirectParserASTType type,
      {this.assertKeyword,
      this.kind,
      this.leftParenthesis,
      this.commaToken,
      this.semicolonToken})
      : super("Assert", type);

  Map<String, Object> get deprecatedArguments => {
        "assertKeyword": assertKeyword,
        "kind": kind,
        "leftParenthesis": leftParenthesis,
        "commaToken": commaToken,
        "semicolonToken": semicolonToken,
      };
}

class DirectParserASTContentLiteralDoubleHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLiteralDoubleHandle(DirectParserASTType type,
      {this.token})
      : super("LiteralDouble", type);

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

class DirectParserASTContentLiteralIntHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLiteralIntHandle(DirectParserASTType type, {this.token})
      : super("LiteralInt", type);

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

class DirectParserASTContentLiteralListHandle extends DirectParserASTContent {
  final int count;
  final Token leftBracket;
  final Token constKeyword;
  final Token rightBracket;

  DirectParserASTContentLiteralListHandle(DirectParserASTType type,
      {this.count, this.leftBracket, this.constKeyword, this.rightBracket})
      : super("LiteralList", type);

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

class DirectParserASTContentLiteralSetOrMapHandle
    extends DirectParserASTContent {
  final int count;
  final Token leftBrace;
  final Token constKeyword;
  final Token rightBrace;
  final bool hasSetEntry;

  DirectParserASTContentLiteralSetOrMapHandle(DirectParserASTType type,
      {this.count,
      this.leftBrace,
      this.constKeyword,
      this.rightBrace,
      this.hasSetEntry})
      : super("LiteralSetOrMap", type);

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

class DirectParserASTContentLiteralNullHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentLiteralNullHandle(DirectParserASTType type,
      {this.token})
      : super("LiteralNull", type);

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

class DirectParserASTContentNativeClauseHandle extends DirectParserASTContent {
  final Token nativeToken;
  final bool hasName;

  DirectParserASTContentNativeClauseHandle(DirectParserASTType type,
      {this.nativeToken, this.hasName})
      : super("NativeClause", type);

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

class DirectParserASTContentNamedArgumentHandle extends DirectParserASTContent {
  final Token colon;

  DirectParserASTContentNamedArgumentHandle(DirectParserASTType type,
      {this.colon})
      : super("NamedArgument", type);

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

class DirectParserASTContentNewExpressionBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNewExpressionBegin(DirectParserASTType type,
      {this.token})
      : super("NewExpression", type);

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

class DirectParserASTContentNewExpressionEnd extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNewExpressionEnd(DirectParserASTType type, {this.token})
      : super("NewExpression", type);

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

class DirectParserASTContentNoArgumentsHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoArgumentsHandle(DirectParserASTType type,
      {this.token})
      : super("NoArguments", type);

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

class DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoConstructorReferenceContinuationAfterTypeArgumentsHandle(
      DirectParserASTType type,
      {this.token})
      : super("NoConstructorReferenceContinuationAfterTypeArguments", type);

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

class DirectParserASTContentNoTypeHandle extends DirectParserASTContent {
  final Token lastConsumed;

  DirectParserASTContentNoTypeHandle(DirectParserASTType type,
      {this.lastConsumed})
      : super("NoType", type);

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

class DirectParserASTContentNoTypeVariablesHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentNoTypeVariablesHandle(DirectParserASTType type,
      {this.token})
      : super("NoTypeVariables", type);

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

class DirectParserASTContentOperatorHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentOperatorHandle(DirectParserASTType type, {this.token})
      : super("Operator", type);

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

class DirectParserASTContentSymbolVoidHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentSymbolVoidHandle(DirectParserASTType type, {this.token})
      : super("SymbolVoid", type);

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

class DirectParserASTContentOperatorNameHandle extends DirectParserASTContent {
  final Token operatorKeyword;
  final Token token;

  DirectParserASTContentOperatorNameHandle(DirectParserASTType type,
      {this.operatorKeyword, this.token})
      : super("OperatorName", type);

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

class DirectParserASTContentInvalidOperatorNameHandle
    extends DirectParserASTContent {
  final Token operatorKeyword;
  final Token token;

  DirectParserASTContentInvalidOperatorNameHandle(DirectParserASTType type,
      {this.operatorKeyword, this.token})
      : super("InvalidOperatorName", type);

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

class DirectParserASTContentParenthesizedConditionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentParenthesizedConditionHandle(DirectParserASTType type,
      {this.token})
      : super("ParenthesizedCondition", type);

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

class DirectParserASTContentParenthesizedExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentParenthesizedExpressionHandle(DirectParserASTType type,
      {this.token})
      : super("ParenthesizedExpression", type);

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

class DirectParserASTContentQualifiedHandle extends DirectParserASTContent {
  final Token period;

  DirectParserASTContentQualifiedHandle(DirectParserASTType type, {this.period})
      : super("Qualified", type);

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

class DirectParserASTContentStringPartHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentStringPartHandle(DirectParserASTType type, {this.token})
      : super("StringPart", type);

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

class DirectParserASTContentSuperExpressionHandle
    extends DirectParserASTContent {
  final Token token;
  final IdentifierContext context;

  DirectParserASTContentSuperExpressionHandle(DirectParserASTType type,
      {this.token, this.context})
      : super("SuperExpression", type);

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

class DirectParserASTContentSwitchCaseBegin extends DirectParserASTContent {
  final int labelCount;
  final int expressionCount;
  final Token firstToken;

  DirectParserASTContentSwitchCaseBegin(DirectParserASTType type,
      {this.labelCount, this.expressionCount, this.firstToken})
      : super("SwitchCase", type);

  Map<String, Object> get deprecatedArguments => {
        "labelCount": labelCount,
        "expressionCount": expressionCount,
        "firstToken": firstToken,
      };
}

class DirectParserASTContentSwitchCaseEnd extends DirectParserASTContent {
  final int labelCount;
  final int expressionCount;
  final Token defaultKeyword;
  final Token colonAfterDefault;
  final int statementCount;
  final Token firstToken;
  final Token endToken;

  DirectParserASTContentSwitchCaseEnd(DirectParserASTType type,
      {this.labelCount,
      this.expressionCount,
      this.defaultKeyword,
      this.colonAfterDefault,
      this.statementCount,
      this.firstToken,
      this.endToken})
      : super("SwitchCase", type);

  Map<String, Object> get deprecatedArguments => {
        "labelCount": labelCount,
        "expressionCount": expressionCount,
        "defaultKeyword": defaultKeyword,
        "colonAfterDefault": colonAfterDefault,
        "statementCount": statementCount,
        "firstToken": firstToken,
        "endToken": endToken,
      };
}

class DirectParserASTContentThisExpressionHandle
    extends DirectParserASTContent {
  final Token token;
  final IdentifierContext context;

  DirectParserASTContentThisExpressionHandle(DirectParserASTType type,
      {this.token, this.context})
      : super("ThisExpression", type);

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

class DirectParserASTContentUnaryPostfixAssignmentExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentUnaryPostfixAssignmentExpressionHandle(
      DirectParserASTType type,
      {this.token})
      : super("UnaryPostfixAssignmentExpression", type);

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

class DirectParserASTContentUnaryPrefixExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentUnaryPrefixExpressionHandle(DirectParserASTType type,
      {this.token})
      : super("UnaryPrefixExpression", type);

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

class DirectParserASTContentUnaryPrefixAssignmentExpressionHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentUnaryPrefixAssignmentExpressionHandle(
      DirectParserASTType type,
      {this.token})
      : super("UnaryPrefixAssignmentExpression", type);

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

class DirectParserASTContentFormalParameterDefaultValueExpressionBegin
    extends DirectParserASTContent {
  DirectParserASTContentFormalParameterDefaultValueExpressionBegin(
      DirectParserASTType type)
      : super("FormalParameterDefaultValueExpression", type);

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

class DirectParserASTContentFormalParameterDefaultValueExpressionEnd
    extends DirectParserASTContent {
  DirectParserASTContentFormalParameterDefaultValueExpressionEnd(
      DirectParserASTType type)
      : super("FormalParameterDefaultValueExpression", type);

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

class DirectParserASTContentValuedFormalParameterHandle
    extends DirectParserASTContent {
  final Token equals;
  final Token token;

  DirectParserASTContentValuedFormalParameterHandle(DirectParserASTType type,
      {this.equals, this.token})
      : super("ValuedFormalParameter", type);

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

class DirectParserASTContentFormalParameterWithoutValueHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentFormalParameterWithoutValueHandle(
      DirectParserASTType type,
      {this.token})
      : super("FormalParameterWithoutValue", type);

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

class DirectParserASTContentVoidKeywordHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentVoidKeywordHandle(DirectParserASTType type,
      {this.token})
      : super("VoidKeyword", type);

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

class DirectParserASTContentVoidKeywordWithTypeArgumentsHandle
    extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentVoidKeywordWithTypeArgumentsHandle(
      DirectParserASTType type,
      {this.token})
      : super("VoidKeywordWithTypeArguments", type);

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

class DirectParserASTContentYieldStatementBegin extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentYieldStatementBegin(DirectParserASTType type,
      {this.token})
      : super("YieldStatement", type);

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

class DirectParserASTContentYieldStatementEnd extends DirectParserASTContent {
  final Token yieldToken;
  final Token starToken;
  final Token endToken;

  DirectParserASTContentYieldStatementEnd(DirectParserASTType type,
      {this.yieldToken, this.starToken, this.endToken})
      : super("YieldStatement", type);

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

class DirectParserASTContentInvalidYieldStatementEnd
    extends DirectParserASTContent {
  final Token beginToken;
  final Token starToken;
  final Token endToken;
  final MessageCode errorCode;

  DirectParserASTContentInvalidYieldStatementEnd(DirectParserASTType type,
      {this.beginToken, this.starToken, this.endToken, this.errorCode})
      : super("InvalidYieldStatement", type);

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

class DirectParserASTContentRecoverableErrorHandle
    extends DirectParserASTContent {
  final Message message;
  final Token startToken;
  final Token endToken;

  DirectParserASTContentRecoverableErrorHandle(DirectParserASTType type,
      {this.message, this.startToken, this.endToken})
      : super("RecoverableError", type);

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

class DirectParserASTContentErrorTokenHandle extends DirectParserASTContent {
  final ErrorToken token;

  DirectParserASTContentErrorTokenHandle(DirectParserASTType type, {this.token})
      : super("ErrorToken", type);

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

class DirectParserASTContentUnescapeErrorHandle extends DirectParserASTContent {
  final Message message;
  final Token location;
  final int stringOffset;
  final int length;

  DirectParserASTContentUnescapeErrorHandle(DirectParserASTType type,
      {this.message, this.location, this.stringOffset, this.length})
      : super("UnescapeError", type);

  Map<String, Object> get deprecatedArguments => {
        "message": message,
        "location": location,
        "stringOffset": stringOffset,
        "length": length,
      };
}

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

  DirectParserASTContentInvalidStatementHandle(DirectParserASTType type,
      {this.token, this.message})
      : super("InvalidStatement", type);

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

class DirectParserASTContentScriptHandle extends DirectParserASTContent {
  final Token token;

  DirectParserASTContentScriptHandle(DirectParserASTType type, {this.token})
      : super("Script", type);

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

class DirectParserASTContentCommentReferenceTextHandle
    extends DirectParserASTContent {
  final String referenceSource;
  final int referenceOffset;

  DirectParserASTContentCommentReferenceTextHandle(DirectParserASTType type,
      {this.referenceSource, this.referenceOffset})
      : super("CommentReferenceText", type);

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

class DirectParserASTContentCommentReferenceHandle
    extends DirectParserASTContent {
  final Token newKeyword;
  final Token prefix;
  final Token period;
  final Token token;

  DirectParserASTContentCommentReferenceHandle(DirectParserASTType type,
      {this.newKeyword, this.prefix, this.period, this.token})
      : super("CommentReference", type);

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

class DirectParserASTContentNoCommentReferenceHandle
    extends DirectParserASTContent {
  DirectParserASTContentNoCommentReferenceHandle(DirectParserASTType type)
      : super("NoCommentReference", type);

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