parseUnit(enum) | |
skipErrorTokens(enum) | |
listener: beginCompilationUnit(enum) | |
syntheticPreviousToken(enum) | |
parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') | |
parseMetadataStar() | |
listener: beginMetadataStar(enum) | |
listener: endMetadataStar(0) | |
parseTopLevelKeywordDeclaration(, enum, null, Instance of 'DirectiveContext') | |
parseEnum(enum) | |
listener: beginUncategorizedTopLevelDeclaration(enum) | |
ensureIdentifier(enum, enumDeclaration) | |
insertSyntheticIdentifier(enum, enumDeclaration, message: Message[ExpectedIdentifier, Expected an identifier, but got 'class'., Try inserting an identifier before 'class'., {lexeme: class}], messageOnToken: null) | |
reportRecoverableError(class, Message[ExpectedIdentifier, Expected an identifier, but got 'class'., Try inserting an identifier before 'class'., {lexeme: class}]) | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'class'., Try inserting an identifier before 'class'., {lexeme: class}], class, class) | |
rewriter() | |
listener: handleIdentifier(, enumDeclaration) | |
listener: beginEnum(enum) | |
parseEnumHeaderOpt(, enum) | |
listener: handleNoTypeVariables(class) | |
recoverySmallLookAheadSkipTokens(, [{, with, implements]) | |
parseEnumWithClauseOpt() | |
listener: handleEnumNoWithClause() | |
recoveryEnumWith(, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
recoverySmallLookAheadSkipTokens(, [{, with, implements]) | |
parseClassOrMixinOrEnumImplementsOpt() | |
listener: handleImplements(null, 0) | |
recoveryEnumWith(, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
recoveryEnumImplements(, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
recoverySmallLookAheadSkipTokens(, [{, with, implements]) | |
ensureBlock(, Instance of 'Template<(Token) => Message>', null) | |
reportRecoverableError(class, Message[ExpectedEnumBody, Expected a enum body, but got 'class'., An enum definition must have a body with at least one constant name., {lexeme: class}]) | |
listener: handleRecoverableError(Message[ExpectedEnumBody, Expected a enum body, but got 'class'., An enum definition must have a body with at least one constant name., {lexeme: class}], class, class) | |
insertBlock() | |
rewriter() | |
rewriter() | |
listener: handleEnumHeader(enum, {) | |
listener: handleEnumElements(, 0) | |
listener: endEnum(enum, {, 0) | |
listener: endTopLevelDeclaration(class) | |
parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
parseMetadataStar(}) | |
listener: beginMetadataStar(class) | |
listener: endMetadataStar(0) | |
parseTopLevelKeywordDeclaration(}, class, null, Instance of 'DirectiveContext') | |
parseClassOrNamedMixinApplication(null, null, null, class) | |
listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class) | |
ensureIdentifier(class, classOrMixinDeclaration) | |
listener: handleIdentifier(A, classOrMixinDeclaration) | |
listener: handleNoTypeVariables({) | |
listener: beginClassDeclaration(class, null, null, null, A) | |
parseClass(A, class, class, A) | |
parseClassHeaderOpt(A, class, class) | |
parseClassExtendsOpt(A) | |
listener: handleNoType(A) | |
listener: handleClassExtends(null, 1) | |
parseClassWithClauseOpt(A) | |
listener: handleClassNoWithClause() | |
parseClassOrMixinOrEnumImplementsOpt(A) | |
listener: handleImplements(null, 0) | |
listener: handleClassHeader(class, class, null) | |
parseClassOrMixinOrExtensionBody(A, DeclarationKind.Class, A) | |
listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {) | |
notEofOrValue(}, void) | |
parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, A) | |
parseMetadataStar({) | |
listener: beginMetadataStar(void) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
parseMethod({, null, null, null, null, null, null, null, {, Instance of 'VoidType', null, foo, DeclarationKind.Class, A, false) | |
listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, foo) | |
listener: handleVoidKeyword(void) | |
ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false) | |
listener: handleIdentifier(foo, methodDeclaration) | |
parseQualifiedRestOpt(foo, methodDeclarationContinuation) | |
parseMethodTypeVar(foo) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(foo, foo, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(foo, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
parseMetadataStar(() | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(x) | |
listener: handleType(int, null) | |
ensureIdentifier(int, formalParameterDeclaration) | |
listener: handleIdentifier(x, formalParameterDeclaration) | |
listener: handleFormalParameterWithoutValue()) | |
listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, print) | |
parseStatement({) | |
parseStatementX({) | |
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false) | |
looksLikeLocalFunction(print) | |
parseExpressionStatement({) | |
parseExpression({) | |
parsePrecedenceExpression({, 1, true) | |
parseUnaryExpression({, true) | |
parsePrimary({, expression) | |
parseSendOrFunctionLiteral({, expression) | |
looksLikeFunctionBody(;) | |
parseSend({, expression) | |
isNextIdentifier({) | |
ensureIdentifier({, expression) | |
listener: handleIdentifier(print, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(print) | |
parseArguments(print) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
isNextIdentifier(() | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(*) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(*) | |
listener: handleSend(x, *) | |
listener: beginBinaryExpression(*) | |
parsePrecedenceExpression(*, 15, true) | |
parseUnaryExpression(*, true) | |
parsePrimary(*, expression) | |
parseLiteralInt(*) | |
listener: handleLiteralInt(42) | |
listener: endBinaryExpression(*) | |
listener: endArguments(1, (, )) | |
listener: handleSend(print, ;) | |
ensureSemicolon()) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(1, {, }) | |
listener: endClassMethod(null, void, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, }) | |
listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, }) | |
listener: endClassDeclaration(class, }) | |
listener: endTopLevelDeclaration(enum) | |
parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
parseMetadataStar(}) | |
listener: beginMetadataStar(enum) | |
listener: endMetadataStar(0) | |
parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
parseEnum(enum) | |
listener: beginUncategorizedTopLevelDeclaration(enum) | |
ensureIdentifier(enum, enumDeclaration) | |
listener: handleIdentifier(E, enumDeclaration) | |
listener: beginEnum(enum) | |
parseEnumHeaderOpt(E, enum) | |
listener: handleNoTypeVariables(int) | |
recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
parseEnumWithClauseOpt(E) | |
listener: handleEnumNoWithClause() | |
recoveryEnumWith(E, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
parseClassOrMixinOrEnumImplementsOpt(E) | |
listener: handleImplements(null, 0) | |
recoveryEnumWith(E, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
recoveryEnumImplements(E, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
ensureBlock(E, Instance of 'Template<(Token) => Message>', null) | |
reportRecoverableError(int, Message[ExpectedEnumBody, Expected a enum body, but got 'int'., An enum definition must have a body with at least one constant name., {lexeme: int}]) | |
listener: handleRecoverableError(Message[ExpectedEnumBody, Expected a enum body, but got 'int'., An enum definition must have a body with at least one constant name., {lexeme: int}], int, int) | |
insertBlock(E) | |
rewriter() | |
rewriter() | |
listener: handleEnumHeader(enum, {) | |
listener: handleEnumElements(E, 0) | |
listener: endEnum(enum, {, 0) | |
listener: endTopLevelDeclaration(int) | |
parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
parseTopLevelMemberImpl(}) | |
listener: beginTopLevelMember(int) | |
parseTopLevelMethod(}, null, null, }, Instance of 'SimpleType', null, f, false) | |
listener: beginTopLevelMethod(}, null, null) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(f) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false) | |
listener: handleIdentifier(f, topLevelFunctionDeclaration) | |
parseMethodTypeVar(f) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(f, f, false, MemberKind.TopLevelMethod) | |
parseFormalParameters(f, MemberKind.TopLevelMethod) | |
parseFormalParametersRest((, MemberKind.TopLevelMethod) | |
listener: beginFormalParameters((, MemberKind.TopLevelMethod) | |
listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod) | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
parseFunctionBody(), false, false) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(0, {, }) | |
listener: endTopLevelMethod(int, null, }) | |
listener: endTopLevelDeclaration() | |
reportAllErrorTokens(enum) | |
listener: endCompilationUnit(4, ) |