| // Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| // @dart = 2.9 |
| |
| import 'package:_fe_analyzer_shared/src/parser/assert.dart'; |
| import 'package:_fe_analyzer_shared/src/parser/block_kind.dart'; |
| import 'package:_fe_analyzer_shared/src/parser/declaration_kind.dart'; |
| import 'package:_fe_analyzer_shared/src/parser/formal_parameter_kind.dart'; |
| import 'package:_fe_analyzer_shared/src/parser/identifier_context.dart'; |
| import 'package:_fe_analyzer_shared/src/parser/listener.dart'; |
| import 'package:_fe_analyzer_shared/src/parser/member_kind.dart'; |
| import 'package:_fe_analyzer_shared/src/scanner/error_token.dart'; |
| import 'package:_fe_analyzer_shared/src/scanner/token.dart'; |
| import 'package:front_end/src/fasta/messages.dart'; |
| |
| // ignore_for_file: lines_longer_than_80_chars |
| |
| // THIS FILE IS AUTO GENERATED BY |
| // 'tool/_fasta/direct_parser_ast_helper_creator.dart' |
| // Run e.g. |
| /* |
| out/ReleaseX64/dart \ |
| pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart \ |
| > pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart |
| */ |
| |
| abstract class DirectParserASTContent { |
| final String what; |
| final DirectParserASTType type; |
| Map<String, Object> get deprecatedArguments; |
| List<DirectParserASTContent> children; |
| |
| DirectParserASTContent(this.what, this.type); |
| |
| // TODO(jensj): Compare two ASTs. |
| } |
| |
| enum DirectParserASTType { BEGIN, END, HANDLE } |
| |
| abstract class AbstractDirectParserASTListener implements Listener { |
| List<DirectParserASTContent> data = []; |
| |
| void seen(DirectParserASTContent entry); |
| |
| void beginArguments(Token token) { |
| DirectParserASTContentArgumentsBegin data = |
| new DirectParserASTContentArgumentsBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endArguments(int count, Token beginToken, Token endToken) { |
| DirectParserASTContentArgumentsEnd data = |
| new DirectParserASTContentArgumentsEnd(DirectParserASTType.END, |
| count: count, beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void handleAsyncModifier(Token asyncToken, Token starToken) { |
| DirectParserASTContentAsyncModifierHandle data = |
| new DirectParserASTContentAsyncModifierHandle( |
| DirectParserASTType.HANDLE, |
| asyncToken: asyncToken, |
| starToken: starToken); |
| seen(data); |
| } |
| |
| void beginAwaitExpression(Token token) { |
| DirectParserASTContentAwaitExpressionBegin data = |
| new DirectParserASTContentAwaitExpressionBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endAwaitExpression(Token beginToken, Token endToken) { |
| DirectParserASTContentAwaitExpressionEnd data = |
| new DirectParserASTContentAwaitExpressionEnd(DirectParserASTType.END, |
| beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void endInvalidAwaitExpression( |
| Token beginToken, Token endToken, MessageCode errorCode) { |
| DirectParserASTContentInvalidAwaitExpressionEnd data = |
| new DirectParserASTContentInvalidAwaitExpressionEnd( |
| DirectParserASTType.END, |
| beginToken: beginToken, |
| endToken: endToken, |
| errorCode: errorCode); |
| seen(data); |
| } |
| |
| void beginBlock(Token token, BlockKind blockKind) { |
| DirectParserASTContentBlockBegin data = |
| new DirectParserASTContentBlockBegin(DirectParserASTType.BEGIN, |
| token: token, blockKind: blockKind); |
| seen(data); |
| } |
| |
| void endBlock( |
| int count, Token beginToken, Token endToken, BlockKind blockKind) { |
| DirectParserASTContentBlockEnd data = new DirectParserASTContentBlockEnd( |
| DirectParserASTType.END, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken, |
| blockKind: blockKind); |
| seen(data); |
| } |
| |
| void handleInvalidTopLevelBlock(Token token) { |
| DirectParserASTContentInvalidTopLevelBlockHandle data = |
| new DirectParserASTContentInvalidTopLevelBlockHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginCascade(Token token) { |
| DirectParserASTContentCascadeBegin data = |
| new DirectParserASTContentCascadeBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endCascade() { |
| DirectParserASTContentCascadeEnd data = |
| new DirectParserASTContentCascadeEnd(DirectParserASTType.END); |
| seen(data); |
| } |
| |
| void beginCaseExpression(Token caseKeyword) { |
| DirectParserASTContentCaseExpressionBegin data = |
| new DirectParserASTContentCaseExpressionBegin(DirectParserASTType.BEGIN, |
| caseKeyword: caseKeyword); |
| seen(data); |
| } |
| |
| void endCaseExpression(Token colon) { |
| DirectParserASTContentCaseExpressionEnd data = |
| new DirectParserASTContentCaseExpressionEnd(DirectParserASTType.END, |
| colon: colon); |
| seen(data); |
| } |
| |
| void beginClassOrMixinBody(DeclarationKind kind, Token token) { |
| DirectParserASTContentClassOrMixinBodyBegin data = |
| new DirectParserASTContentClassOrMixinBodyBegin( |
| DirectParserASTType.BEGIN, |
| kind: kind, |
| token: token); |
| seen(data); |
| } |
| |
| void endClassOrMixinBody( |
| DeclarationKind kind, int memberCount, Token beginToken, Token endToken) { |
| DirectParserASTContentClassOrMixinBodyEnd data = |
| new DirectParserASTContentClassOrMixinBodyEnd(DirectParserASTType.END, |
| kind: kind, |
| memberCount: memberCount, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginClassOrNamedMixinApplicationPrelude(Token token) { |
| DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin data = |
| new DirectParserASTContentClassOrNamedMixinApplicationPreludeBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void beginClassDeclaration(Token begin, Token abstractToken, Token name) { |
| DirectParserASTContentClassDeclarationBegin data = |
| new DirectParserASTContentClassDeclarationBegin( |
| DirectParserASTType.BEGIN, |
| begin: begin, |
| abstractToken: abstractToken, |
| name: name); |
| seen(data); |
| } |
| |
| void handleClassExtends(Token extendsKeyword, int typeCount) { |
| DirectParserASTContentClassExtendsHandle data = |
| new DirectParserASTContentClassExtendsHandle(DirectParserASTType.HANDLE, |
| extendsKeyword: extendsKeyword, typeCount: typeCount); |
| seen(data); |
| } |
| |
| void handleClassOrMixinImplements( |
| Token implementsKeyword, int interfacesCount) { |
| DirectParserASTContentClassOrMixinImplementsHandle data = |
| new DirectParserASTContentClassOrMixinImplementsHandle( |
| DirectParserASTType.HANDLE, |
| implementsKeyword: implementsKeyword, |
| interfacesCount: interfacesCount); |
| seen(data); |
| } |
| |
| void handleClassHeader(Token begin, Token classKeyword, Token nativeToken) { |
| DirectParserASTContentClassHeaderHandle data = |
| new DirectParserASTContentClassHeaderHandle(DirectParserASTType.HANDLE, |
| begin: begin, classKeyword: classKeyword, nativeToken: nativeToken); |
| seen(data); |
| } |
| |
| void handleRecoverClassHeader() { |
| DirectParserASTContentRecoverClassHeaderHandle data = |
| new DirectParserASTContentRecoverClassHeaderHandle( |
| DirectParserASTType.HANDLE); |
| seen(data); |
| } |
| |
| void endClassDeclaration(Token beginToken, Token endToken) { |
| DirectParserASTContentClassDeclarationEnd data = |
| new DirectParserASTContentClassDeclarationEnd(DirectParserASTType.END, |
| beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginMixinDeclaration(Token mixinKeyword, Token name) { |
| DirectParserASTContentMixinDeclarationBegin data = |
| new DirectParserASTContentMixinDeclarationBegin( |
| DirectParserASTType.BEGIN, |
| mixinKeyword: mixinKeyword, |
| name: name); |
| seen(data); |
| } |
| |
| void handleMixinOn(Token onKeyword, int typeCount) { |
| DirectParserASTContentMixinOnHandle data = |
| new DirectParserASTContentMixinOnHandle(DirectParserASTType.HANDLE, |
| onKeyword: onKeyword, typeCount: typeCount); |
| seen(data); |
| } |
| |
| void handleMixinHeader(Token mixinKeyword) { |
| DirectParserASTContentMixinHeaderHandle data = |
| new DirectParserASTContentMixinHeaderHandle(DirectParserASTType.HANDLE, |
| mixinKeyword: mixinKeyword); |
| seen(data); |
| } |
| |
| void handleRecoverMixinHeader() { |
| DirectParserASTContentRecoverMixinHeaderHandle data = |
| new DirectParserASTContentRecoverMixinHeaderHandle( |
| DirectParserASTType.HANDLE); |
| seen(data); |
| } |
| |
| void endMixinDeclaration(Token mixinKeyword, Token endToken) { |
| DirectParserASTContentMixinDeclarationEnd data = |
| new DirectParserASTContentMixinDeclarationEnd(DirectParserASTType.END, |
| mixinKeyword: mixinKeyword, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginUncategorizedTopLevelDeclaration(Token token) { |
| DirectParserASTContentUncategorizedTopLevelDeclarationBegin data = |
| new DirectParserASTContentUncategorizedTopLevelDeclarationBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void beginExtensionDeclarationPrelude(Token extensionKeyword) { |
| DirectParserASTContentExtensionDeclarationPreludeBegin data = |
| new DirectParserASTContentExtensionDeclarationPreludeBegin( |
| DirectParserASTType.BEGIN, |
| extensionKeyword: extensionKeyword); |
| seen(data); |
| } |
| |
| void beginExtensionDeclaration(Token extensionKeyword, Token name) { |
| DirectParserASTContentExtensionDeclarationBegin data = |
| new DirectParserASTContentExtensionDeclarationBegin( |
| DirectParserASTType.BEGIN, |
| extensionKeyword: extensionKeyword, |
| name: name); |
| seen(data); |
| } |
| |
| void endExtensionDeclaration( |
| Token extensionKeyword, Token onKeyword, Token endToken) { |
| DirectParserASTContentExtensionDeclarationEnd data = |
| new DirectParserASTContentExtensionDeclarationEnd( |
| DirectParserASTType.END, |
| extensionKeyword: extensionKeyword, |
| onKeyword: onKeyword, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginCombinators(Token token) { |
| DirectParserASTContentCombinatorsBegin data = |
| new DirectParserASTContentCombinatorsBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endCombinators(int count) { |
| DirectParserASTContentCombinatorsEnd data = |
| new DirectParserASTContentCombinatorsEnd(DirectParserASTType.END, |
| count: count); |
| seen(data); |
| } |
| |
| void beginCompilationUnit(Token token) { |
| DirectParserASTContentCompilationUnitBegin data = |
| new DirectParserASTContentCompilationUnitBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void handleDirectivesOnly() { |
| DirectParserASTContentDirectivesOnlyHandle data = |
| new DirectParserASTContentDirectivesOnlyHandle( |
| DirectParserASTType.HANDLE); |
| seen(data); |
| } |
| |
| void endCompilationUnit(int count, Token token) { |
| DirectParserASTContentCompilationUnitEnd data = |
| new DirectParserASTContentCompilationUnitEnd(DirectParserASTType.END, |
| count: count, token: token); |
| seen(data); |
| } |
| |
| void beginConstLiteral(Token token) { |
| DirectParserASTContentConstLiteralBegin data = |
| new DirectParserASTContentConstLiteralBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endConstLiteral(Token token) { |
| DirectParserASTContentConstLiteralEnd data = |
| new DirectParserASTContentConstLiteralEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginConstructorReference(Token start) { |
| DirectParserASTContentConstructorReferenceBegin data = |
| new DirectParserASTContentConstructorReferenceBegin( |
| DirectParserASTType.BEGIN, |
| start: start); |
| seen(data); |
| } |
| |
| void endConstructorReference( |
| Token start, Token periodBeforeName, Token endToken) { |
| DirectParserASTContentConstructorReferenceEnd data = |
| new DirectParserASTContentConstructorReferenceEnd( |
| DirectParserASTType.END, |
| start: start, |
| periodBeforeName: periodBeforeName, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginDoWhileStatement(Token token) { |
| DirectParserASTContentDoWhileStatementBegin data = |
| new DirectParserASTContentDoWhileStatementBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endDoWhileStatement( |
| Token doKeyword, Token whileKeyword, Token endToken) { |
| DirectParserASTContentDoWhileStatementEnd data = |
| new DirectParserASTContentDoWhileStatementEnd(DirectParserASTType.END, |
| doKeyword: doKeyword, |
| whileKeyword: whileKeyword, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginDoWhileStatementBody(Token token) { |
| DirectParserASTContentDoWhileStatementBodyBegin data = |
| new DirectParserASTContentDoWhileStatementBodyBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endDoWhileStatementBody(Token token) { |
| DirectParserASTContentDoWhileStatementBodyEnd data = |
| new DirectParserASTContentDoWhileStatementBodyEnd( |
| DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginWhileStatementBody(Token token) { |
| DirectParserASTContentWhileStatementBodyBegin data = |
| new DirectParserASTContentWhileStatementBodyBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endWhileStatementBody(Token token) { |
| DirectParserASTContentWhileStatementBodyEnd data = |
| new DirectParserASTContentWhileStatementBodyEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginEnum(Token enumKeyword) { |
| DirectParserASTContentEnumBegin data = new DirectParserASTContentEnumBegin( |
| DirectParserASTType.BEGIN, |
| enumKeyword: enumKeyword); |
| seen(data); |
| } |
| |
| void endEnum(Token enumKeyword, Token leftBrace, int count) { |
| DirectParserASTContentEnumEnd data = new DirectParserASTContentEnumEnd( |
| DirectParserASTType.END, |
| enumKeyword: enumKeyword, |
| leftBrace: leftBrace, |
| count: count); |
| seen(data); |
| } |
| |
| void beginExport(Token token) { |
| DirectParserASTContentExportBegin data = |
| new DirectParserASTContentExportBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endExport(Token exportKeyword, Token semicolon) { |
| DirectParserASTContentExportEnd data = new DirectParserASTContentExportEnd( |
| DirectParserASTType.END, |
| exportKeyword: exportKeyword, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleExtraneousExpression(Token token, Message message) { |
| DirectParserASTContentExtraneousExpressionHandle data = |
| new DirectParserASTContentExtraneousExpressionHandle( |
| DirectParserASTType.HANDLE, |
| token: token, |
| message: message); |
| seen(data); |
| } |
| |
| void handleExpressionStatement(Token token) { |
| DirectParserASTContentExpressionStatementHandle data = |
| new DirectParserASTContentExpressionStatementHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginFactoryMethod( |
| Token lastConsumed, Token externalToken, Token constToken) { |
| DirectParserASTContentFactoryMethodBegin data = |
| new DirectParserASTContentFactoryMethodBegin(DirectParserASTType.BEGIN, |
| lastConsumed: lastConsumed, |
| externalToken: externalToken, |
| constToken: constToken); |
| seen(data); |
| } |
| |
| void endClassFactoryMethod( |
| Token beginToken, Token factoryKeyword, Token endToken) { |
| DirectParserASTContentClassFactoryMethodEnd data = |
| new DirectParserASTContentClassFactoryMethodEnd(DirectParserASTType.END, |
| beginToken: beginToken, |
| factoryKeyword: factoryKeyword, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endMixinFactoryMethod( |
| Token beginToken, Token factoryKeyword, Token endToken) { |
| DirectParserASTContentMixinFactoryMethodEnd data = |
| new DirectParserASTContentMixinFactoryMethodEnd(DirectParserASTType.END, |
| beginToken: beginToken, |
| factoryKeyword: factoryKeyword, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endExtensionFactoryMethod( |
| Token beginToken, Token factoryKeyword, Token endToken) { |
| DirectParserASTContentExtensionFactoryMethodEnd data = |
| new DirectParserASTContentExtensionFactoryMethodEnd( |
| DirectParserASTType.END, |
| beginToken: beginToken, |
| factoryKeyword: factoryKeyword, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginFormalParameter(Token token, MemberKind kind, Token requiredToken, |
| Token covariantToken, Token varFinalOrConst) { |
| DirectParserASTContentFormalParameterBegin data = |
| new DirectParserASTContentFormalParameterBegin( |
| DirectParserASTType.BEGIN, |
| token: token, |
| kind: kind, |
| requiredToken: requiredToken, |
| covariantToken: covariantToken, |
| varFinalOrConst: varFinalOrConst); |
| seen(data); |
| } |
| |
| void endFormalParameter( |
| Token thisKeyword, |
| Token periodAfterThis, |
| Token nameToken, |
| Token initializerStart, |
| Token initializerEnd, |
| FormalParameterKind kind, |
| MemberKind memberKind) { |
| DirectParserASTContentFormalParameterEnd data = |
| new DirectParserASTContentFormalParameterEnd(DirectParserASTType.END, |
| thisKeyword: thisKeyword, |
| periodAfterThis: periodAfterThis, |
| nameToken: nameToken, |
| initializerStart: initializerStart, |
| initializerEnd: initializerEnd, |
| kind: kind, |
| memberKind: memberKind); |
| seen(data); |
| } |
| |
| void handleNoFormalParameters(Token token, MemberKind kind) { |
| DirectParserASTContentNoFormalParametersHandle data = |
| new DirectParserASTContentNoFormalParametersHandle( |
| DirectParserASTType.HANDLE, |
| token: token, |
| kind: kind); |
| seen(data); |
| } |
| |
| void beginFormalParameters(Token token, MemberKind kind) { |
| DirectParserASTContentFormalParametersBegin data = |
| new DirectParserASTContentFormalParametersBegin( |
| DirectParserASTType.BEGIN, |
| token: token, |
| kind: kind); |
| seen(data); |
| } |
| |
| void endFormalParameters( |
| int count, Token beginToken, Token endToken, MemberKind kind) { |
| DirectParserASTContentFormalParametersEnd data = |
| new DirectParserASTContentFormalParametersEnd(DirectParserASTType.END, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken, |
| kind: kind); |
| seen(data); |
| } |
| |
| void endClassFields( |
| Token abstractToken, |
| Token externalToken, |
| Token staticToken, |
| Token covariantToken, |
| Token lateToken, |
| Token varFinalOrConst, |
| int count, |
| Token beginToken, |
| Token endToken) { |
| DirectParserASTContentClassFieldsEnd data = |
| new DirectParserASTContentClassFieldsEnd(DirectParserASTType.END, |
| abstractToken: abstractToken, |
| externalToken: externalToken, |
| staticToken: staticToken, |
| covariantToken: covariantToken, |
| lateToken: lateToken, |
| varFinalOrConst: varFinalOrConst, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endMixinFields( |
| Token abstractToken, |
| Token externalToken, |
| Token staticToken, |
| Token covariantToken, |
| Token lateToken, |
| Token varFinalOrConst, |
| int count, |
| Token beginToken, |
| Token endToken) { |
| DirectParserASTContentMixinFieldsEnd data = |
| new DirectParserASTContentMixinFieldsEnd(DirectParserASTType.END, |
| abstractToken: abstractToken, |
| externalToken: externalToken, |
| staticToken: staticToken, |
| covariantToken: covariantToken, |
| lateToken: lateToken, |
| varFinalOrConst: varFinalOrConst, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endExtensionFields( |
| Token abstractToken, |
| Token externalToken, |
| Token staticToken, |
| Token covariantToken, |
| Token lateToken, |
| Token varFinalOrConst, |
| int count, |
| Token beginToken, |
| Token endToken) { |
| DirectParserASTContentExtensionFieldsEnd data = |
| new DirectParserASTContentExtensionFieldsEnd(DirectParserASTType.END, |
| abstractToken: abstractToken, |
| externalToken: externalToken, |
| staticToken: staticToken, |
| covariantToken: covariantToken, |
| lateToken: lateToken, |
| varFinalOrConst: varFinalOrConst, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void handleForInitializerEmptyStatement(Token token) { |
| DirectParserASTContentForInitializerEmptyStatementHandle data = |
| new DirectParserASTContentForInitializerEmptyStatementHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void handleForInitializerExpressionStatement(Token token, bool forIn) { |
| DirectParserASTContentForInitializerExpressionStatementHandle data = |
| new DirectParserASTContentForInitializerExpressionStatementHandle( |
| DirectParserASTType.HANDLE, |
| token: token, |
| forIn: forIn); |
| seen(data); |
| } |
| |
| void handleForInitializerLocalVariableDeclaration(Token token, bool forIn) { |
| DirectParserASTContentForInitializerLocalVariableDeclarationHandle data = |
| new DirectParserASTContentForInitializerLocalVariableDeclarationHandle( |
| DirectParserASTType.HANDLE, |
| token: token, |
| forIn: forIn); |
| seen(data); |
| } |
| |
| void beginForStatement(Token token) { |
| DirectParserASTContentForStatementBegin data = |
| new DirectParserASTContentForStatementBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void handleForLoopParts(Token forKeyword, Token leftParen, |
| Token leftSeparator, int updateExpressionCount) { |
| DirectParserASTContentForLoopPartsHandle data = |
| new DirectParserASTContentForLoopPartsHandle(DirectParserASTType.HANDLE, |
| forKeyword: forKeyword, |
| leftParen: leftParen, |
| leftSeparator: leftSeparator, |
| updateExpressionCount: updateExpressionCount); |
| seen(data); |
| } |
| |
| void endForStatement(Token endToken) { |
| DirectParserASTContentForStatementEnd data = |
| new DirectParserASTContentForStatementEnd(DirectParserASTType.END, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginForStatementBody(Token token) { |
| DirectParserASTContentForStatementBodyBegin data = |
| new DirectParserASTContentForStatementBodyBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endForStatementBody(Token token) { |
| DirectParserASTContentForStatementBodyEnd data = |
| new DirectParserASTContentForStatementBodyEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void handleForInLoopParts(Token awaitToken, Token forToken, |
| Token leftParenthesis, Token inKeyword) { |
| DirectParserASTContentForInLoopPartsHandle data = |
| new DirectParserASTContentForInLoopPartsHandle( |
| DirectParserASTType.HANDLE, |
| awaitToken: awaitToken, |
| forToken: forToken, |
| leftParenthesis: leftParenthesis, |
| inKeyword: inKeyword); |
| seen(data); |
| } |
| |
| void endForIn(Token endToken) { |
| DirectParserASTContentForInEnd data = new DirectParserASTContentForInEnd( |
| DirectParserASTType.END, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginForInExpression(Token token) { |
| DirectParserASTContentForInExpressionBegin data = |
| new DirectParserASTContentForInExpressionBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endForInExpression(Token token) { |
| DirectParserASTContentForInExpressionEnd data = |
| new DirectParserASTContentForInExpressionEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginForInBody(Token token) { |
| DirectParserASTContentForInBodyBegin data = |
| new DirectParserASTContentForInBodyBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endForInBody(Token token) { |
| DirectParserASTContentForInBodyEnd data = |
| new DirectParserASTContentForInBodyEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginNamedFunctionExpression(Token token) { |
| DirectParserASTContentNamedFunctionExpressionBegin data = |
| new DirectParserASTContentNamedFunctionExpressionBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endNamedFunctionExpression(Token endToken) { |
| DirectParserASTContentNamedFunctionExpressionEnd data = |
| new DirectParserASTContentNamedFunctionExpressionEnd( |
| DirectParserASTType.END, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginLocalFunctionDeclaration(Token token) { |
| DirectParserASTContentLocalFunctionDeclarationBegin data = |
| new DirectParserASTContentLocalFunctionDeclarationBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endLocalFunctionDeclaration(Token endToken) { |
| DirectParserASTContentLocalFunctionDeclarationEnd data = |
| new DirectParserASTContentLocalFunctionDeclarationEnd( |
| DirectParserASTType.END, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginBlockFunctionBody(Token token) { |
| DirectParserASTContentBlockFunctionBodyBegin data = |
| new DirectParserASTContentBlockFunctionBodyBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endBlockFunctionBody(int count, Token beginToken, Token endToken) { |
| DirectParserASTContentBlockFunctionBodyEnd data = |
| new DirectParserASTContentBlockFunctionBodyEnd(DirectParserASTType.END, |
| count: count, beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void handleNoFunctionBody(Token token) { |
| DirectParserASTContentNoFunctionBodyHandle data = |
| new DirectParserASTContentNoFunctionBodyHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void handleFunctionBodySkipped(Token token, bool isExpressionBody) { |
| DirectParserASTContentFunctionBodySkippedHandle data = |
| new DirectParserASTContentFunctionBodySkippedHandle( |
| DirectParserASTType.HANDLE, |
| token: token, |
| isExpressionBody: isExpressionBody); |
| seen(data); |
| } |
| |
| void beginFunctionName(Token token) { |
| DirectParserASTContentFunctionNameBegin data = |
| new DirectParserASTContentFunctionNameBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endFunctionName(Token beginToken, Token token) { |
| DirectParserASTContentFunctionNameEnd data = |
| new DirectParserASTContentFunctionNameEnd(DirectParserASTType.END, |
| beginToken: beginToken, token: token); |
| seen(data); |
| } |
| |
| void beginFunctionTypeAlias(Token token) { |
| DirectParserASTContentFunctionTypeAliasBegin data = |
| new DirectParserASTContentFunctionTypeAliasBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endFunctionTypeAlias( |
| Token typedefKeyword, Token equals, Token endToken) { |
| DirectParserASTContentFunctionTypeAliasEnd data = |
| new DirectParserASTContentFunctionTypeAliasEnd(DirectParserASTType.END, |
| typedefKeyword: typedefKeyword, equals: equals, endToken: endToken); |
| seen(data); |
| } |
| |
| void handleClassWithClause(Token withKeyword) { |
| DirectParserASTContentClassWithClauseHandle data = |
| new DirectParserASTContentClassWithClauseHandle( |
| DirectParserASTType.HANDLE, |
| withKeyword: withKeyword); |
| seen(data); |
| } |
| |
| void handleClassNoWithClause() { |
| DirectParserASTContentClassNoWithClauseHandle data = |
| new DirectParserASTContentClassNoWithClauseHandle( |
| DirectParserASTType.HANDLE); |
| seen(data); |
| } |
| |
| void beginNamedMixinApplication( |
| Token begin, Token abstractToken, Token name) { |
| DirectParserASTContentNamedMixinApplicationBegin data = |
| new DirectParserASTContentNamedMixinApplicationBegin( |
| DirectParserASTType.BEGIN, |
| begin: begin, |
| abstractToken: abstractToken, |
| name: name); |
| seen(data); |
| } |
| |
| void handleNamedMixinApplicationWithClause(Token withKeyword) { |
| DirectParserASTContentNamedMixinApplicationWithClauseHandle data = |
| new DirectParserASTContentNamedMixinApplicationWithClauseHandle( |
| DirectParserASTType.HANDLE, |
| withKeyword: withKeyword); |
| seen(data); |
| } |
| |
| void endNamedMixinApplication(Token begin, Token classKeyword, Token equals, |
| Token implementsKeyword, Token endToken) { |
| DirectParserASTContentNamedMixinApplicationEnd data = |
| new DirectParserASTContentNamedMixinApplicationEnd( |
| DirectParserASTType.END, |
| begin: begin, |
| classKeyword: classKeyword, |
| equals: equals, |
| implementsKeyword: implementsKeyword, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginHide(Token hideKeyword) { |
| DirectParserASTContentHideBegin data = new DirectParserASTContentHideBegin( |
| DirectParserASTType.BEGIN, |
| hideKeyword: hideKeyword); |
| seen(data); |
| } |
| |
| void endHide(Token hideKeyword) { |
| DirectParserASTContentHideEnd data = new DirectParserASTContentHideEnd( |
| DirectParserASTType.END, |
| hideKeyword: hideKeyword); |
| seen(data); |
| } |
| |
| void handleIdentifierList(int count) { |
| DirectParserASTContentIdentifierListHandle data = |
| new DirectParserASTContentIdentifierListHandle( |
| DirectParserASTType.HANDLE, |
| count: count); |
| seen(data); |
| } |
| |
| void beginTypeList(Token token) { |
| DirectParserASTContentTypeListBegin data = |
| new DirectParserASTContentTypeListBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endTypeList(int count) { |
| DirectParserASTContentTypeListEnd data = |
| new DirectParserASTContentTypeListEnd(DirectParserASTType.END, |
| count: count); |
| seen(data); |
| } |
| |
| void beginIfStatement(Token token) { |
| DirectParserASTContentIfStatementBegin data = |
| new DirectParserASTContentIfStatementBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endIfStatement(Token ifToken, Token elseToken) { |
| DirectParserASTContentIfStatementEnd data = |
| new DirectParserASTContentIfStatementEnd(DirectParserASTType.END, |
| ifToken: ifToken, elseToken: elseToken); |
| seen(data); |
| } |
| |
| void beginThenStatement(Token token) { |
| DirectParserASTContentThenStatementBegin data = |
| new DirectParserASTContentThenStatementBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endThenStatement(Token token) { |
| DirectParserASTContentThenStatementEnd data = |
| new DirectParserASTContentThenStatementEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginElseStatement(Token token) { |
| DirectParserASTContentElseStatementBegin data = |
| new DirectParserASTContentElseStatementBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endElseStatement(Token token) { |
| DirectParserASTContentElseStatementEnd data = |
| new DirectParserASTContentElseStatementEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginImport(Token importKeyword) { |
| DirectParserASTContentImportBegin data = |
| new DirectParserASTContentImportBegin(DirectParserASTType.BEGIN, |
| importKeyword: importKeyword); |
| seen(data); |
| } |
| |
| void handleImportPrefix(Token deferredKeyword, Token asKeyword) { |
| DirectParserASTContentImportPrefixHandle data = |
| new DirectParserASTContentImportPrefixHandle(DirectParserASTType.HANDLE, |
| deferredKeyword: deferredKeyword, asKeyword: asKeyword); |
| seen(data); |
| } |
| |
| void endImport(Token importKeyword, Token semicolon) { |
| DirectParserASTContentImportEnd data = new DirectParserASTContentImportEnd( |
| DirectParserASTType.END, |
| importKeyword: importKeyword, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleRecoverImport(Token semicolon) { |
| DirectParserASTContentRecoverImportHandle data = |
| new DirectParserASTContentRecoverImportHandle( |
| DirectParserASTType.HANDLE, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void beginConditionalUris(Token token) { |
| DirectParserASTContentConditionalUrisBegin data = |
| new DirectParserASTContentConditionalUrisBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endConditionalUris(int count) { |
| DirectParserASTContentConditionalUrisEnd data = |
| new DirectParserASTContentConditionalUrisEnd(DirectParserASTType.END, |
| count: count); |
| seen(data); |
| } |
| |
| void beginConditionalUri(Token ifKeyword) { |
| DirectParserASTContentConditionalUriBegin data = |
| new DirectParserASTContentConditionalUriBegin(DirectParserASTType.BEGIN, |
| ifKeyword: ifKeyword); |
| seen(data); |
| } |
| |
| void endConditionalUri(Token ifKeyword, Token leftParen, Token equalSign) { |
| DirectParserASTContentConditionalUriEnd data = |
| new DirectParserASTContentConditionalUriEnd(DirectParserASTType.END, |
| ifKeyword: ifKeyword, leftParen: leftParen, equalSign: equalSign); |
| seen(data); |
| } |
| |
| void handleDottedName(int count, Token firstIdentifier) { |
| DirectParserASTContentDottedNameHandle data = |
| new DirectParserASTContentDottedNameHandle(DirectParserASTType.HANDLE, |
| count: count, firstIdentifier: firstIdentifier); |
| seen(data); |
| } |
| |
| void beginImplicitCreationExpression(Token token) { |
| DirectParserASTContentImplicitCreationExpressionBegin data = |
| new DirectParserASTContentImplicitCreationExpressionBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endImplicitCreationExpression(Token token) { |
| DirectParserASTContentImplicitCreationExpressionEnd data = |
| new DirectParserASTContentImplicitCreationExpressionEnd( |
| DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginInitializedIdentifier(Token token) { |
| DirectParserASTContentInitializedIdentifierBegin data = |
| new DirectParserASTContentInitializedIdentifierBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endInitializedIdentifier(Token nameToken) { |
| DirectParserASTContentInitializedIdentifierEnd data = |
| new DirectParserASTContentInitializedIdentifierEnd( |
| DirectParserASTType.END, |
| nameToken: nameToken); |
| seen(data); |
| } |
| |
| void beginFieldInitializer(Token token) { |
| DirectParserASTContentFieldInitializerBegin data = |
| new DirectParserASTContentFieldInitializerBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endFieldInitializer(Token assignment, Token token) { |
| DirectParserASTContentFieldInitializerEnd data = |
| new DirectParserASTContentFieldInitializerEnd(DirectParserASTType.END, |
| assignment: assignment, token: token); |
| seen(data); |
| } |
| |
| void handleNoFieldInitializer(Token token) { |
| DirectParserASTContentNoFieldInitializerHandle data = |
| new DirectParserASTContentNoFieldInitializerHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginVariableInitializer(Token token) { |
| DirectParserASTContentVariableInitializerBegin data = |
| new DirectParserASTContentVariableInitializerBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endVariableInitializer(Token assignmentOperator) { |
| DirectParserASTContentVariableInitializerEnd data = |
| new DirectParserASTContentVariableInitializerEnd( |
| DirectParserASTType.END, |
| assignmentOperator: assignmentOperator); |
| seen(data); |
| } |
| |
| void handleNoVariableInitializer(Token token) { |
| DirectParserASTContentNoVariableInitializerHandle data = |
| new DirectParserASTContentNoVariableInitializerHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginInitializer(Token token) { |
| DirectParserASTContentInitializerBegin data = |
| new DirectParserASTContentInitializerBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endInitializer(Token token) { |
| DirectParserASTContentInitializerEnd data = |
| new DirectParserASTContentInitializerEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void beginInitializers(Token token) { |
| DirectParserASTContentInitializersBegin data = |
| new DirectParserASTContentInitializersBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endInitializers(int count, Token beginToken, Token endToken) { |
| DirectParserASTContentInitializersEnd data = |
| new DirectParserASTContentInitializersEnd(DirectParserASTType.END, |
| count: count, beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void handleNoInitializers() { |
| DirectParserASTContentNoInitializersHandle data = |
| new DirectParserASTContentNoInitializersHandle( |
| DirectParserASTType.HANDLE); |
| seen(data); |
| } |
| |
| void handleInvalidExpression(Token token) { |
| DirectParserASTContentInvalidExpressionHandle data = |
| new DirectParserASTContentInvalidExpressionHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void handleInvalidFunctionBody(Token token) { |
| DirectParserASTContentInvalidFunctionBodyHandle data = |
| new DirectParserASTContentInvalidFunctionBodyHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void handleInvalidTypeReference(Token token) { |
| DirectParserASTContentInvalidTypeReferenceHandle data = |
| new DirectParserASTContentInvalidTypeReferenceHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void handleLabel(Token token) { |
| DirectParserASTContentLabelHandle data = |
| new DirectParserASTContentLabelHandle(DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginLabeledStatement(Token token, int labelCount) { |
| DirectParserASTContentLabeledStatementBegin data = |
| new DirectParserASTContentLabeledStatementBegin( |
| DirectParserASTType.BEGIN, |
| token: token, |
| labelCount: labelCount); |
| seen(data); |
| } |
| |
| void endLabeledStatement(int labelCount) { |
| DirectParserASTContentLabeledStatementEnd data = |
| new DirectParserASTContentLabeledStatementEnd(DirectParserASTType.END, |
| labelCount: labelCount); |
| seen(data); |
| } |
| |
| void beginLibraryName(Token token) { |
| DirectParserASTContentLibraryNameBegin data = |
| new DirectParserASTContentLibraryNameBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endLibraryName(Token libraryKeyword, Token semicolon) { |
| DirectParserASTContentLibraryNameEnd data = |
| new DirectParserASTContentLibraryNameEnd(DirectParserASTType.END, |
| libraryKeyword: libraryKeyword, semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleLiteralMapEntry(Token colon, Token endToken) { |
| DirectParserASTContentLiteralMapEntryHandle data = |
| new DirectParserASTContentLiteralMapEntryHandle( |
| DirectParserASTType.HANDLE, |
| colon: colon, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginLiteralString(Token token) { |
| DirectParserASTContentLiteralStringBegin data = |
| new DirectParserASTContentLiteralStringBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void handleInterpolationExpression(Token leftBracket, Token rightBracket) { |
| DirectParserASTContentInterpolationExpressionHandle data = |
| new DirectParserASTContentInterpolationExpressionHandle( |
| DirectParserASTType.HANDLE, |
| leftBracket: leftBracket, |
| rightBracket: rightBracket); |
| seen(data); |
| } |
| |
| void endLiteralString(int interpolationCount, Token endToken) { |
| DirectParserASTContentLiteralStringEnd data = |
| new DirectParserASTContentLiteralStringEnd(DirectParserASTType.END, |
| interpolationCount: interpolationCount, endToken: endToken); |
| seen(data); |
| } |
| |
| void handleStringJuxtaposition(Token startToken, int literalCount) { |
| DirectParserASTContentStringJuxtapositionHandle data = |
| new DirectParserASTContentStringJuxtapositionHandle( |
| DirectParserASTType.HANDLE, |
| startToken: startToken, |
| literalCount: literalCount); |
| seen(data); |
| } |
| |
| void beginMember() { |
| DirectParserASTContentMemberBegin data = |
| new DirectParserASTContentMemberBegin(DirectParserASTType.BEGIN); |
| seen(data); |
| } |
| |
| void handleInvalidMember(Token endToken) { |
| DirectParserASTContentInvalidMemberHandle data = |
| new DirectParserASTContentInvalidMemberHandle( |
| DirectParserASTType.HANDLE, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endMember() { |
| DirectParserASTContentMemberEnd data = |
| new DirectParserASTContentMemberEnd(DirectParserASTType.END); |
| seen(data); |
| } |
| |
| void beginMethod(Token externalToken, Token staticToken, Token covariantToken, |
| Token varFinalOrConst, Token getOrSet, Token name) { |
| DirectParserASTContentMethodBegin data = |
| new DirectParserASTContentMethodBegin(DirectParserASTType.BEGIN, |
| externalToken: externalToken, |
| staticToken: staticToken, |
| covariantToken: covariantToken, |
| varFinalOrConst: varFinalOrConst, |
| getOrSet: getOrSet, |
| name: name); |
| seen(data); |
| } |
| |
| void endClassMethod(Token getOrSet, Token beginToken, Token beginParam, |
| Token beginInitializers, Token endToken) { |
| DirectParserASTContentClassMethodEnd data = |
| new DirectParserASTContentClassMethodEnd(DirectParserASTType.END, |
| getOrSet: getOrSet, |
| beginToken: beginToken, |
| beginParam: beginParam, |
| beginInitializers: beginInitializers, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endMixinMethod(Token getOrSet, Token beginToken, Token beginParam, |
| Token beginInitializers, Token endToken) { |
| DirectParserASTContentMixinMethodEnd data = |
| new DirectParserASTContentMixinMethodEnd(DirectParserASTType.END, |
| getOrSet: getOrSet, |
| beginToken: beginToken, |
| beginParam: beginParam, |
| beginInitializers: beginInitializers, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endExtensionMethod(Token getOrSet, Token beginToken, Token beginParam, |
| Token beginInitializers, Token endToken) { |
| DirectParserASTContentExtensionMethodEnd data = |
| new DirectParserASTContentExtensionMethodEnd(DirectParserASTType.END, |
| getOrSet: getOrSet, |
| beginToken: beginToken, |
| beginParam: beginParam, |
| beginInitializers: beginInitializers, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endClassConstructor(Token getOrSet, Token beginToken, Token beginParam, |
| Token beginInitializers, Token endToken) { |
| DirectParserASTContentClassConstructorEnd data = |
| new DirectParserASTContentClassConstructorEnd(DirectParserASTType.END, |
| getOrSet: getOrSet, |
| beginToken: beginToken, |
| beginParam: beginParam, |
| beginInitializers: beginInitializers, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endMixinConstructor(Token getOrSet, Token beginToken, Token beginParam, |
| Token beginInitializers, Token endToken) { |
| DirectParserASTContentMixinConstructorEnd data = |
| new DirectParserASTContentMixinConstructorEnd(DirectParserASTType.END, |
| getOrSet: getOrSet, |
| beginToken: beginToken, |
| beginParam: beginParam, |
| beginInitializers: beginInitializers, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endExtensionConstructor(Token getOrSet, Token beginToken, |
| Token beginParam, Token beginInitializers, Token endToken) { |
| DirectParserASTContentExtensionConstructorEnd data = |
| new DirectParserASTContentExtensionConstructorEnd( |
| DirectParserASTType.END, |
| getOrSet: getOrSet, |
| beginToken: beginToken, |
| beginParam: beginParam, |
| beginInitializers: beginInitializers, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginMetadataStar(Token token) { |
| DirectParserASTContentMetadataStarBegin data = |
| new DirectParserASTContentMetadataStarBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endMetadataStar(int count) { |
| DirectParserASTContentMetadataStarEnd data = |
| new DirectParserASTContentMetadataStarEnd(DirectParserASTType.END, |
| count: count); |
| seen(data); |
| } |
| |
| void beginMetadata(Token token) { |
| DirectParserASTContentMetadataBegin data = |
| new DirectParserASTContentMetadataBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) { |
| DirectParserASTContentMetadataEnd data = |
| new DirectParserASTContentMetadataEnd(DirectParserASTType.END, |
| beginToken: beginToken, |
| periodBeforeName: periodBeforeName, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginOptionalFormalParameters(Token token) { |
| DirectParserASTContentOptionalFormalParametersBegin data = |
| new DirectParserASTContentOptionalFormalParametersBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endOptionalFormalParameters( |
| int count, Token beginToken, Token endToken) { |
| DirectParserASTContentOptionalFormalParametersEnd data = |
| new DirectParserASTContentOptionalFormalParametersEnd( |
| DirectParserASTType.END, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginPart(Token token) { |
| DirectParserASTContentPartBegin data = new DirectParserASTContentPartBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endPart(Token partKeyword, Token semicolon) { |
| DirectParserASTContentPartEnd data = new DirectParserASTContentPartEnd( |
| DirectParserASTType.END, |
| partKeyword: partKeyword, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void beginPartOf(Token token) { |
| DirectParserASTContentPartOfBegin data = |
| new DirectParserASTContentPartOfBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endPartOf( |
| Token partKeyword, Token ofKeyword, Token semicolon, bool hasName) { |
| DirectParserASTContentPartOfEnd data = new DirectParserASTContentPartOfEnd( |
| DirectParserASTType.END, |
| partKeyword: partKeyword, |
| ofKeyword: ofKeyword, |
| semicolon: semicolon, |
| hasName: hasName); |
| seen(data); |
| } |
| |
| void beginRedirectingFactoryBody(Token token) { |
| DirectParserASTContentRedirectingFactoryBodyBegin data = |
| new DirectParserASTContentRedirectingFactoryBodyBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endRedirectingFactoryBody(Token beginToken, Token endToken) { |
| DirectParserASTContentRedirectingFactoryBodyEnd data = |
| new DirectParserASTContentRedirectingFactoryBodyEnd( |
| DirectParserASTType.END, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginReturnStatement(Token token) { |
| DirectParserASTContentReturnStatementBegin data = |
| new DirectParserASTContentReturnStatementBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void handleNativeFunctionBody(Token nativeToken, Token semicolon) { |
| DirectParserASTContentNativeFunctionBodyHandle data = |
| new DirectParserASTContentNativeFunctionBodyHandle( |
| DirectParserASTType.HANDLE, |
| nativeToken: nativeToken, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleNativeFunctionBodyIgnored(Token nativeToken, Token semicolon) { |
| DirectParserASTContentNativeFunctionBodyIgnoredHandle data = |
| new DirectParserASTContentNativeFunctionBodyIgnoredHandle( |
| DirectParserASTType.HANDLE, |
| nativeToken: nativeToken, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleNativeFunctionBodySkipped(Token nativeToken, Token semicolon) { |
| DirectParserASTContentNativeFunctionBodySkippedHandle data = |
| new DirectParserASTContentNativeFunctionBodySkippedHandle( |
| DirectParserASTType.HANDLE, |
| nativeToken: nativeToken, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleEmptyFunctionBody(Token semicolon) { |
| DirectParserASTContentEmptyFunctionBodyHandle data = |
| new DirectParserASTContentEmptyFunctionBodyHandle( |
| DirectParserASTType.HANDLE, |
| semicolon: semicolon); |
| seen(data); |
| } |
| |
| void handleExpressionFunctionBody(Token arrowToken, Token endToken) { |
| DirectParserASTContentExpressionFunctionBodyHandle data = |
| new DirectParserASTContentExpressionFunctionBodyHandle( |
| DirectParserASTType.HANDLE, |
| arrowToken: arrowToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void endReturnStatement( |
| bool hasExpression, Token beginToken, Token endToken) { |
| DirectParserASTContentReturnStatementEnd data = |
| new DirectParserASTContentReturnStatementEnd(DirectParserASTType.END, |
| hasExpression: hasExpression, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void handleSend(Token beginToken, Token endToken) { |
| DirectParserASTContentSendHandle data = |
| new DirectParserASTContentSendHandle(DirectParserASTType.HANDLE, |
| beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginShow(Token showKeyword) { |
| DirectParserASTContentShowBegin data = new DirectParserASTContentShowBegin( |
| DirectParserASTType.BEGIN, |
| showKeyword: showKeyword); |
| seen(data); |
| } |
| |
| void endShow(Token showKeyword) { |
| DirectParserASTContentShowEnd data = new DirectParserASTContentShowEnd( |
| DirectParserASTType.END, |
| showKeyword: showKeyword); |
| seen(data); |
| } |
| |
| void beginSwitchStatement(Token token) { |
| DirectParserASTContentSwitchStatementBegin data = |
| new DirectParserASTContentSwitchStatementBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endSwitchStatement(Token switchKeyword, Token endToken) { |
| DirectParserASTContentSwitchStatementEnd data = |
| new DirectParserASTContentSwitchStatementEnd(DirectParserASTType.END, |
| switchKeyword: switchKeyword, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginSwitchBlock(Token token) { |
| DirectParserASTContentSwitchBlockBegin data = |
| new DirectParserASTContentSwitchBlockBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endSwitchBlock(int caseCount, Token beginToken, Token endToken) { |
| DirectParserASTContentSwitchBlockEnd data = |
| new DirectParserASTContentSwitchBlockEnd(DirectParserASTType.END, |
| caseCount: caseCount, beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginLiteralSymbol(Token token) { |
| DirectParserASTContentLiteralSymbolBegin data = |
| new DirectParserASTContentLiteralSymbolBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endLiteralSymbol(Token hashToken, int identifierCount) { |
| DirectParserASTContentLiteralSymbolEnd data = |
| new DirectParserASTContentLiteralSymbolEnd(DirectParserASTType.END, |
| hashToken: hashToken, identifierCount: identifierCount); |
| seen(data); |
| } |
| |
| void handleThrowExpression(Token throwToken, Token endToken) { |
| DirectParserASTContentThrowExpressionHandle data = |
| new DirectParserASTContentThrowExpressionHandle( |
| DirectParserASTType.HANDLE, |
| throwToken: throwToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginRethrowStatement(Token token) { |
| DirectParserASTContentRethrowStatementBegin data = |
| new DirectParserASTContentRethrowStatementBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endRethrowStatement(Token rethrowToken, Token endToken) { |
| DirectParserASTContentRethrowStatementEnd data = |
| new DirectParserASTContentRethrowStatementEnd(DirectParserASTType.END, |
| rethrowToken: rethrowToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void endTopLevelDeclaration(Token nextToken) { |
| DirectParserASTContentTopLevelDeclarationEnd data = |
| new DirectParserASTContentTopLevelDeclarationEnd( |
| DirectParserASTType.END, |
| nextToken: nextToken); |
| seen(data); |
| } |
| |
| void handleInvalidTopLevelDeclaration(Token endToken) { |
| DirectParserASTContentInvalidTopLevelDeclarationHandle data = |
| new DirectParserASTContentInvalidTopLevelDeclarationHandle( |
| DirectParserASTType.HANDLE, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginTopLevelMember(Token token) { |
| DirectParserASTContentTopLevelMemberBegin data = |
| new DirectParserASTContentTopLevelMemberBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void beginFields(Token lastConsumed) { |
| DirectParserASTContentFieldsBegin data = |
| new DirectParserASTContentFieldsBegin(DirectParserASTType.BEGIN, |
| lastConsumed: lastConsumed); |
| seen(data); |
| } |
| |
| void endTopLevelFields( |
| Token externalToken, |
| Token staticToken, |
| Token covariantToken, |
| Token lateToken, |
| Token varFinalOrConst, |
| int count, |
| Token beginToken, |
| Token endToken) { |
| DirectParserASTContentTopLevelFieldsEnd data = |
| new DirectParserASTContentTopLevelFieldsEnd(DirectParserASTType.END, |
| externalToken: externalToken, |
| staticToken: staticToken, |
| covariantToken: covariantToken, |
| lateToken: lateToken, |
| varFinalOrConst: varFinalOrConst, |
| count: count, |
| beginToken: beginToken, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginTopLevelMethod(Token lastConsumed, Token externalToken) { |
| DirectParserASTContentTopLevelMethodBegin data = |
| new DirectParserASTContentTopLevelMethodBegin(DirectParserASTType.BEGIN, |
| lastConsumed: lastConsumed, externalToken: externalToken); |
| seen(data); |
| } |
| |
| void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) { |
| DirectParserASTContentTopLevelMethodEnd data = |
| new DirectParserASTContentTopLevelMethodEnd(DirectParserASTType.END, |
| beginToken: beginToken, getOrSet: getOrSet, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginTryStatement(Token token) { |
| DirectParserASTContentTryStatementBegin data = |
| new DirectParserASTContentTryStatementBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void handleCaseMatch(Token caseKeyword, Token colon) { |
| DirectParserASTContentCaseMatchHandle data = |
| new DirectParserASTContentCaseMatchHandle(DirectParserASTType.HANDLE, |
| caseKeyword: caseKeyword, colon: colon); |
| seen(data); |
| } |
| |
| void beginCatchClause(Token token) { |
| DirectParserASTContentCatchClauseBegin data = |
| new DirectParserASTContentCatchClauseBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endCatchClause(Token token) { |
| DirectParserASTContentCatchClauseEnd data = |
| new DirectParserASTContentCatchClauseEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void handleCatchBlock(Token onKeyword, Token catchKeyword, Token comma) { |
| DirectParserASTContentCatchBlockHandle data = |
| new DirectParserASTContentCatchBlockHandle(DirectParserASTType.HANDLE, |
| onKeyword: onKeyword, catchKeyword: catchKeyword, comma: comma); |
| seen(data); |
| } |
| |
| void handleFinallyBlock(Token finallyKeyword) { |
| DirectParserASTContentFinallyBlockHandle data = |
| new DirectParserASTContentFinallyBlockHandle(DirectParserASTType.HANDLE, |
| finallyKeyword: finallyKeyword); |
| seen(data); |
| } |
| |
| void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) { |
| DirectParserASTContentTryStatementEnd data = |
| new DirectParserASTContentTryStatementEnd(DirectParserASTType.END, |
| catchCount: catchCount, |
| tryKeyword: tryKeyword, |
| finallyKeyword: finallyKeyword); |
| seen(data); |
| } |
| |
| void handleType(Token beginToken, Token questionMark) { |
| DirectParserASTContentTypeHandle data = |
| new DirectParserASTContentTypeHandle(DirectParserASTType.HANDLE, |
| beginToken: beginToken, questionMark: questionMark); |
| seen(data); |
| } |
| |
| void handleNonNullAssertExpression(Token bang) { |
| DirectParserASTContentNonNullAssertExpressionHandle data = |
| new DirectParserASTContentNonNullAssertExpressionHandle( |
| DirectParserASTType.HANDLE, |
| bang: bang); |
| seen(data); |
| } |
| |
| void handleNoName(Token token) { |
| DirectParserASTContentNoNameHandle data = |
| new DirectParserASTContentNoNameHandle(DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginFunctionType(Token beginToken) { |
| DirectParserASTContentFunctionTypeBegin data = |
| new DirectParserASTContentFunctionTypeBegin(DirectParserASTType.BEGIN, |
| beginToken: beginToken); |
| seen(data); |
| } |
| |
| void endFunctionType(Token functionToken, Token questionMark) { |
| DirectParserASTContentFunctionTypeEnd data = |
| new DirectParserASTContentFunctionTypeEnd(DirectParserASTType.END, |
| functionToken: functionToken, questionMark: questionMark); |
| seen(data); |
| } |
| |
| void beginTypeArguments(Token token) { |
| DirectParserASTContentTypeArgumentsBegin data = |
| new DirectParserASTContentTypeArgumentsBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endTypeArguments(int count, Token beginToken, Token endToken) { |
| DirectParserASTContentTypeArgumentsEnd data = |
| new DirectParserASTContentTypeArgumentsEnd(DirectParserASTType.END, |
| count: count, beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void handleInvalidTypeArguments(Token token) { |
| DirectParserASTContentInvalidTypeArgumentsHandle data = |
| new DirectParserASTContentInvalidTypeArgumentsHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void handleNoTypeArguments(Token token) { |
| DirectParserASTContentNoTypeArgumentsHandle data = |
| new DirectParserASTContentNoTypeArgumentsHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginTypeVariable(Token token) { |
| DirectParserASTContentTypeVariableBegin data = |
| new DirectParserASTContentTypeVariableBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void handleTypeVariablesDefined(Token token, int count) { |
| DirectParserASTContentTypeVariablesDefinedHandle data = |
| new DirectParserASTContentTypeVariablesDefinedHandle( |
| DirectParserASTType.HANDLE, |
| token: token, |
| count: count); |
| seen(data); |
| } |
| |
| void endTypeVariable( |
| Token token, int index, Token extendsOrSuper, Token variance) { |
| DirectParserASTContentTypeVariableEnd data = |
| new DirectParserASTContentTypeVariableEnd(DirectParserASTType.END, |
| token: token, |
| index: index, |
| extendsOrSuper: extendsOrSuper, |
| variance: variance); |
| seen(data); |
| } |
| |
| void beginTypeVariables(Token token) { |
| DirectParserASTContentTypeVariablesBegin data = |
| new DirectParserASTContentTypeVariablesBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endTypeVariables(Token beginToken, Token endToken) { |
| DirectParserASTContentTypeVariablesEnd data = |
| new DirectParserASTContentTypeVariablesEnd(DirectParserASTType.END, |
| beginToken: beginToken, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginFunctionExpression(Token token) { |
| DirectParserASTContentFunctionExpressionBegin data = |
| new DirectParserASTContentFunctionExpressionBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endFunctionExpression(Token beginToken, Token token) { |
| DirectParserASTContentFunctionExpressionEnd data = |
| new DirectParserASTContentFunctionExpressionEnd(DirectParserASTType.END, |
| beginToken: beginToken, token: token); |
| seen(data); |
| } |
| |
| void beginVariablesDeclaration( |
| Token token, Token lateToken, Token varFinalOrConst) { |
| DirectParserASTContentVariablesDeclarationBegin data = |
| new DirectParserASTContentVariablesDeclarationBegin( |
| DirectParserASTType.BEGIN, |
| token: token, |
| lateToken: lateToken, |
| varFinalOrConst: varFinalOrConst); |
| seen(data); |
| } |
| |
| void endVariablesDeclaration(int count, Token endToken) { |
| DirectParserASTContentVariablesDeclarationEnd data = |
| new DirectParserASTContentVariablesDeclarationEnd( |
| DirectParserASTType.END, |
| count: count, |
| endToken: endToken); |
| seen(data); |
| } |
| |
| void beginWhileStatement(Token token) { |
| DirectParserASTContentWhileStatementBegin data = |
| new DirectParserASTContentWhileStatementBegin(DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endWhileStatement(Token whileKeyword, Token endToken) { |
| DirectParserASTContentWhileStatementEnd data = |
| new DirectParserASTContentWhileStatementEnd(DirectParserASTType.END, |
| whileKeyword: whileKeyword, endToken: endToken); |
| seen(data); |
| } |
| |
| void beginAsOperatorType(Token operator) { |
| DirectParserASTContentAsOperatorTypeBegin data = |
| new DirectParserASTContentAsOperatorTypeBegin(DirectParserASTType.BEGIN, |
| operator: operator); |
| seen(data); |
| } |
| |
| void endAsOperatorType(Token operator) { |
| DirectParserASTContentAsOperatorTypeEnd data = |
| new DirectParserASTContentAsOperatorTypeEnd(DirectParserASTType.END, |
| operator: operator); |
| seen(data); |
| } |
| |
| void handleAsOperator(Token operator) { |
| DirectParserASTContentAsOperatorHandle data = |
| new DirectParserASTContentAsOperatorHandle(DirectParserASTType.HANDLE, |
| operator: operator); |
| seen(data); |
| } |
| |
| void handleAssignmentExpression(Token token) { |
| DirectParserASTContentAssignmentExpressionHandle data = |
| new DirectParserASTContentAssignmentExpressionHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginBinaryExpression(Token token) { |
| DirectParserASTContentBinaryExpressionBegin data = |
| new DirectParserASTContentBinaryExpressionBegin( |
| DirectParserASTType.BEGIN, |
| token: token); |
| seen(data); |
| } |
| |
| void endBinaryExpression(Token token) { |
| DirectParserASTContentBinaryExpressionEnd data = |
| new DirectParserASTContentBinaryExpressionEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void handleEndingBinaryExpression(Token token) { |
| DirectParserASTContentEndingBinaryExpressionHandle data = |
| new DirectParserASTContentEndingBinaryExpressionHandle( |
| DirectParserASTType.HANDLE, |
| token: token); |
| seen(data); |
| } |
| |
| void beginConditionalExpression(Token question) { |
| DirectParserASTContentConditionalExpressionBegin data = |
| new DirectParserASTContentConditionalExpressionBegin( |
| DirectParserASTType.BEGIN, |
| question: question); |
| seen(data); |
| } |
| |
| void handleConditionalExpressionColon() { |
| DirectParserASTContentConditionalExpressionColonHandle data = |
| new DirectParserASTContentConditionalExpressionColonHandle( |
| DirectParserASTType.HANDLE); |
| seen(data); |
| } |
| |
| void endConditionalExpression(Token question, Token colon) { |
| DirectParserASTContentConditionalExpressionEnd data = |
| new DirectParserASTContentConditionalExpressionEnd( |
| DirectParserASTType.END, |
| question: question, |
| colon: colon); |
| seen(data); |
| } |
| |
| void beginConstExpression(Token constKeyword) { |
| DirectParserASTContentConstExpressionBegin data = |
| new DirectParserASTContentConstExpressionBegin( |
| DirectParserASTType.BEGIN, |
| constKeyword: constKeyword); |
| seen(data); |
| } |
| |
| void endConstExpression(Token token) { |
| DirectParserASTContentConstExpressionEnd data = |
| new DirectParserASTContentConstExpressionEnd(DirectParserASTType.END, |
| token: token); |
| seen(data); |
| } |
| |
| void 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 => {}; |
| } |