parseUnit(class) | |
skipErrorTokens(class) | |
listener: beginCompilationUnit(class) | |
syntheticPreviousToken(class) | |
parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') | |
parseMetadataStar() | |
listener: beginMetadataStar(class) | |
listener: endMetadataStar(0) | |
parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext') | |
parseClassDeclarationModifiers(, class) | |
parseClassOrNamedMixinApplication(null, class) | |
listener: beginClassOrNamedMixinApplicationPrelude(class) | |
ensureIdentifier(class, classOrMixinDeclaration) | |
listener: handleIdentifier(WrapperClass, classOrMixinDeclaration) | |
listener: handleNoTypeVariables({) | |
listener: beginClassDeclaration(class, null, WrapperClass) | |
parseClass(WrapperClass, class, class, WrapperClass) | |
parseClassHeaderOpt(WrapperClass, class, class) | |
parseClassExtendsOpt(WrapperClass) | |
listener: handleNoType(WrapperClass) | |
listener: handleClassExtends(null) | |
parseWithClauseOpt(WrapperClass) | |
listener: handleClassNoWithClause() | |
parseClassOrMixinImplementsOpt(WrapperClass) | |
listener: handleClassOrMixinImplements(null, 0) | |
listener: handleClassHeader(class, class, null) | |
parseClassOrMixinOrExtensionBody(WrapperClass, DeclarationKind.Class, WrapperClass) | |
listener: beginClassOrMixinBody(DeclarationKind.Class, {) | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar({) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(assert) | |
indicatesMethodOrField(() | |
parseMethod({, null, null, null, null, null, {, Instance of 'SimpleType', null, assert, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, assert) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(assert) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'assert'., null, {token: assert}], assert, assert) | |
listener: handleIdentifier(assert, methodDeclaration) | |
parseQualifiedRestOpt(assert, methodDeclarationContinuation) | |
parseMethodTypeVar(assert) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(assert, assert, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(assert, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseAssert(return, Assert.Expression) | |
listener: beginAssert(assert, Assert.Expression) | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
reportRecoverableError(assert, AssertAsExpression) | |
listener: handleRecoverableError(AssertAsExpression, assert, assert) | |
listener: endAssert(assert, Assert.Expression, (, null, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(break) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, break, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, break) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(break) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., null, {token: break}], break, break) | |
listener: handleIdentifier(break, methodDeclaration) | |
parseQualifiedRestOpt(break, methodDeclarationContinuation) | |
parseMethodTypeVar(break) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(break, break, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(break, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., null, {token: break}], break, break) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(break) | |
parseArgumentsOpt() | |
listener: handleNoArguments(break) | |
listener: handleSend(, break) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, break) | |
parseStatement(;) | |
parseStatementX(;) | |
parseBreakStatement(;) | |
isBreakAllowed() | |
reportRecoverableError(break, BreakOutsideOfLoop) | |
listener: handleRecoverableError(BreakOutsideOfLoop, break, break) | |
ensureSemicolon(break) | |
reportRecoverableError(break, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break) | |
rewriter() | |
listener: handleBreakStatement(false, break, ;) | |
notEofOrValue(}, () | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(() | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(;) | |
parseParenthesizedExpression(;) | |
parseExpressionInParenthesis(;) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(4, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(case) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, case, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, case) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(case) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'case'., null, {token: case}], case, case) | |
listener: handleIdentifier(case, methodDeclaration) | |
parseQualifiedRestOpt(case, methodDeclarationContinuation) | |
parseMethodTypeVar(case) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(case, case, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(case, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'case'., null, {token: case}], case, case) | |
listener: handleIdentifier(case, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(case) | |
parseArguments(case) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(case, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(catch) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, catch, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, catch) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(catch) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'catch'., null, {token: catch}], catch, catch) | |
listener: handleIdentifier(catch, methodDeclaration) | |
parseQualifiedRestOpt(catch, methodDeclarationContinuation) | |
parseMethodTypeVar(catch) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(catch, catch, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(catch, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'catch'., null, {token: catch}], catch, catch) | |
listener: handleIdentifier(catch, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(catch) | |
parseArguments(catch) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(catch, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(class) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, class, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, class) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(class) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'class'., null, {token: class}], class, class) | |
listener: handleIdentifier(class, methodDeclaration) | |
parseQualifiedRestOpt(class, methodDeclarationContinuation) | |
parseMethodTypeVar(class) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(class, class, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(class, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'class'., null, {token: class}], class, class) | |
listener: handleIdentifier(class, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(class) | |
parseArguments(class) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(class, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(const) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, const, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, const) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(const) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'const'., null, {token: const}], const, const) | |
listener: handleIdentifier(const, methodDeclaration) | |
parseQualifiedRestOpt(const, methodDeclarationContinuation) | |
parseMethodTypeVar(const) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(const, const, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(const, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseConstExpression(return) | |
listener: beginConstExpression(const) | |
parseConstructorReference(const, null) | |
ensureIdentifier(const, constructorReference) | |
insertSyntheticIdentifier(const, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], messageOnToken: null) | |
reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}]) | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, constructorReference) | |
listener: beginConstructorReference() | |
parseQualifiedRestOpt(, constructorReferenceContinuation) | |
listener: handleNoTypeArguments(() | |
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(() | |
listener: endConstructorReference(, null, () | |
parseConstructorInvocationArguments() | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: endConstExpression(const) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(continue) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, continue, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, continue) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(continue) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., null, {token: continue}], continue, continue) | |
listener: handleIdentifier(continue, methodDeclaration) | |
parseQualifiedRestOpt(continue, methodDeclarationContinuation) | |
parseMethodTypeVar(continue) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(continue, continue, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(continue, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., null, {token: continue}], continue, continue) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(continue) | |
parseArgumentsOpt() | |
listener: handleNoArguments(continue) | |
listener: handleSend(, continue) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, continue) | |
parseStatement(;) | |
parseStatementX(;) | |
parseContinueStatement(;) | |
isContinueAllowed() | |
reportRecoverableError(continue, ContinueOutsideOfLoop) | |
listener: handleRecoverableError(ContinueOutsideOfLoop, continue, continue) | |
ensureSemicolon(continue) | |
reportRecoverableError(continue, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue) | |
rewriter() | |
listener: handleContinueStatement(false, continue, ;) | |
notEofOrValue(}, () | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(() | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(;) | |
parseParenthesizedExpression(;) | |
parseExpressionInParenthesis(;) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(4, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(default) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, default, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, default) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(default) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'default'., null, {token: default}], default, default) | |
listener: handleIdentifier(default, methodDeclaration) | |
parseQualifiedRestOpt(default, methodDeclarationContinuation) | |
parseMethodTypeVar(default) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(default, default, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(default, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'default'., null, {token: default}], default, default) | |
listener: handleIdentifier(default, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(default) | |
parseArguments(default) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(default, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(do) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, do, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, do) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(do) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., null, {token: do}], do, do) | |
listener: handleIdentifier(do, methodDeclaration) | |
parseQualifiedRestOpt(do, methodDeclarationContinuation) | |
parseMethodTypeVar(do) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(do, do, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(do, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., null, {token: do}], do, do) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(do) | |
parseArgumentsOpt() | |
listener: handleNoArguments(do) | |
listener: handleSend(, do) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], do, do) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, do) | |
parseStatement(;) | |
parseStatementX(;) | |
parseDoWhileStatement(;) | |
listener: beginDoWhileStatement(do) | |
listener: beginDoWhileStatementBody(() | |
parseStatement(do) | |
parseStatementX(do) | |
parseExpressionStatementOrDeclaration(do, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(do, do, null, null, null, false) | |
looksLikeLocalFunction(() | |
parseExpressionStatement(do) | |
parseExpression(do) | |
parsePrecedenceExpression(do, 1, true) | |
parseUnaryExpression(do, true) | |
parsePrimary(do, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(do) | |
parseParenthesizedExpression(do) | |
parseExpressionInParenthesis(do) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
listener: endDoWhileStatementBody(;) | |
reportRecoverableError(}, Message[ExpectedButGot, Expected 'while' before this., null, {string: while}]) | |
listener: handleRecoverableError(Message[ExpectedButGot, Expected 'while' before this., null, {string: while}], }, }) | |
rewriter() | |
ensureParenthesizedCondition(while) | |
reportRecoverableError(}, Message[ExpectedToken, Expected to find '('., null, {string: (}]) | |
listener: handleRecoverableError(Message[ExpectedToken, Expected to find '('., null, {string: (}], }, }) | |
rewriter() | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., null, {token: }}], }, }) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments()) | |
parseArgumentsOpt() | |
listener: handleNoArguments()) | |
listener: handleSend(, )) | |
ensureCloseParen(, () | |
listener: handleParenthesizedCondition(() | |
ensureSemicolon()) | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, }) | |
rewriter() | |
listener: endDoWhileStatement(do, while, ;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(3, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(else) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, else, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, else) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(else) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., null, {token: else}], else, else) | |
listener: handleIdentifier(else, methodDeclaration) | |
parseQualifiedRestOpt(else, methodDeclarationContinuation) | |
parseMethodTypeVar(else) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(else, else, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(else, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., null, {token: else}], else, else) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(else) | |
parseArgumentsOpt() | |
listener: handleNoArguments(else) | |
listener: handleSend(, else) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, else) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(else) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
inPlainSync() | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., null, {token: else}], else, else) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(else) | |
parseArgumentsOpt() | |
listener: handleNoArguments(else) | |
listener: handleSend(, else) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}]) | |
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], else, else) | |
notEofOrValue(}, () | |
parseStatement(else) | |
parseStatementX(else) | |
parseExpressionStatementOrDeclaration(else, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(else, else, null, null, null, false) | |
looksLikeLocalFunction(() | |
parseExpressionStatement(else) | |
parseExpression(else) | |
parsePrecedenceExpression(else, 1, true) | |
parseUnaryExpression(else, true) | |
parsePrimary(else, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(else) | |
parseParenthesizedExpression(else) | |
parseExpressionInParenthesis(else) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(4, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(enum) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, enum, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, enum) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(enum) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'enum'., null, {token: enum}], enum, enum) | |
listener: handleIdentifier(enum, methodDeclaration) | |
parseQualifiedRestOpt(enum, methodDeclarationContinuation) | |
parseMethodTypeVar(enum) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(enum, enum, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(enum, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'enum'., null, {token: enum}], enum, enum) | |
listener: handleIdentifier(enum, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(enum) | |
parseArguments(enum) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(enum, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(extends) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, extends, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, extends) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(extends) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'extends'., null, {token: extends}], extends, extends) | |
listener: handleIdentifier(extends, methodDeclaration) | |
parseQualifiedRestOpt(extends, methodDeclarationContinuation) | |
parseMethodTypeVar(extends) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(extends, extends, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(extends, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'extends'., null, {token: extends}], extends, extends) | |
listener: handleIdentifier(extends, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(extends) | |
parseArguments(extends) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(extends, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(false) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, false, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, false) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(false) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'false'., null, {token: false}], false, false) | |
listener: handleIdentifier(false, methodDeclaration) | |
parseQualifiedRestOpt(false, methodDeclarationContinuation) | |
parseMethodTypeVar(false) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(false, false, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(false, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralBool(return) | |
listener: handleLiteralBool(false) | |
parseArgumentOrIndexStar(false, Instance of 'NoTypeParamOrArg', false) | |
listener: handleNoTypeArguments(() | |
parseArguments(false) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend((, )) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(final) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, final, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, final) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(final) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., null, {token: final}], final, final) | |
listener: handleIdentifier(final, methodDeclaration) | |
parseQualifiedRestOpt(final, methodDeclarationContinuation) | |
parseMethodTypeVar(final) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(final, final, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(final, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., null, {token: final}], final, final) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(final) | |
parseArgumentsOpt() | |
listener: handleNoArguments(final) | |
listener: handleSend(, final) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], final, final) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, final) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclarationAfterModifiers(final, ;, null, final, null, false) | |
looksLikeLocalFunction(() | |
listener: beginMetadataStar(final) | |
listener: endMetadataStar(0) | |
listener: handleNoType(final) | |
listener: beginVariablesDeclaration((, null, final) | |
parseVariablesDeclarationRest(final, true) | |
parseOptionallyInitializedIdentifier(final) | |
ensureIdentifier(final, localVariableDeclaration) | |
reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, localVariableDeclaration) | |
listener: beginInitializedIdentifier() | |
parseVariableInitializerOpt() | |
listener: handleNoVariableInitializer(x) | |
listener: endInitializedIdentifier() | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x) | |
rewriter() | |
listener: endVariablesDeclaration(1, ;) | |
notEofOrValue(}, x) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(x) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSendOrFunctionLiteral(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureSemicolon(1) | |
reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, )) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction()) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), )) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments()) | |
parseArgumentsOpt() | |
listener: handleNoArguments()) | |
listener: handleSend(, )) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), )) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}]) | |
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), )) | |
notEofOrValue(}, +) | |
parseStatement()) | |
parseStatementX()) | |
parseExpressionStatementOrDeclaration(), false) | |
parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement()) | |
parseExpression()) | |
parsePrecedenceExpression(), 1, true) | |
parseUnaryExpression(), true) | |
rewriteAndRecover(), UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(), expression) | |
parseSendOrFunctionLiteral(), expression) | |
parseSend(), expression) | |
ensureIdentifier(), expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(6, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(finally) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, finally, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, finally) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(finally) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'finally'., null, {token: finally}], finally, finally) | |
listener: handleIdentifier(finally, methodDeclaration) | |
parseQualifiedRestOpt(finally, methodDeclarationContinuation) | |
parseMethodTypeVar(finally) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(finally, finally, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(finally, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'finally'., null, {token: finally}], finally, finally) | |
listener: handleIdentifier(finally, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(finally) | |
parseArguments(finally) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(finally, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(for) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, for, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, for) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(for) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., null, {token: for}], for, for) | |
listener: handleIdentifier(for, methodDeclaration) | |
parseQualifiedRestOpt(for, methodDeclarationContinuation) | |
parseMethodTypeVar(for) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(for, for, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(for, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., null, {token: for}], for, for) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(for) | |
parseArgumentsOpt() | |
listener: handleNoArguments(for) | |
listener: handleSend(, for) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], for, for) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, for) | |
parseStatement(;) | |
parseStatementX(;) | |
parseForStatement(;, null) | |
listener: beginForStatement(for) | |
parseForLoopPartsStart(null, for) | |
parseExpressionStatementOrDeclaration((, true) | |
parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, true) | |
parseForLoopPartsMid((, null, for) | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: handleForInitializerExpressionStatement(1, false) | |
parseForRest(null, 1, for) | |
parseForLoopPartsRest(1, for, null) | |
ensureSemicolon(1) | |
reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
rewriter() | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), )) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments()) | |
parseArgumentsOpt() | |
listener: handleNoArguments()) | |
listener: handleSend(, )) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), )) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
listener: handleForLoopParts(for, (, ;, 0) | |
listener: beginForStatementBody(+) | |
parseStatement()) | |
parseStatementX()) | |
parseExpressionStatementOrDeclaration(), false) | |
parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement()) | |
parseExpression()) | |
parsePrecedenceExpression(), 1, true) | |
parseUnaryExpression(), true) | |
rewriteAndRecover(), UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(), expression) | |
parseSendOrFunctionLiteral(), expression) | |
parseSend(), expression) | |
ensureIdentifier(), expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
listener: endForStatementBody(}) | |
listener: endForStatement(}) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(3, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(if) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, if, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, if) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(if) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., null, {token: if}], if, if) | |
listener: handleIdentifier(if, methodDeclaration) | |
parseQualifiedRestOpt(if, methodDeclarationContinuation) | |
parseMethodTypeVar(if) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(if, if, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(if, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., null, {token: if}], if, if) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(if) | |
parseArgumentsOpt() | |
listener: handleNoArguments(if) | |
listener: handleSend(, if) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], if, if) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, if) | |
parseStatement(;) | |
parseStatementX(;) | |
parseIfStatement(;) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(+) | |
parseStatement()) | |
parseStatementX()) | |
parseExpressionStatementOrDeclaration(), false) | |
parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement()) | |
parseExpression()) | |
parsePrecedenceExpression(), 1, true) | |
parseUnaryExpression(), true) | |
rewriteAndRecover(), UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(), expression) | |
parseSendOrFunctionLiteral(), expression) | |
parseSend(), expression) | |
ensureIdentifier(), expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(3, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(in) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, in, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, in) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(in) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'in'., null, {token: in}], in, in) | |
listener: handleIdentifier(in, methodDeclaration) | |
parseQualifiedRestOpt(in, methodDeclarationContinuation) | |
parseMethodTypeVar(in) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(in, in, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(in, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'in'., null, {token: in}], in, in) | |
listener: handleIdentifier(in, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(in) | |
parseArguments(in) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(in, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(is) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, is, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, is) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(is) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., null, {token: is}], is, is) | |
listener: handleIdentifier(is, methodDeclaration) | |
parseQualifiedRestOpt(is, methodDeclarationContinuation) | |
parseMethodTypeVar(is) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(is, is, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(is, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., null, {token: is}], is, is) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(is) | |
parseArgumentsOpt() | |
listener: handleNoArguments(is) | |
listener: handleSend(, is) | |
parseIsOperatorRest() | |
listener: beginIsOperatorType(is) | |
computeTypeAfterIsOrAs(is) | |
reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedType, Expected a type, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, typeReference) | |
listener: handleNoTypeArguments(() | |
listener: handleType(, null) | |
listener: endIsOperatorType(is) | |
listener: handleIsOperator(is, null) | |
skipChainedAsIsOperators() | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, () | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, () | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(() | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(;) | |
parseParenthesizedExpression(;) | |
parseExpressionInParenthesis(;) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(3, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(new) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, new, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, new) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(new) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(new, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'new'., null, {token: new}], new, new) | |
listener: handleIdentifier(new, methodDeclaration) | |
parseQualifiedRestOpt(new, methodDeclarationContinuation) | |
parseMethodTypeVar(new) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(new, new, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(new, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseNewExpression(return) | |
listener: beginNewExpression(new) | |
parseConstructorReference(new, null) | |
ensureIdentifier(new, constructorReference) | |
insertSyntheticIdentifier(new, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], messageOnToken: null) | |
reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}]) | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, constructorReference) | |
listener: beginConstructorReference() | |
parseQualifiedRestOpt(, constructorReferenceContinuation) | |
listener: handleNoTypeArguments(() | |
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(() | |
listener: endConstructorReference(, null, () | |
parseConstructorInvocationArguments() | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: endNewExpression(new) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(null) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, null, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, null) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(null) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(null, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'null'., null, {token: null}], null, null) | |
listener: handleIdentifier(null, methodDeclaration) | |
parseQualifiedRestOpt(null, methodDeclarationContinuation) | |
parseMethodTypeVar(null) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(null, null, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(null, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralNull(return) | |
listener: handleLiteralNull(null) | |
parseArgumentOrIndexStar(null, Instance of 'NoTypeParamOrArg', false) | |
listener: handleNoTypeArguments(() | |
parseArguments(null) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend((, )) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(rethrow) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, rethrow, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, rethrow) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(rethrow) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'rethrow'., null, {token: rethrow}], rethrow, rethrow) | |
listener: handleIdentifier(rethrow, methodDeclaration) | |
parseQualifiedRestOpt(rethrow, methodDeclarationContinuation) | |
parseMethodTypeVar(rethrow) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(rethrow, rethrow, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(rethrow, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'rethrow'., null, {token: rethrow}], rethrow, rethrow) | |
listener: handleIdentifier(rethrow, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(rethrow) | |
parseArguments(rethrow) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(rethrow, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(return) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, return, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, return) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(return) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'return'., null, {token: return}], return, return) | |
listener: handleIdentifier(return, methodDeclaration) | |
parseQualifiedRestOpt(return, methodDeclarationContinuation) | |
parseMethodTypeVar(return) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(return, return, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(return, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {token: return}], return, return) | |
parsePrimary(return, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(return) | |
parseParenthesizedExpression(return) | |
parseExpressionInParenthesis(return) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(super) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, super, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, super) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(super) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'super'., null, {token: super}], super, super) | |
listener: handleIdentifier(super, methodDeclaration) | |
parseQualifiedRestOpt(super, methodDeclarationContinuation) | |
parseMethodTypeVar(super) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(super, super, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(super, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseSuperExpression(return, expression) | |
listener: handleSuperExpression(super, expression) | |
listener: handleNoTypeArguments(() | |
parseArguments(super) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(super, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(switch) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, switch, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, switch) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(switch) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., null, {token: switch}], switch, switch) | |
listener: handleIdentifier(switch, methodDeclaration) | |
parseQualifiedRestOpt(switch, methodDeclarationContinuation) | |
parseMethodTypeVar(switch) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(switch, switch, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(switch, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., null, {token: switch}], switch, switch) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(switch) | |
parseArgumentsOpt() | |
listener: handleNoArguments(switch) | |
listener: handleSend(, switch) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], switch, switch) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, switch) | |
parseStatement(;) | |
parseStatementX(;) | |
parseSwitchStatement(;) | |
listener: beginSwitchStatement(switch) | |
ensureParenthesizedCondition(switch) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedCondition(() | |
parseSwitchBlock()) | |
ensureBlock(), null, switch statement) | |
reportRecoverableError(), Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}]) | |
listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}], ), )) | |
insertBlock()) | |
rewriter() | |
rewriter() | |
listener: beginSwitchBlock({) | |
notEofOrValue(}, }) | |
listener: endSwitchBlock(0, {, }) | |
listener: endSwitchStatement(switch, }) | |
notEofOrValue(}, +) | |
parseStatement(}) | |
parseStatementX(}) | |
parseExpressionStatementOrDeclaration(}, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement(}) | |
parseExpression(}) | |
parsePrecedenceExpression(}, 1, true) | |
parseUnaryExpression(}, true) | |
rewriteAndRecover(}, UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(}, expression) | |
parseSendOrFunctionLiteral(}, expression) | |
parseSend(}, expression) | |
ensureIdentifier(}, expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(4, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
recoverFromInvalidMember(int, }, null, null, null, null, null, }, Instance of 'SimpleType', null, DeclarationKind.Class, WrapperClass) | |
parseFields(}, null, null, null, null, null, }, Instance of 'SimpleType', this, DeclarationKind.Class, WrapperClass, false) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(this) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false) | |
reportRecoverableErrorWithToken(this, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'this'., null, {token: this}], this, this) | |
listener: handleIdentifier(this, fieldDeclaration) | |
parseFieldInitializerOpt(this, this, null, null, DeclarationKind.Class, WrapperClass) | |
listener: handleNoFieldInitializer(() | |
ensureSemicolon(this) | |
reportRecoverableError(this, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], this, this) | |
rewriter() | |
listener: endClassFields(null, null, null, null, 1, int, ;) | |
listener: endMember() | |
notEofOrValue(}, () | |
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(;) | |
listener: beginMetadataStar(() | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
recoverFromInvalidMember(;, ;, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass) | |
parseMethod(;, null, null, null, null, null, ;, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass, false) | |
listener: beginMethod(null, null, null, null, null, () | |
listener: handleNoType(;) | |
ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false) | |
insertSyntheticIdentifier(;, methodDeclaration, message: null, messageOnToken: null) | |
reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}]) | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, methodDeclaration) | |
parseQualifiedRestOpt(, methodDeclarationContinuation) | |
parseMethodTypeVar() | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(, (, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseThisExpression(return, expression) | |
listener: handleThisExpression(this, expression) | |
listener: handleNoTypeArguments(() | |
parseArguments(this) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(this, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, , (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(throw) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, throw, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, throw) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(throw) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(throw, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'throw'., null, {token: throw}], throw, throw) | |
listener: handleIdentifier(throw, methodDeclaration) | |
parseQualifiedRestOpt(throw, methodDeclarationContinuation) | |
parseMethodTypeVar(throw) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(throw, throw, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(throw, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parseThrowExpression(return, true) | |
parseExpression(throw) | |
parsePrecedenceExpression(throw, 1, true) | |
parseUnaryExpression(throw, true) | |
parsePrimary(throw, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(throw) | |
parseParenthesizedExpression(throw) | |
parseExpressionInParenthesis(throw) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
listener: handleThrowExpression(throw, ;) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(true) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, true, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, true) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(true) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(true, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'true'., null, {token: true}], true, true) | |
listener: handleIdentifier(true, methodDeclaration) | |
parseQualifiedRestOpt(true, methodDeclarationContinuation) | |
parseMethodTypeVar(true) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(true, true, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(true, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralBool(return) | |
listener: handleLiteralBool(true) | |
parseArgumentOrIndexStar(true, Instance of 'NoTypeParamOrArg', false) | |
listener: handleNoTypeArguments(() | |
parseArguments(true) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend((, )) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(try) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, try, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, try) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(try) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., null, {token: try}], try, try) | |
listener: handleIdentifier(try, methodDeclaration) | |
parseQualifiedRestOpt(try, methodDeclarationContinuation) | |
parseMethodTypeVar(try) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(try, try, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(try, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., null, {token: try}], try, try) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(try) | |
parseArgumentsOpt() | |
listener: handleNoArguments(try) | |
listener: handleSend(, try) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], try, try) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, try) | |
parseStatement(;) | |
parseStatementX(;) | |
parseTryStatement(;) | |
listener: beginTryStatement(try) | |
parseBlock(try, BlockKind(try statement)) | |
ensureBlock(try, null, try statement) | |
reportRecoverableError(try, Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}]) | |
listener: handleRecoverableError(Message[ExpectedClassOrMixinBody, A try statement must have a body, even if it is empty., Try adding an empty body., {string: try statement}], try, try) | |
insertBlock(try) | |
rewriter() | |
rewriter() | |
listener: beginBlock({, BlockKind(try statement)) | |
notEofOrValue(}, }) | |
listener: endBlock(0, {, }, BlockKind(try statement)) | |
reportRecoverableError(try, OnlyTry) | |
listener: handleRecoverableError(OnlyTry, try, try) | |
listener: endTryStatement(0, try, null) | |
notEofOrValue(}, () | |
parseStatement(}) | |
parseStatementX(}) | |
parseExpressionStatementOrDeclaration(}, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(}, }, null, null, null, false) | |
looksLikeLocalFunction(() | |
parseExpressionStatement(}) | |
parseExpression(}) | |
parsePrecedenceExpression(}, 1, true) | |
parseUnaryExpression(}, true) | |
parsePrimary(}, expression) | |
parseParenthesizedExpressionOrFunctionLiteral(}) | |
parseParenthesizedExpression(}) | |
parseExpressionInParenthesis(}) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedExpression(() | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(4, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(var) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, var, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, var) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(var) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., null, {token: var}], var, var) | |
listener: handleIdentifier(var, methodDeclaration) | |
parseQualifiedRestOpt(var, methodDeclarationContinuation) | |
parseMethodTypeVar(var) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(var, var, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(var, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., null, {token: var}], var, var) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(var) | |
parseArgumentsOpt() | |
listener: handleNoArguments(var) | |
listener: handleSend(, var) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], var, var) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, var) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, false) | |
looksLikeLocalFunction(() | |
listener: beginMetadataStar(var) | |
listener: endMetadataStar(0) | |
listener: handleNoType(var) | |
listener: beginVariablesDeclaration((, null, var) | |
parseVariablesDeclarationRest(var, true) | |
parseOptionallyInitializedIdentifier(var) | |
ensureIdentifier(var, localVariableDeclaration) | |
reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, localVariableDeclaration) | |
listener: beginInitializedIdentifier() | |
parseVariableInitializerOpt() | |
listener: handleNoVariableInitializer(x) | |
listener: endInitializedIdentifier() | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x) | |
rewriter() | |
listener: endVariablesDeclaration(1, ;) | |
notEofOrValue(}, x) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(x) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSendOrFunctionLiteral(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureSemicolon(1) | |
reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, )) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction()) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), )) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments()) | |
parseArgumentsOpt() | |
listener: handleNoArguments()) | |
listener: handleSend(, )) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), )) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}]) | |
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), )) | |
notEofOrValue(}, +) | |
parseStatement()) | |
parseStatementX()) | |
parseExpressionStatementOrDeclaration(), false) | |
parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement()) | |
parseExpression()) | |
parsePrecedenceExpression(), 1, true) | |
parseUnaryExpression(), true) | |
rewriteAndRecover(), UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(), expression) | |
parseSendOrFunctionLiteral(), expression) | |
parseSend(), expression) | |
ensureIdentifier(), expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(6, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(void) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, void, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, void) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(void) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., null, {token: void}], void, void) | |
listener: handleIdentifier(void, methodDeclaration) | |
parseQualifiedRestOpt(void, methodDeclarationContinuation) | |
parseMethodTypeVar(void) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(void, void, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(void, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseSendOrFunctionLiteral(return, expression) | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., null, {token: void}], void, void) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(void) | |
parseArgumentsOpt() | |
listener: handleNoArguments(void) | |
listener: handleSend(, void) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], void, void) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, void) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(() | |
listener: beginMetadataStar(void) | |
listener: endMetadataStar(0) | |
listener: handleVoidKeyword(void) | |
listener: beginVariablesDeclaration((, null, null) | |
parseVariablesDeclarationRest(void, true) | |
parseOptionallyInitializedIdentifier(void) | |
ensureIdentifier(void, localVariableDeclaration) | |
reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., null, {token: (}], (, () | |
rewriter() | |
listener: handleIdentifier(, localVariableDeclaration) | |
listener: beginInitializedIdentifier() | |
parseVariableInitializerOpt() | |
listener: handleNoVariableInitializer(x) | |
listener: endInitializedIdentifier() | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x) | |
rewriter() | |
listener: endVariablesDeclaration(1, ;) | |
notEofOrValue(}, x) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction(x) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSendOrFunctionLiteral(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureSemicolon(1) | |
reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, )) | |
parseStatement(;) | |
parseStatementX(;) | |
parseExpressionStatementOrDeclaration(;, false) | |
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false) | |
looksLikeLocalFunction()) | |
parseExpressionStatement(;) | |
parseExpression(;) | |
parsePrecedenceExpression(;, 1, true) | |
parseUnaryExpression(;, true) | |
parsePrimary(;, expression) | |
parseSend(;, expression) | |
ensureIdentifier(;, expression) | |
reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., null, {token: )}], ), )) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments()) | |
parseArgumentsOpt() | |
listener: handleNoArguments()) | |
listener: handleSend(, )) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), )) | |
rewriter() | |
listener: handleExpressionStatement(;) | |
reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}]) | |
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), )) | |
notEofOrValue(}, +) | |
parseStatement()) | |
parseStatementX()) | |
parseExpressionStatementOrDeclaration(), false) | |
parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement()) | |
parseExpression()) | |
parsePrecedenceExpression(), 1, true) | |
parseUnaryExpression(), true) | |
rewriteAndRecover(), UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(), expression) | |
parseSendOrFunctionLiteral(), expression) | |
parseSend(), expression) | |
ensureIdentifier(), expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(6, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(while) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, while, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, while) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(while) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., null, {token: while}], while, while) | |
listener: handleIdentifier(while, methodDeclaration) | |
parseQualifiedRestOpt(while, methodDeclarationContinuation) | |
parseMethodTypeVar(while) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(while, while, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(while, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., null, {token: while}], while, while) | |
rewriter() | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(while) | |
parseArgumentsOpt() | |
listener: handleNoArguments(while) | |
listener: handleSend(, while) | |
ensureSemicolon() | |
reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], while, while) | |
rewriter() | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, while) | |
parseStatement(;) | |
parseStatementX(;) | |
parseWhileStatement(;) | |
listener: beginWhileStatement(while) | |
ensureParenthesizedCondition(while) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
ensureCloseParen(1, () | |
listener: handleParenthesizedCondition(() | |
listener: beginWhileStatementBody(+) | |
parseStatement()) | |
parseStatementX()) | |
parseExpressionStatementOrDeclaration(), false) | |
parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false) | |
looksLikeLocalFunction(+) | |
parseExpressionStatement()) | |
parseExpression()) | |
parsePrecedenceExpression(), 1, true) | |
parseUnaryExpression(), true) | |
rewriteAndRecover(), UnsupportedPrefixPlus, ) | |
reportRecoverableError(+, UnsupportedPrefixPlus) | |
listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
rewriter() | |
parsePrimary(), expression) | |
parseSendOrFunctionLiteral(), expression) | |
parseSend(), expression) | |
ensureIdentifier(), expression) | |
listener: handleIdentifier(, expression) | |
listener: handleNoTypeArguments(+) | |
parseArgumentsOpt() | |
listener: handleNoArguments(+) | |
listener: handleSend(, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: handleExpressionStatement(;) | |
listener: endWhileStatementBody(}) | |
listener: endWhileStatement(while, }) | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(3, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, int) | |
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
parseMetadataStar(}) | |
listener: beginMetadataStar(int) | |
listener: endMetadataStar(0) | |
listener: beginMember() | |
isReservedKeyword(with) | |
indicatesMethodOrField(() | |
parseMethod(}, null, null, null, null, null, }, Instance of 'SimpleType', null, with, DeclarationKind.Class, WrapperClass, true) | |
listener: beginMethod(null, null, null, null, null, with) | |
listener: handleIdentifier(int, typeReference) | |
listener: handleNoTypeArguments(with) | |
listener: handleType(int, null) | |
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, true) | |
reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'with'., null, {token: with}], with, with) | |
listener: handleIdentifier(with, methodDeclaration) | |
parseQualifiedRestOpt(with, methodDeclarationContinuation) | |
parseMethodTypeVar(with) | |
listener: handleNoTypeVariables(() | |
parseGetterOrFormalParameters(with, with, false, MemberKind.NonStaticMethod) | |
parseFormalParameters(with, MemberKind.NonStaticMethod) | |
parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
parseFormalParameter((, FormalParameterKind.mandatory, 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, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) | |
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
parseInitializersOpt()) | |
listener: handleNoInitializers() | |
parseAsyncModifierOpt()) | |
listener: handleAsyncModifier(null, null) | |
inPlainSync() | |
inPlainSync() | |
parseFunctionBody(), false, true) | |
listener: beginBlockFunctionBody({) | |
notEofOrValue(}, if) | |
parseStatement({) | |
parseStatementX({) | |
parseIfStatement({) | |
listener: beginIfStatement(if) | |
ensureParenthesizedCondition(if) | |
parseExpressionInParenthesisRest(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(==) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(==) | |
listener: handleSend(x, ==) | |
listener: beginBinaryExpression(==) | |
parsePrecedenceExpression(==, 8, true) | |
parseUnaryExpression(==, true) | |
parsePrimary(==, expression) | |
parseLiteralInt(==) | |
listener: handleLiteralInt(0) | |
listener: endBinaryExpression(==) | |
ensureCloseParen(0, () | |
listener: handleParenthesizedCondition(() | |
listener: beginThenStatement(return) | |
parseStatement()) | |
parseStatementX()) | |
parseReturnStatement()) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
parseLiteralInt(return) | |
listener: handleLiteralInt(42) | |
ensureSemicolon(42) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
listener: endThenStatement(;) | |
listener: endIfStatement(if, null) | |
notEofOrValue(}, return) | |
parseStatement(;) | |
parseStatementX(;) | |
parseReturnStatement(;) | |
listener: beginReturnStatement(return) | |
parseExpression(return) | |
parsePrecedenceExpression(return, 1, true) | |
parseUnaryExpression(return, true) | |
parsePrimary(return, expression) | |
inPlainSync() | |
parseSend(return, expression) | |
ensureIdentifier(return, expression) | |
reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>') | |
listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'with'., null, {token: with}], with, with) | |
listener: handleIdentifier(with, expression) | |
listener: handleNoTypeArguments(() | |
parseArgumentsOpt(with) | |
parseArguments(with) | |
parseArgumentsRest(() | |
listener: beginArguments(() | |
parseExpression(() | |
parsePrecedenceExpression((, 1, true) | |
parseUnaryExpression((, true) | |
parsePrimary((, expression) | |
parseSendOrFunctionLiteral((, expression) | |
parseSend((, expression) | |
ensureIdentifier((, expression) | |
listener: handleIdentifier(x, expression) | |
listener: handleNoTypeArguments(-) | |
parseArgumentsOpt(x) | |
listener: handleNoArguments(-) | |
listener: handleSend(x, -) | |
listener: beginBinaryExpression(-) | |
parsePrecedenceExpression(-, 14, true) | |
parseUnaryExpression(-, true) | |
parsePrimary(-, expression) | |
parseLiteralInt(-) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(-) | |
listener: endArguments(1, (, )) | |
listener: handleSend(with, +) | |
listener: beginBinaryExpression(+) | |
parsePrecedenceExpression(+, 14, true) | |
parseUnaryExpression(+, true) | |
parsePrimary(+, expression) | |
parseLiteralInt(+) | |
listener: handleLiteralInt(1) | |
listener: endBinaryExpression(+) | |
ensureSemicolon(1) | |
listener: endReturnStatement(true, return, ;) | |
inGenerator() | |
notEofOrValue(}, }) | |
listener: endBlockFunctionBody(2, {, }) | |
listener: endClassMethod(null, int, (, null, }) | |
listener: endMember() | |
notEofOrValue(}, }) | |
listener: endClassOrMixinBody(DeclarationKind.Class, 34, {, }) | |
listener: endClassDeclaration(class, }) | |
listener: endTopLevelDeclaration() | |
reportAllErrorTokens(class) | |
listener: endCompilationUnit(1, ) |