| parseUnit(class) | |
| skipErrorTokens(class) | |
| listener: beginCompilationUnit(class) | |
| syntheticPreviousToken(class) | |
| parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') | |
| parseMetadataStar() | |
| listener: beginMetadataStar(class) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(, class, null, Instance of 'DirectiveContext') | |
| parseClassOrNamedMixinApplication(null, null, null, class) | |
| listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class) | |
| ensureIdentifier(class, classOrMixinDeclaration) | |
| listener: handleIdentifier(WrapperClass, classOrMixinDeclaration) | |
| listener: handleNoTypeVariables({) | |
| listener: beginClassDeclaration(class, null, null, null, WrapperClass) | |
| parseClass(WrapperClass, class, class, WrapperClass) | |
| parseClassHeaderOpt(WrapperClass, class, class) | |
| parseClassExtendsOpt(WrapperClass) | |
| listener: handleNoType(WrapperClass) | |
| listener: handleClassExtends(null, 1) | |
| parseClassWithClauseOpt(WrapperClass) | |
| listener: handleClassNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(WrapperClass) | |
| listener: handleImplements(null, 0) | |
| listener: handleClassHeader(class, class, null) | |
| parseClassOrMixinOrExtensionBody(WrapperClass, DeclarationKind.Class, WrapperClass) | |
| listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {) | |
| notEofOrValue(}, int) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod({, null, null, null, null, null, null, null, {, Instance of 'SimpleType', null, abstract, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, abstract) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(abstract) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(abstract, methodDeclaration) | |
| parseQualifiedRestOpt(abstract, methodDeclarationContinuation) | |
| parseMethodTypeVar(abstract) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(abstract, abstract, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(abstract, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(abstract, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(abstract) | |
| parseArguments(abstract) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(abstract, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, as, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, as) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(as) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(as, methodDeclaration) | |
| parseQualifiedRestOpt(as, methodDeclarationContinuation) | |
| parseMethodTypeVar(as) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(as, as, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(as, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(as, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(as) | |
| parseArguments(as) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(as, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(assert) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, assert, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, async, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, async) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(async) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(async, methodDeclaration) | |
| parseQualifiedRestOpt(async, methodDeclarationContinuation) | |
| parseMethodTypeVar(async) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(async, async, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(async, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(async, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(async) | |
| parseArguments(async) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(async, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, await, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, await) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(await) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(await, methodDeclaration) | |
| parseQualifiedRestOpt(await, methodDeclarationContinuation) | |
| parseMethodTypeVar(await) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(await, await, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(await, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| inPlainSync() | |
| looksLikeAwaitExpression(return, AwaitOrYieldContext.UnaryExpression) | |
| looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression) | |
| parsePrimary(return, expression) | |
| inPlainSync() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(await, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(await) | |
| parseArguments(await) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(await, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(break) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, break, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {lexeme: break}], break, break) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(break) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(break) | |
| listener: handleSend(, break) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;) | |
| parseParenthesizedExpressionOrRecordLiteral(;) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(case) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, case, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(catch) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, catch, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(class) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, class, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(const) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, const, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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, ConstructorReferenceContext.Const, null) | |
| ensureIdentifier(const, constructorReference) | |
| insertSyntheticIdentifier(const, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], messageOnToken: null) | |
| reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}]) | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| rewriter() | |
| listener: handleIdentifier(, constructorReference) | |
| listener: beginConstructorReference() | |
| parseQualifiedRestOpt(, constructorReferenceContinuation) | |
| listener: handleNoTypeArguments(() | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(() | |
| listener: endConstructorReference(, null, (, ConstructorReferenceContext.Const) | |
| parseConstructorInvocationArguments() | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(continue) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, continue, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {lexeme: continue}], continue, continue) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(continue) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(continue) | |
| listener: handleSend(, continue) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;) | |
| parseParenthesizedExpressionOrRecordLiteral(;) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, covariant, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, covariant) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(covariant) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(covariant, methodDeclaration) | |
| parseQualifiedRestOpt(covariant, methodDeclarationContinuation) | |
| parseMethodTypeVar(covariant) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(covariant, covariant, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(covariant, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(covariant, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(covariant) | |
| parseArguments(covariant) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(covariant, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(default) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, default, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, deferred, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, deferred) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(deferred) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(deferred, methodDeclaration) | |
| parseQualifiedRestOpt(deferred, methodDeclarationContinuation) | |
| parseMethodTypeVar(deferred) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(deferred, deferred, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(deferred, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(deferred, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(deferred) | |
| parseArguments(deferred) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(deferred, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(do) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, do, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {lexeme: do}], do, do) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(do) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(do) | |
| listener: handleSend(, do) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do) | |
| parseParenthesizedExpressionOrRecordLiteral(do) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, }) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, dynamic, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, dynamic) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(dynamic) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(dynamic, methodDeclaration) | |
| parseQualifiedRestOpt(dynamic, methodDeclarationContinuation) | |
| parseMethodTypeVar(dynamic) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(dynamic, dynamic, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(dynamic, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(dynamic, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(dynamic) | |
| parseArguments(dynamic) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(dynamic, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(else) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, else, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(else) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(else) | |
| listener: handleSend(, else) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| isNextIdentifier(;) | |
| ensureIdentifier(;, expression) | |
| reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(else) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(else) | |
| listener: handleSend(, else) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| rewriter() | |
| listener: handleExpressionStatement(;) | |
| reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], 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) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else) | |
| parseParenthesizedExpressionOrRecordLiteral(else) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(enum) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, enum, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, export, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, export) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(export) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(export, methodDeclaration) | |
| parseQualifiedRestOpt(export, methodDeclarationContinuation) | |
| parseMethodTypeVar(export) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(export, export, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(export, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(export, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(export) | |
| parseArguments(export) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(export, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(extends) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, extends, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, extension, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, extension) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(extension) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(extension, methodDeclaration) | |
| parseQualifiedRestOpt(extension, methodDeclarationContinuation) | |
| parseMethodTypeVar(extension) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(extension, extension, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(extension, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(extension, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(extension) | |
| parseArguments(extension) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(extension, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, external, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, external) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(external) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(external, methodDeclaration) | |
| parseQualifiedRestOpt(external, methodDeclarationContinuation) | |
| parseMethodTypeVar(external) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(external, external, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(external, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(external, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(external) | |
| parseArguments(external) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(external, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, factory, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, factory) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(factory) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(factory, methodDeclaration) | |
| parseQualifiedRestOpt(factory, methodDeclarationContinuation) | |
| parseMethodTypeVar(factory) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(factory, factory, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(factory, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(factory, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(factory) | |
| parseArguments(factory) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(factory, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(false) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, false, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(final) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, final, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {lexeme: final}], final, final) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(final) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(final) | |
| listener: handleSend(, final) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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 '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| rewriter() | |
| listener: handleIdentifier(, localVariableDeclaration) | |
| listener: beginInitializedIdentifier() | |
| parseVariableInitializerOpt() | |
| listener: handleNoVariableInitializer() | |
| listener: endInitializedIdentifier() | |
| ensureSemicolon() | |
| reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, () | |
| 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) | |
| isNextIdentifier(;) | |
| 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) | |
| isNextIdentifier(;) | |
| ensureIdentifier(;, expression) | |
| reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), )) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments()) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments()) | |
| listener: handleSend(, )) | |
| ensureSemicolon() | |
| reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
| rewriter() | |
| listener: handleExpressionStatement(;) | |
| reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), )) | |
| 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) | |
| isNextIdentifier()) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(finally) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, finally, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(for) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, for, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., Try inserting an identifier before 'for'., {lexeme: for}], for, for) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(for) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(for) | |
| listener: handleSend(, for) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| isNextIdentifier(() | |
| 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) | |
| isNextIdentifier(;) | |
| ensureIdentifier(;, expression) | |
| reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), )) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments()) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments()) | |
| listener: handleSend(, )) | |
| ensureSemicolon() | |
| reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
| 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) | |
| isNextIdentifier()) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, Function, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, Function) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(Function) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(Function, methodDeclaration) | |
| parseQualifiedRestOpt(Function, methodDeclarationContinuation) | |
| parseMethodTypeVar(Function) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(Function, Function, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(Function, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(Function, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(Function) | |
| parseArguments(Function) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(Function, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, get, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, get) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(get) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(get, methodDeclaration) | |
| parseQualifiedRestOpt(get, methodDeclarationContinuation) | |
| parseMethodTypeVar(get) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(get, get, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(get, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(get, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(get) | |
| parseArguments(get) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(get, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, hide, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, hide) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(hide) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(hide, methodDeclaration) | |
| parseQualifiedRestOpt(hide, methodDeclarationContinuation) | |
| parseMethodTypeVar(hide) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(hide, hide, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(hide, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(hide, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(hide) | |
| parseArguments(hide) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(hide, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(if) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, if, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., Try inserting an identifier before 'if'., {lexeme: if}], if, if) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(if) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(if) | |
| listener: handleSend(, if) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| isNextIdentifier(() | |
| 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) | |
| isNextIdentifier()) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, implements, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, implements) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(implements) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(implements, methodDeclaration) | |
| parseQualifiedRestOpt(implements, methodDeclarationContinuation) | |
| parseMethodTypeVar(implements) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(implements, implements, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(implements, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(implements, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(implements) | |
| parseArguments(implements) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(implements, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, import, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, import) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(import) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(import, methodDeclaration) | |
| parseQualifiedRestOpt(import, methodDeclarationContinuation) | |
| parseMethodTypeVar(import) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(import, import, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(import, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(import, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(import) | |
| parseArguments(import) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(import, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(in) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, in, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, inout, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, inout) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(inout) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(inout, methodDeclaration) | |
| parseQualifiedRestOpt(inout, methodDeclarationContinuation) | |
| parseMethodTypeVar(inout) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(inout, inout, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(inout, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(inout, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(inout) | |
| parseArguments(inout) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(inout, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, interface, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, interface) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(interface) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(interface, methodDeclaration) | |
| parseQualifiedRestOpt(interface, methodDeclarationContinuation) | |
| parseMethodTypeVar(interface) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(interface, interface, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(interface, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(interface, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(interface) | |
| parseArguments(interface) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(interface, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(is) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, is, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(is) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(is) | |
| listener: handleSend(, is) | |
| parseIsOperatorRest() | |
| listener: beginIsOperatorType(is) | |
| computeTypeAfterIsOrAs(is) | |
| parseRecordType((, is) | |
| listener: beginRecordType(() | |
| parseRecordTypeField((, identifierIsOptional: true) | |
| listener: beginRecordTypeEntry() | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(x) | |
| listener: endMetadataStar(0) | |
| listener: handleIdentifier(x, typeReference) | |
| listener: handleNoTypeArguments(-) | |
| listener: handleType(x, null) | |
| listener: handleNoName(-) | |
| listener: endRecordTypeEntry() | |
| ensureCloseParen(x, () | |
| reportRecoverableError(-, Message[ExpectedButGot, Expected ')' before this., null, {string: )}]) | |
| listener: handleRecoverableError(Message[ExpectedButGot, Expected ')' before this., null, {string: )}], -, -) | |
| reportRecoverableError(), OnlyOneRecordTypeFieldsList) | |
| listener: handleRecoverableError(OnlyOneRecordTypeFieldsList, ), )) | |
| listener: endRecordType((, null, 1) | |
| 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) | |
| rewriteAndRecover(;, UnsupportedPrefixPlus, ) | |
| reportRecoverableError(+, UnsupportedPrefixPlus) | |
| listener: handleRecoverableError(UnsupportedPrefixPlus, +, +) | |
| rewriter() | |
| parsePrimary(;, expression) | |
| parseSendOrFunctionLiteral(;, expression) | |
| parseSend(;, expression) | |
| isNextIdentifier(;) | |
| 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(3, {, }) | |
| listener: endClassMethod(null, int, (, null, }) | |
| listener: endMember() | |
| notEofOrValue(}, int) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, late, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, late) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(late) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(late, methodDeclaration) | |
| parseQualifiedRestOpt(late, methodDeclarationContinuation) | |
| parseMethodTypeVar(late) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(late, late, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(late, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(late, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(late) | |
| parseArguments(late) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(late, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, library, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, library) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(library) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(library, methodDeclaration) | |
| parseQualifiedRestOpt(library, methodDeclarationContinuation) | |
| parseMethodTypeVar(library) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(library, library, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(library, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(library, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(library) | |
| parseArguments(library) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(library, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, mixin, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, mixin) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(mixin) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(mixin, methodDeclaration) | |
| parseQualifiedRestOpt(mixin, methodDeclarationContinuation) | |
| parseMethodTypeVar(mixin) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(mixin, mixin, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(mixin, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(mixin, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(mixin) | |
| parseArguments(mixin) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(mixin, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, native, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, native) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(native) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(native, methodDeclaration) | |
| parseQualifiedRestOpt(native, methodDeclarationContinuation) | |
| parseMethodTypeVar(native) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(native, native, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(native, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(native, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(native) | |
| parseArguments(native) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(native, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(new) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, new, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(new) | |
| listener: beginNewExpression(new) | |
| parseConstructorReference(new, ConstructorReferenceContext.New, null) | |
| ensureIdentifier(new, constructorReference) | |
| insertSyntheticIdentifier(new, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], messageOnToken: null) | |
| reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}]) | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| rewriter() | |
| listener: handleIdentifier(, constructorReference) | |
| listener: beginConstructorReference() | |
| parseQualifiedRestOpt(, constructorReferenceContinuation) | |
| listener: handleNoTypeArguments(() | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(() | |
| listener: endConstructorReference(, null, (, ConstructorReferenceContext.New) | |
| parseConstructorInvocationArguments() | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(null) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, null, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, of, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, of) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(of) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(of, methodDeclaration) | |
| parseQualifiedRestOpt(of, methodDeclarationContinuation) | |
| parseMethodTypeVar(of) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(of, of, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(of, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(of, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(of) | |
| parseArguments(of) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(of, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, on, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, on) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(on) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(on, methodDeclaration) | |
| parseQualifiedRestOpt(on, methodDeclarationContinuation) | |
| parseMethodTypeVar(on) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(on, on, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(on, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(on, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(on) | |
| parseArguments(on) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(on, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isUnaryMinus(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, operator, DeclarationKind.Class, WrapperClass, false) | |
| isUnaryMinus(() | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, operator) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(operator) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(operator, methodDeclaration) | |
| parseQualifiedRestOpt(operator, methodDeclarationContinuation) | |
| parseMethodTypeVar(operator) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(operator, operator, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(operator, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(operator, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(operator) | |
| parseArguments(operator) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(operator, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, out, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, out) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(out) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(out, methodDeclaration) | |
| parseQualifiedRestOpt(out, methodDeclarationContinuation) | |
| parseMethodTypeVar(out) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(out, out, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(out, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(out, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(out) | |
| parseArguments(out) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(out, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, part, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, part) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(part) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(part, methodDeclaration) | |
| parseQualifiedRestOpt(part, methodDeclarationContinuation) | |
| parseMethodTypeVar(part) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(part, part, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(part, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(part, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(part) | |
| parseArguments(part) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(part, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, patch, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, patch) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(patch) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(patch, methodDeclaration) | |
| parseQualifiedRestOpt(patch, methodDeclarationContinuation) | |
| parseMethodTypeVar(patch) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(patch, patch, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(patch, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(patch, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(patch) | |
| parseArguments(patch) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(patch, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, required, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, required) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(required) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(required, methodDeclaration) | |
| parseQualifiedRestOpt(required, methodDeclarationContinuation) | |
| parseMethodTypeVar(required) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(required, required, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(required, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(required, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(required) | |
| parseArguments(required) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(required, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(rethrow) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, rethrow, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(return) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, return, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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, {lexeme: return}], return, return) | |
| parsePrimary(return, expression) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return) | |
| parseParenthesizedExpressionOrRecordLiteral(return) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, set, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, set) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(set) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(set, methodDeclaration) | |
| parseQualifiedRestOpt(set, methodDeclarationContinuation) | |
| parseMethodTypeVar(set) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(set, set, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(set, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(set, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(set) | |
| parseArguments(set) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(set, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, show, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, show) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(show) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(show, methodDeclaration) | |
| parseQualifiedRestOpt(show, methodDeclarationContinuation) | |
| parseMethodTypeVar(show) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(show, show, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(show, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(show, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(show) | |
| parseArguments(show) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(show, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, source, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, source) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(source) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(source, methodDeclaration) | |
| parseQualifiedRestOpt(source, methodDeclarationContinuation) | |
| parseMethodTypeVar(source) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(source, source, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(source, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(source, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(source) | |
| parseArguments(source) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(source, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, static, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, static) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(static) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(static, methodDeclaration) | |
| parseQualifiedRestOpt(static, methodDeclarationContinuation) | |
| parseMethodTypeVar(static) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(static, static, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(static, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(static, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(static) | |
| parseArguments(static) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(static, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| recoverFromInvalidMember(int, }, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, DeclarationKind.Class, WrapperClass) | |
| parseFields(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', super, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginFields(DeclarationKind.Class, null, null, null, null, null, null, null, }) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(super) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false) | |
| reportRecoverableErrorWithToken(super, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super) | |
| listener: handleIdentifier(super, fieldDeclaration) | |
| parseFieldInitializerOpt(super, super, null, null, null, null, null, DeclarationKind.Class, WrapperClass) | |
| listener: handleNoFieldInitializer(() | |
| ensureSemicolon(super) | |
| reportRecoverableError(super, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], super, super) | |
| rewriter() | |
| listener: endClassFields(null, null, null, null, null, null, null, 1, int, ;) | |
| listener: endMember() | |
| notEofOrValue(}, () | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(;) | |
| listener: beginMetadataStar(() | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| recoverFromInvalidMember(;, ;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass) | |
| parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, () | |
| listener: handleNoType(;) | |
| ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false) | |
| insertSyntheticIdentifier(;, methodDeclaration, message: null, messageOnToken: null) | |
| reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}]) | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(() | |
| 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, , (, null, }) | |
| listener: endMember() | |
| notEofOrValue(}, int) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(switch) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, switch, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., Try inserting an identifier before 'switch'., {lexeme: switch}], switch, switch) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(switch) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(switch) | |
| listener: handleSend(, switch) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| isNextIdentifier(() | |
| 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) | |
| isNextIdentifier(}) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, sync, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, sync) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(sync) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(sync, methodDeclaration) | |
| parseQualifiedRestOpt(sync, methodDeclarationContinuation) | |
| parseMethodTypeVar(sync) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(sync, sync, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(sync, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(sync, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(sync) | |
| parseArguments(sync) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(sync, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| recoverFromInvalidMember(int, }, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, DeclarationKind.Class, WrapperClass) | |
| parseFields(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', this, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginFields(DeclarationKind.Class, null, null, null, null, null, null, null, }) | |
| 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[ExpectedIdentifierButGotKeyword, 'this' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: this}], this, this) | |
| listener: handleIdentifier(this, fieldDeclaration) | |
| parseFieldInitializerOpt(this, this, null, null, null, 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, null, null, null, 1, int, ;) | |
| listener: endMember() | |
| notEofOrValue(}, () | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(;) | |
| listener: beginMetadataStar(() | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| recoverFromInvalidMember(;, ;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, DeclarationKind.Class, WrapperClass) | |
| parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, (, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, () | |
| listener: handleNoType(;) | |
| ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false) | |
| insertSyntheticIdentifier(;, methodDeclaration, message: null, messageOnToken: null) | |
| reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}]) | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(throw) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, throw, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'throw' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw) | |
| parseParenthesizedExpressionOrRecordLiteral(throw) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(true) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, true, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'true' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(try) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, try, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'try' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., Try inserting an identifier before 'try'., {lexeme: try}], try, try) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(try) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(try) | |
| listener: handleSend(, try) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(}) | |
| parseParenthesizedExpressionOrRecordLiteral(}) | |
| listener: beginParenthesizedExpressionOrRecordLiteral(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| ensureCloseParen(1, () | |
| listener: endParenthesizedExpression(() | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, typedef, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, typedef) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(typedef) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(typedef, methodDeclaration) | |
| parseQualifiedRestOpt(typedef, methodDeclarationContinuation) | |
| parseMethodTypeVar(typedef) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(typedef, typedef, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(typedef, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(typedef, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(typedef) | |
| parseArguments(typedef) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(typedef, +) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(var) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, var, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'var' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., Try inserting an identifier before 'var'., {lexeme: var}], var, var) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(var) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(var) | |
| listener: handleSend(, var) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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 '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| rewriter() | |
| listener: handleIdentifier(, localVariableDeclaration) | |
| listener: beginInitializedIdentifier() | |
| parseVariableInitializerOpt() | |
| listener: handleNoVariableInitializer() | |
| listener: endInitializedIdentifier() | |
| ensureSemicolon() | |
| reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, () | |
| 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) | |
| isNextIdentifier(;) | |
| 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) | |
| isNextIdentifier(;) | |
| ensureIdentifier(;, expression) | |
| reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), )) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments()) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments()) | |
| listener: handleSend(, )) | |
| ensureSemicolon() | |
| reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
| rewriter() | |
| listener: handleExpressionStatement(;) | |
| reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), )) | |
| 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) | |
| isNextIdentifier()) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(void) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, void, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'void' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., Try inserting an identifier before 'void'., {lexeme: void}], void, void) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(void) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(void) | |
| listener: handleSend(, void) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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 '('., Try inserting an identifier before '('., {lexeme: (}], (, () | |
| rewriter() | |
| listener: handleIdentifier(, localVariableDeclaration) | |
| listener: beginInitializedIdentifier() | |
| parseVariableInitializerOpt() | |
| listener: handleNoVariableInitializer() | |
| listener: endInitializedIdentifier() | |
| ensureSemicolon() | |
| reportRecoverableError((, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, () | |
| 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) | |
| isNextIdentifier(;) | |
| 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) | |
| isNextIdentifier(;) | |
| ensureIdentifier(;, expression) | |
| reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), )) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments()) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments()) | |
| listener: handleSend(, )) | |
| ensureSemicolon() | |
| reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) | |
| rewriter() | |
| listener: handleExpressionStatement(;) | |
| reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), )) | |
| 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) | |
| isNextIdentifier()) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(while) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, while, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'while' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., Try inserting an identifier before 'while'., {lexeme: while}], while, while) | |
| rewriter() | |
| listener: handleIdentifier(, expression) | |
| listener: handleNoTypeArguments(while) | |
| parseArgumentsOpt() | |
| listener: handleNoArguments(while) | |
| listener: handleSend(, while) | |
| ensureSemicolon() | |
| reportRecoverableError(return, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}]) | |
| listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], return, return) | |
| 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) | |
| isNextIdentifier(() | |
| 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) | |
| isNextIdentifier()) | |
| 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) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| isReservedKeyword(with) | |
| indicatesMethodOrField(() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, with, DeclarationKind.Class, WrapperClass, true) | |
| listener: beginMethod(DeclarationKind.Class, null, 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[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: 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) | |
| isNextIdentifier(() | |
| 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(}, int) | |
| parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, WrapperClass) | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginMember() | |
| parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'SimpleType', null, yield, DeclarationKind.Class, WrapperClass, false) | |
| listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, yield) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(yield) | |
| listener: handleType(int, null) | |
| ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false) | |
| listener: handleIdentifier(yield, methodDeclaration) | |
| parseQualifiedRestOpt(yield, methodDeclarationContinuation) | |
| parseMethodTypeVar(yield) | |
| listener: handleNoTypeVariables(() | |
| parseGetterOrFormalParameters(yield, yield, false, MemberKind.NonStaticMethod) | |
| parseFormalParameters(yield, MemberKind.NonStaticMethod) | |
| parseFormalParametersRest((, MemberKind.NonStaticMethod) | |
| listener: beginFormalParameters((, MemberKind.NonStaticMethod) | |
| parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| parseMetadataStar(() | |
| listener: beginMetadataStar(int) | |
| listener: endMetadataStar(0) | |
| listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) | |
| listener: handleIdentifier(int, typeReference) | |
| listener: handleNoTypeArguments(x) | |
| listener: handleType(int, null) | |
| ensureIdentifier(int, formalParameterDeclaration) | |
| listener: handleIdentifier(x, formalParameterDeclaration) | |
| listener: handleFormalParameterWithoutValue()) | |
| listener: endFormalParameter(null, null, null, x, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod) | |
| listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod) | |
| parseInitializersOpt()) | |
| listener: handleNoInitializers() | |
| parseAsyncModifierOpt()) | |
| listener: handleAsyncModifier(null, null) | |
| inPlainSync() | |
| inPlainSync() | |
| parseFunctionBody(), false, true) | |
| listener: beginBlockFunctionBody({) | |
| notEofOrValue(}, if) | |
| parseStatement({) | |
| parseStatementX({) | |
| parseIfStatement({) | |
| listener: beginIfStatement(if) | |
| ensureParenthesizedCondition(if) | |
| parseExpressionInParenthesisRest(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(==) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(==) | |
| listener: handleSend(x, ==) | |
| listener: beginBinaryExpression(==) | |
| parsePrecedenceExpression(==, 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() | |
| parseSendOrFunctionLiteral(return, expression) | |
| looksLikeFunctionBody(+) | |
| parseSend(return, expression) | |
| isNextIdentifier(return) | |
| ensureIdentifier(return, expression) | |
| inPlainSync() | |
| listener: handleIdentifier(yield, expression) | |
| listener: handleNoTypeArguments(() | |
| parseArgumentsOpt(yield) | |
| parseArguments(yield) | |
| parseArgumentsRest(() | |
| listener: beginArguments(() | |
| parseExpression(() | |
| parsePrecedenceExpression((, 1, true) | |
| parseUnaryExpression((, true) | |
| parsePrimary((, expression) | |
| parseSendOrFunctionLiteral((, expression) | |
| parseSend((, expression) | |
| isNextIdentifier(() | |
| ensureIdentifier((, expression) | |
| listener: handleIdentifier(x, expression) | |
| listener: handleNoTypeArguments(-) | |
| parseArgumentsOpt(x) | |
| listener: handleNoArguments(-) | |
| listener: handleSend(x, -) | |
| listener: beginBinaryExpression(-) | |
| parsePrecedenceExpression(-, 14, true) | |
| parseUnaryExpression(-, true) | |
| parsePrimary(-, expression) | |
| parseLiteralInt(-) | |
| listener: handleLiteralInt(1) | |
| listener: endBinaryExpression(-) | |
| listener: endArguments(1, (, )) | |
| listener: handleSend(yield, +) | |
| 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: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 71, {, }) | |
| listener: endClassDeclaration(class, }) | |
| listener: endTopLevelDeclaration() | |
| reportAllErrorTokens(class) | |
| listener: endCompilationUnit(1, ) |