dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity
Files
e3e82c95cb3782515e5775bd8da170fd6771a723
sdk/pkg/front_end/parser_testcases/patterns/const_patterns.dart.intertwined.expect
T
Johnni Winther dced5e0482 [cfe] Add LocalTypeParameterScope 
This cleans up the LocalScope interface and the handling of named function expressions.

Change-Id: Id0432910a9e65d8ae966dfab67c66248639d241a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/419842
Reviewed-by: Chloe Stefantsova <cstefantsova@google.com>
Commit-Queue: Johnni Winther <johnniwinther@google.com>
2025-04-03 03:43:30 -07:00

3318 lines
249 KiB
Plaintext
Raw Blame History

parseUnit(import)
skipErrorTokens(import)
listener: beginCompilationUnit(import)
syntheticPreviousToken(import)
parseTopLevelDeclarationImpl(, DirectiveContext(DirectiveState.Unknown))
parseMetadataStar()
listener: beginMetadataStar(import)
listener: endMetadataStar(0)
parseTopLevelKeywordDeclaration(import, , import, null, null, null, null, DirectiveContext(DirectiveState.Unknown))
parseImport(import)
listener: beginUncategorizedTopLevelDeclaration(import)
listener: beginImport(import)
ensureLiteralString(import)
parseLiteralString(import)
parseSingleLiteralString(import)
listener: beginLiteralString('const_patterns.dart')
listener: endLiteralString(0, as)
parseConditionalUriStar('const_patterns.dart')
listener: beginConditionalUris(as)
listener: endConditionalUris(0)
parseImportPrefixOpt('const_patterns.dart')
ensureIdentifier(as, importPrefixDeclaration)
listener: handleIdentifier(prefix, importPrefixDeclaration)
listener: handleImportPrefix(null, as)
parseCombinatorStar(prefix)
listener: beginCombinators(;)
listener: endCombinators(0)
listener: endImport(import, null, ;)
listener: endTopLevelDeclaration(;)
parseTopLevelDeclarationImpl(;, DirectiveContext(DirectiveState.ImportAndExport))
parseMetadataStar(;)
listener: beginMetadataStar(const)
listener: endMetadataStar(0)
parseTopLevelMemberImpl(;)
listener: beginTopLevelMember(const)
skipOuterPattern(const)
skipObjectPatternRest(int)
parseFields(;, null, null, null, null, null, null, const, const, SimpleType(), value, DeclarationKind.TopLevel, null, false)
listener: beginFields(DeclarationKind.TopLevel, null, null, null, null, null, null, const, ;)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(value)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, topLevelVariableDeclaration, false)
listener: handleIdentifier(value, topLevelVariableDeclaration)
parseFieldInitializerOpt(value, value, null, null, null, null, const, DeclarationKind.TopLevel, null)
listener: beginFieldInitializer(=)
parseExpression(=)
looksLikeOuterPatternEquals(=)
skipOuterPattern(=)
parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
parseUnaryExpression(=, true, ConstantPatternContext.none)
parsePrimary(=, expression, ConstantPatternContext.none)
parseLiteralInt(=)
listener: handleLiteralInt(42)
listener: endFieldInitializer(=, 42)
listener: endTopLevelFields(null, null, null, null, null, const, 1, const, ;)
listener: endTopLevelDeclaration(;)
parseTopLevelDeclarationImpl(;, DirectiveContext(DirectiveState.Declarations))
parseMetadataStar(;)
listener: beginMetadataStar(void)
listener: endMetadataStar(0)
parseTopLevelMemberImpl(;)
listener: beginTopLevelMember(void)
parseTopLevelMethod(;, null, null, ;, VoidType(), null, func, false)
listener: beginTopLevelMethod(;, null, null)
listener: handleVoidKeyword(void)
ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
listener: handleIdentifier(func, topLevelFunctionDeclaration)
parseMethodTypeVar(func)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(func, func, false, MemberKind.TopLevelMethod)
parseFormalParameters(func, MemberKind.TopLevelMethod)
parseFormalParametersRest((, MemberKind.TopLevelMethod)
listener: beginFormalParameters((, MemberKind.TopLevelMethod)
listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
parseFunctionBody(), false, false)
listener: beginBlockFunctionBody({)
notEofOrValue(}, })
listener: endBlockFunctionBody(0, {, })
listener: endTopLevelMethod(void, null, })
listener: endTopLevelDeclaration(})
parseTopLevelDeclarationImpl(}, DirectiveContext(DirectiveState.Declarations))
parseMetadataStar(})
listener: beginMetadataStar(class)
listener: endMetadataStar(0)
parseTopLevelKeywordDeclaration(class, }, class, null, null, null, null, DirectiveContext(DirectiveState.Declarations))
parseClassOrNamedMixinApplication(class, null, null, null, null, null, null, null, null, class)
listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
ensureIdentifier(class, classOrMixinDeclaration)
listener: handleIdentifier(Class, classOrMixinDeclaration)
listener: handleNoTypeVariables({)
listener: beginClassDeclaration(class, null, null, null, null, null, null, null, null, Class)
parseClass(Class, class, class, Class)
parseClassHeaderOpt(Class, class, class)
parseClassExtendsOpt(Class, DeclarationHeaderKind.Class)
listener: handleNoType(Class)
listener: handleClassExtends(null, 1)
parseClassWithClauseOpt(Class)
listener: handleClassNoWithClause()
parseClassOrMixinOrEnumImplementsOpt(Class)
listener: handleImplements(null, 0)
listener: handleClassHeader(class, class, null)
parseClassOrMixinOrExtensionBody(Class, DeclarationKind.Class, Class)
listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
notEofOrValue(}, const)
parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Class)
parseMetadataStar({)
listener: beginMetadataStar(const)
listener: endMetadataStar(0)
listener: beginMember()
skipOuterPattern(const)
skipObjectPatternRest(Class)
parseMethod({, null, null, null, null, null, null, const, const, NoType(), null, Class, DeclarationKind.Class, Class, false)
listener: beginMethod(DeclarationKind.Class, null, null, null, null, const, null, Class, Class)
listener: handleNoType(const)
ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
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)
parseOptionalPositionalParameters((, MemberKind.NonStaticMethod)
listener: beginOptionalFormalParameters([)
parseFormalParameter([, FormalParameterKind.optionalPositional, MemberKind.NonStaticMethod)
parseMetadataStar([)
listener: beginMetadataStar(a)
listener: endMetadataStar(0)
listener: beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
listener: handleNoType([)
ensureIdentifier([, formalParameterDeclaration)
listener: handleIdentifier(a, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(])
listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalPositional, MemberKind.NonStaticMethod)
listener: endOptionalFormalParameters(1, [, ], MemberKind.NonStaticMethod)
ensureCloseParen(], ()
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: handleEmptyFunctionBody(;)
listener: endClassConstructor(null, const, (, null, ;)
listener: endMember()
notEofOrValue(}, const)
parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
parseMetadataStar(;)
listener: beginMetadataStar(const)
listener: endMetadataStar(0)
listener: beginMember()
skipOuterPattern(const)
skipObjectPatternRest(named)
parseMethod(;, null, null, null, null, null, null, const, const, NoType(), null, Class, DeclarationKind.Class, Class, false)
listener: beginMethod(DeclarationKind.Class, null, null, null, null, const, null, Class, Class)
listener: handleNoType(const)
ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
listener: handleIdentifier(Class, methodDeclaration)
parseQualifiedRestOpt(Class, methodDeclarationContinuation)
parseQualifiedRest(Class, methodDeclarationContinuation)
ensureIdentifier(., methodDeclarationContinuation)
listener: handleIdentifier(named, methodDeclarationContinuation)
listener: handleQualified(.)
parseMethodTypeVar(named)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(named, Class, false, MemberKind.NonStaticMethod)
parseFormalParameters(named, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: handleEmptyFunctionBody(;)
listener: endClassConstructor(null, const, (, null, ;)
listener: endMember()
notEofOrValue(}, call)
parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
parseMetadataStar(;)
listener: beginMetadataStar(call)
listener: endMetadataStar(0)
listener: beginMember()
isReservedKeyword(()
parseMethod(;, null, null, null, null, null, null, null, ;, NoType(), null, call, DeclarationKind.Class, Class, false)
listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, call, Class)
listener: handleNoType(;)
ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
listener: handleIdentifier(call, methodDeclaration)
parseQualifiedRestOpt(call, methodDeclarationContinuation)
parseMethodTypeVar(call)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(call, call, false, MemberKind.NonStaticMethod)
parseFormalParameters(call, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, })
listener: endBlockFunctionBody(0, {, })
listener: endClassMethod(null, call, (, null, })
listener: endMember()
notEofOrValue(}, test)
parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
parseMetadataStar(})
listener: beginMetadataStar(test)
listener: endMetadataStar(0)
listener: beginMember()
isReservedKeyword(()
parseMethod(}, null, null, null, null, null, null, null, }, NoType(), null, test, DeclarationKind.Class, Class, false)
listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, test, Class)
listener: handleNoType(})
ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
listener: handleIdentifier(test, methodDeclaration)
parseQualifiedRestOpt(test, methodDeclarationContinuation)
parseMethodTypeVar(test)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(test, test, false, MemberKind.NonStaticMethod)
parseFormalParameters(test, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(o)
listener: endMetadataStar(0)
listener: beginFormalParameter(o, MemberKind.NonStaticMethod, null, null, null)
listener: handleNoType(()
ensureIdentifier((, formalParameterDeclaration)
listener: handleIdentifier(o, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, null, o, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(async, null)
inPlainSync()
inPlainSync()
parseFunctionBody(async, false, false)
listener: beginBlockFunctionBody({)
notEofOrValue(}, const)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrConstDeclaration({)
parseExpressionStatementOrDeclarationAfterModifiers(const, {, null, const, SimpleType(), null)
looksLikeLocalFunction(local)
listener: beginMetadataStar(const)
listener: endMetadataStar(0)
listener: handleIdentifier(dynamic, typeReference)
listener: handleNoTypeArguments(local)
listener: handleType(dynamic, null)
listener: beginVariablesDeclaration(local, null, const)
parseVariablesDeclarationRest(dynamic, true)
parseOptionallyInitializedIdentifier(dynamic)
ensureIdentifier(dynamic, localVariableDeclaration)
listener: handleIdentifier(local, localVariableDeclaration)
listener: beginInitializedIdentifier(local)
parseVariableInitializerOpt(local)
listener: beginVariableInitializer(=)
parseExpression(=)
looksLikeOuterPatternEquals(=)
skipOuterPattern(=)
parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
parseUnaryExpression(=, true, ConstantPatternContext.none)
parsePrimary(=, expression, ConstantPatternContext.none)
parseLiteralInt(=)
listener: handleLiteralInt(0)
listener: endVariableInitializer(=)
listener: endInitializedIdentifier(local)
ensureSemicolon(0)
listener: endVariablesDeclaration(1, ;)
notEofOrValue(}, dynamic)
parseStatement(;)
parseStatementX(;)
parseExpressionStatementOrDeclaration(;, null)
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
looksLikeLocalFunction(variable)
listener: beginMetadataStar(dynamic)
listener: endMetadataStar(0)
listener: handleIdentifier(dynamic, typeReference)
listener: handleNoTypeArguments(variable)
listener: handleType(dynamic, null)
listener: beginVariablesDeclaration(variable, null, null)
parseVariablesDeclarationRest(dynamic, true)
parseOptionallyInitializedIdentifier(dynamic)
ensureIdentifier(dynamic, localVariableDeclaration)
listener: handleIdentifier(variable, localVariableDeclaration)
listener: beginInitializedIdentifier(variable)
parseVariableInitializerOpt(variable)
listener: beginVariableInitializer(=)
parseExpression(=)
looksLikeOuterPatternEquals(=)
skipOuterPattern(=)
parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
parseUnaryExpression(=, true, ConstantPatternContext.none)
parsePrimary(=, expression, ConstantPatternContext.none)
parseLiteralInt(=)
listener: handleLiteralInt(0)
listener: endVariableInitializer(=)
listener: endInitializedIdentifier(variable)
ensureSemicolon(0)
listener: endVariablesDeclaration(1, ;)
notEofOrValue(}, switch)
parseStatement(;)
parseStatementX(;)
parseSwitchStatement(;)
listener: beginSwitchStatement(switch)
ensureParenthesizedCondition(switch, allowCase: false)
parseExpressionInParenthesisRest((, allowCase: false)
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(o)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(o, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(o)
listener: handleNoArguments())
listener: handleSend(o, o)
ensureCloseParen(o, ()
listener: handleParenthesizedCondition((, null, null)
parseSwitchBlock())
ensureBlock(), BlockKind(switch statement))
listener: beginSwitchBlock({)
notEofOrValue(}, case)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralBool(case)
listener: handleLiteralBool(true)
listener: endConstantPattern(null)
listener: endPattern(true)
listener: handleSwitchCaseNoWhenClause(true)
ensureColon(true)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralNull(case)
listener: handleLiteralNull(null)
listener: endConstantPattern(null)
listener: endPattern(null)
listener: handleSwitchCaseNoWhenClause(null)
ensureColon(null)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseThisExpression(case, expression)
listener: handleThisExpression(this, expression)
listener: endConstantPattern(null)
listener: endPattern(this)
listener: handleSwitchCaseNoWhenClause(this)
ensureColon(this)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseThisExpression(case, expression)
listener: handleThisExpression(this, expression)
listener: handleNoTypeArguments(()
parseArguments(this)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: handleSend(this, ))
listener: endConstantPattern(null)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSuperExpression(case, expression)
listener: handleSuperExpression(super, expression)
listener: handleNoTypeArguments(()
parseArguments(super)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: handleSend(super, ))
listener: endConstantPattern(null)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralInt(case)
listener: handleLiteralInt(42)
listener: endConstantPattern(null)
listener: endPattern(42)
listener: handleSwitchCaseNoWhenClause(42)
ensureColon(42)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
parseLiteralInt(-)
listener: handleLiteralInt(42)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(null)
listener: endPattern(42)
listener: handleSwitchCaseNoWhenClause(42)
ensureColon(42)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralDouble(case)
listener: handleLiteralDouble(42.5)
listener: endConstantPattern(null)
listener: endPattern(42.5)
listener: handleSwitchCaseNoWhenClause(42.5)
ensureColon(42.5)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
parseLiteralDouble(-)
listener: handleLiteralDouble(42.5)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(null)
listener: endPattern(42.5)
listener: handleSwitchCaseNoWhenClause(42.5)
ensureColon(42.5)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralString(case)
parseSingleLiteralString(case)
listener: beginLiteralString('foo')
listener: endLiteralString(0, :)
listener: endConstantPattern(null)
listener: endPattern('foo')
listener: handleSwitchCaseNoWhenClause('foo')
ensureColon('foo')
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralString(case)
parseSingleLiteralString(case)
listener: beginLiteralString('foo')
listener: endLiteralString(0, 'bar')
parseSingleLiteralString('foo')
listener: beginLiteralString('bar')
listener: endLiteralString(0, :)
listener: handleAdjacentStringLiterals(case, 2)
listener: endConstantPattern(null)
listener: endPattern('bar')
listener: handleSwitchCaseNoWhenClause('bar')
ensureColon('bar')
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: endConstantPattern(null)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments(!)
parseArgumentsOpt(value)
listener: handleNoArguments(!)
listener: handleSend(value, value)
listener: endConstantPattern(null)
listener: handleNullAssertPattern(!)
listener: endPattern(!)
listener: handleSwitchCaseNoWhenClause(!)
ensureColon(!)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments(?)
parseArgumentsOpt(value)
listener: handleNoArguments(?)
listener: handleSend(value, value)
listener: endConstantPattern(null)
listener: handleNullCheckPattern(?)
listener: endPattern(?)
listener: handleSwitchCaseNoWhenClause(?)
ensureColon(?)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments(as)
parseArgumentsOpt(value)
listener: handleNoArguments(as)
listener: handleSend(value, value)
listener: endConstantPattern(null)
listener: beginAsOperatorType(as)
computeTypeAfterIsOrAs(as)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(:)
listener: handleType(int, null)
listener: endAsOperatorType(as)
listener: handleCastPattern(as)
listener: endPattern(int)
listener: handleSwitchCaseNoWhenClause(int)
ensureColon(int)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
reportRecoverableError(value, InvalidConstantPatternNegation)
listener: handleRecoverableError(InvalidConstantPatternNegation, value, value)
parseSendOrFunctionLiteral(-, expression, ConstantPatternContext.numericLiteralOnly)
parseSend(-, expression, ConstantPatternContext.numericLiteralOnly)
isNextIdentifier(-)
ensureIdentifier(-, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(null)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(local, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(local)
listener: handleNoArguments(:)
listener: handleSend(local, local)
listener: endConstantPattern(null)
listener: endPattern(local)
listener: handleSwitchCaseNoWhenClause(local)
ensureColon(local)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
reportRecoverableError(local, InvalidConstantPatternNegation)
listener: handleRecoverableError(InvalidConstantPatternNegation, local, local)
parseSendOrFunctionLiteral(-, expression, ConstantPatternContext.numericLiteralOnly)
parseSend(-, expression, ConstantPatternContext.numericLiteralOnly)
isNextIdentifier(-)
ensureIdentifier(-, expression)
listener: handleIdentifier(local, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(local)
listener: handleNoArguments(:)
listener: handleSend(local, local)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(null)
listener: endPattern(local)
listener: handleSwitchCaseNoWhenClause(local)
ensureColon(local)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(func, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(func)
listener: handleNoArguments(:)
listener: handleSend(func, func)
listener: endConstantPattern(null)
listener: endPattern(func)
listener: handleSwitchCaseNoWhenClause(func)
ensureColon(func)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(value, expressionContinuation)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: handleEndingBinaryExpression(., value)
listener: endConstantPattern(null)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
reportRecoverableError(prefix, InvalidConstantPatternNegation)
listener: handleRecoverableError(InvalidConstantPatternNegation, prefix, prefix)
parseSendOrFunctionLiteral(-, expression, ConstantPatternContext.numericLiteralOnly)
parseSend(-, expression, ConstantPatternContext.numericLiteralOnly)
isNextIdentifier(-)
ensureIdentifier(-, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.numericLiteralOnly)
reportRecoverableError(value, InvalidConstantPatternNegation)
listener: handleRecoverableError(InvalidConstantPatternNegation, value, value)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.numericLiteralOnly)
parseSend(., expressionContinuation, ConstantPatternContext.numericLiteralOnly)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(value, expressionContinuation)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: handleEndingBinaryExpression(., value)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(null)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(Class, expressionContinuation)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(Class)
listener: handleNoArguments(.)
listener: handleSend(Class, Class)
listener: handleEndingBinaryExpression(., Class)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(named, expressionContinuation)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(named)
listener: handleNoArguments(:)
listener: handleSend(named, named)
listener: handleEndingBinaryExpression(., named)
listener: endConstantPattern(null)
listener: endPattern(named)
listener: handleSwitchCaseNoWhenClause(named)
ensureColon(named)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralInt(case)
listener: handleLiteralInt(1)
reportRecoverableError(+, Message[InvalidConstantPatternBinary, The binary operator + is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: +}])
listener: handleRecoverableError(Message[InvalidConstantPatternBinary, The binary operator + is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: +}], +, +)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, false, ConstantPatternContext.none)
parseUnaryExpression(+, false, ConstantPatternContext.none)
parsePrimary(+, expression, ConstantPatternContext.none)
parseLiteralInt(+)
listener: handleLiteralInt(2)
listener: endBinaryExpression(+, 2)
listener: endConstantPattern(null)
listener: endPattern(2)
listener: handleSwitchCaseNoWhenClause(2)
ensureColon(2)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseLiteralInt(case)
listener: handleLiteralInt(1)
reportRecoverableError(*, Message[InvalidConstantPatternBinary, The binary operator * is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: *}])
listener: handleRecoverableError(Message[InvalidConstantPatternBinary, The binary operator * is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: *}], *, *)
listener: beginBinaryExpression(*)
parsePrecedenceExpression(*, 15, false, ConstantPatternContext.none)
parseUnaryExpression(*, false, ConstantPatternContext.none)
parsePrimary(*, expression, ConstantPatternContext.none)
parseLiteralInt(*)
listener: handleLiteralInt(2)
listener: endBinaryExpression(*, 2)
listener: endConstantPattern(null)
listener: endPattern(2)
listener: handleSwitchCaseNoWhenClause(2)
ensureColon(2)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
parseVariablePattern(case, PatternContext.matching, typeInfo: VoidType())
listener: handleVoidKeyword(void)
listener: handleDeclaredVariablePattern(null, fun, false)
listener: endPattern(fun)
listener: handleSwitchCaseNoWhenClause(fun)
ensureColon(fun)
rewriteAndRecover(fun, Message[ExpectedButGot, Expected ':' before this., null, {string: :}], :)
reportRecoverableError((, Message[ExpectedButGot, Expected ':' before this., null, {string: :}])
listener: handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], (, ()
rewriter()
listener: endCaseExpression(case, null, :)
peekPastLabels(()
parseStatementsInSwitchCase(:, (, case, 0, 25, null, null)
listener: beginSwitchCase(0, 25, case)
parseStatement(:)
parseStatementX(:)
parseExpressionStatementOrDeclaration(:, null)
parseExpressionStatementOrDeclarationAfterModifiers(:, :, null, null, null, null)
looksLikeLocalFunction(()
parseExpressionStatement(:)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
listener: handleNoTypeVariables(()
parseFunctionExpression(:)
listener: beginFunctionExpression(()
parseFormalParametersRequiredOpt(:, MemberKind.Local)
parseFormalParametersRest((, MemberKind.Local)
listener: beginFormalParameters((, MemberKind.Local)
listener: endFormalParameters(0, (, ), MemberKind.Local)
parseAsyncOptBody(), true, false)
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
parseFunctionBody(), true, false)
listener: beginBlockFunctionBody({)
notEofOrValue(}, })
listener: endBlockFunctionBody(0, {, })
listener: endFunctionExpression((, })
ensureSemicolon(})
reportRecoverableError(}, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
rewriter()
listener: handleExpressionStatement((, ;)
peekPastLabels(:)
parseStatement(;)
parseStatementX(;)
parseExpressionStatementOrDeclaration(;, null)
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
looksLikeLocalFunction(:)
parseExpressionStatement(;)
parseExpression(;)
looksLikeOuterPatternEquals(;)
skipOuterPattern(;)
parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
parseUnaryExpression(;, true, ConstantPatternContext.none)
parsePrimary(;, expression, ConstantPatternContext.none)
parseSend(;, expression, ConstantPatternContext.none)
isNextIdentifier(;)
ensureIdentifier(;, expression)
reportRecoverableErrorWithToken(:, Template(ExpectedIdentifier))
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(}, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
rewriter()
listener: handleExpressionStatement(:, ;)
reportRecoverableError(:, Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}])
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
peekPastLabels(case)
listener: endSwitchCase(0, 25, null, null, 2, case, :)
notEofOrValue(}, case)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
inPlainSync()
parseAssert(case, Assert.Expression)
listener: beginAssert(assert, Assert.Expression)
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralBool(()
listener: handleLiteralBool(false)
reportRecoverableError(assert, AssertAsExpression)
listener: handleRecoverableError(AssertAsExpression, assert, assert)
listener: endAssert(assert, Assert.Expression, (, null, ))
listener: endConstantPattern(null)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
inPlainSync()
parseSwitchExpression(case)
listener: beginSwitchExpression(switch)
ensureParenthesizedCondition(switch, allowCase: false)
parseExpressionInParenthesisRest((, allowCase: false)
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(o)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(o, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(o)
listener: handleNoArguments())
listener: handleSend(o, o)
ensureCloseParen(o, ()
listener: handleParenthesizedCondition((, null, null)
ensureBlock(), BlockKind(switch expression))
listener: beginSwitchExpressionBlock({)
listener: beginSwitchExpressionCase()
parsePattern({, PatternContext.matching, precedence: 1)
listener: beginPattern({)
parsePrimaryPattern({, PatternContext.matching)
parseVariablePattern({, PatternContext.matching, typeInfo: NoType())
listener: handleNoType(_)
listener: handleWildcardPattern(null, _)
listener: endPattern(_)
listener: handleSwitchExpressionCasePattern(_)
ensureFunctionArrow(_)
parseExpression(=>)
looksLikeOuterPatternEquals(=>)
skipOuterPattern(=>)
parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
parseUnaryExpression(=>, true, ConstantPatternContext.none)
parsePrimary(=>, expression, ConstantPatternContext.none)
parseLiteralBool(=>)
listener: handleLiteralBool(true)
listener: endSwitchExpressionCase(_, null, =>, true)
listener: endSwitchExpressionBlock(1, {, })
listener: endSwitchExpression(switch, })
listener: endConstantPattern(null)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
inPlainSync()
parseAwaitExpression(case, false)
listener: beginAwaitExpression(await)
parsePrecedenceExpression(await, 16, false, ConstantPatternContext.none)
parseUnaryExpression(await, false, ConstantPatternContext.none)
parsePrimary(await, expression, ConstantPatternContext.none)
parseLiteralInt(await)
listener: handleLiteralInt(0)
inAsync()
listener: endAwaitExpression(await, 0)
listener: endConstantPattern(null)
listener: endPattern(0)
listener: handleSwitchCaseNoWhenClause(0)
ensureColon(0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
reportRecoverableError(!, Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}])
listener: handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}], !, !)
parsePrecedenceExpression(!, 16, false, ConstantPatternContext.none)
parseUnaryExpression(!, false, ConstantPatternContext.none)
parsePrimary(!, expression, ConstantPatternContext.none)
parseLiteralBool(!)
listener: handleLiteralBool(false)
listener: handleUnaryPrefixExpression(!)
listener: endConstantPattern(null)
listener: endPattern(false)
listener: handleSwitchCaseNoWhenClause(false)
ensureColon(false)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
reportRecoverableError(~, Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}])
listener: handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}], ~, ~)
parsePrecedenceExpression(~, 16, false, ConstantPatternContext.none)
parseUnaryExpression(~, false, ConstantPatternContext.none)
parsePrimary(~, expression, ConstantPatternContext.none)
parseLiteralInt(~)
listener: handleLiteralInt(0)
listener: handleUnaryPrefixExpression(~)
listener: endConstantPattern(null)
listener: endPattern(0)
listener: handleSwitchCaseNoWhenClause(0)
ensureColon(0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrecedenceExpression(++, 16, false, ConstantPatternContext.none)
parseUnaryExpression(++, false, ConstantPatternContext.none)
parsePrimary(++, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral(++, expression, ConstantPatternContext.none)
parseSend(++, expression, ConstantPatternContext.none)
isNextIdentifier(++)
ensureIdentifier(++, expression)
listener: handleIdentifier(variable, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(variable)
listener: handleNoArguments(:)
listener: handleSend(variable, variable)
listener: handleUnaryPrefixAssignmentExpression(++)
listener: endConstantPattern(null)
listener: endPattern(variable)
listener: handleSwitchCaseNoWhenClause(variable)
ensureColon(variable)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(0, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 0, 0)
parseLiteralInt(const)
listener: handleLiteralInt(0)
listener: endConstantPattern(const)
listener: endPattern(0)
listener: handleSwitchCaseNoWhenClause(0)
ensureColon(0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(0x0, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 0x0, 0x0)
parseLiteralInt(const)
listener: handleLiteralInt(0x0)
listener: endConstantPattern(const)
listener: endPattern(0x0)
listener: handleSwitchCaseNoWhenClause(0x0)
ensureColon(0x0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(0.5, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 0.5, 0.5)
parseLiteralDouble(const)
listener: handleLiteralDouble(0.5)
listener: endConstantPattern(const)
listener: endPattern(0.5)
listener: handleSwitchCaseNoWhenClause(0.5)
ensureColon(0.5)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(true, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, true, true)
parseLiteralBool(const)
listener: handleLiteralBool(true)
listener: endConstantPattern(const)
listener: endPattern(true)
listener: handleSwitchCaseNoWhenClause(true)
ensureColon(true)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(null, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, null, null)
parseLiteralNull(const)
listener: handleLiteralNull(null)
listener: endConstantPattern(const)
listener: endPattern(null)
listener: handleSwitchCaseNoWhenClause(null)
ensureColon(null)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
reportRecoverableError(-, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, -, -)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.none)
parseUnaryExpression(-, false, ConstantPatternContext.none)
parsePrimary(-, expression, ConstantPatternContext.none)
parseLiteralInt(-)
listener: handleLiteralInt(0)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(const)
listener: endPattern(0)
listener: handleSwitchCaseNoWhenClause(0)
ensureColon(0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError('foo', InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 'foo', 'foo')
parseLiteralString(const)
parseSingleLiteralString(const)
listener: beginLiteralString('foo')
listener: endLiteralString(0, :)
listener: endConstantPattern(const)
listener: endPattern('foo')
listener: handleSwitchCaseNoWhenClause('foo')
ensureColon('foo')
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(#, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, #, #)
parseLiteralSymbol(const)
listener: beginLiteralSymbol(#)
ensureIdentifier(#, literalSymbol)
listener: handleIdentifier(a, literalSymbol)
listener: endLiteralSymbol(#, 1)
listener: endConstantPattern(const)
listener: endPattern(a)
listener: handleSwitchCaseNoWhenClause(a)
ensureColon(a)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments(:)
reportRecoverableError(value, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, value, value)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: endConstantPattern(const)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(local, expression)
listener: handleNoTypeArguments(:)
reportRecoverableError(local, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, local, local)
parseArgumentsOpt(local)
listener: handleNoArguments(:)
listener: handleSend(local, local)
listener: endConstantPattern(const)
listener: endPattern(local)
listener: handleSwitchCaseNoWhenClause(local)
ensureColon(local)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.explicit)
parseSend(., expressionContinuation, ConstantPatternContext.explicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(value, expressionContinuation)
listener: handleNoTypeArguments(:)
reportRecoverableError(value, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, value, value)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: handleEndingBinaryExpression(., value)
listener: endConstantPattern(const)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
reportRecoverableError(-, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, -, -)
parsePrecedenceExpression(-, 16, false, ConstantPatternContext.none)
parseUnaryExpression(-, false, ConstantPatternContext.none)
parsePrimary(-, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral(-, expression, ConstantPatternContext.none)
parseSend(-, expression, ConstantPatternContext.none)
isNextIdentifier(-)
ensureIdentifier(-, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.none)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
parseSend(., expressionContinuation, ConstantPatternContext.none)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(value, expressionContinuation)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(value)
listener: handleNoArguments(:)
listener: handleSend(value, value)
listener: handleEndingBinaryExpression(., value)
listener: handleUnaryPrefixExpression(-)
listener: endConstantPattern(const)
listener: endPattern(value)
listener: handleSwitchCaseNoWhenClause(value)
ensureColon(value)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.explicit)
parseSend(., expressionContinuation, ConstantPatternContext.explicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(Class, expressionContinuation)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(Class)
listener: handleNoArguments(.)
listener: handleSend(Class, Class)
listener: handleEndingBinaryExpression(., Class)
parsePrimary(., expressionContinuation, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.explicit)
parseSend(., expressionContinuation, ConstantPatternContext.explicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(named, expressionContinuation)
listener: handleNoTypeArguments(:)
reportRecoverableError(named, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, named, named)
parseArgumentsOpt(named)
listener: handleNoArguments(:)
listener: handleSend(named, named)
listener: handleEndingBinaryExpression(., named)
listener: endConstantPattern(const)
listener: endPattern(named)
listener: handleSwitchCaseNoWhenClause(named)
ensureColon(named)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
parseLiteralInt(const)
listener: handleLiteralInt(1)
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, false, ConstantPatternContext.none)
parseUnaryExpression(+, false, ConstantPatternContext.none)
parsePrimary(+, expression, ConstantPatternContext.none)
parseLiteralInt(+)
listener: handleLiteralInt(2)
listener: endBinaryExpression(+, 2)
listener: endConstantPattern(const)
listener: endPattern(2)
listener: handleSwitchCaseNoWhenClause(2)
ensureColon(2)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody({)
parseFunctionLiteral(const, void, fun, VoidType(), NoTypeParamOrArg(), expression)
listener: handleNoTypeVariables(()
listener: beginNamedFunctionExpression(void)
listener: handleVoidKeyword(void)
parseNamedFunctionRest(void, void, fun, true)
listener: beginFunctionName(fun)
ensureIdentifier(void, localFunctionDeclaration)
listener: handleIdentifier(fun, localFunctionDeclaration)
reportRecoverableError(fun, NamedFunctionExpression)
listener: handleRecoverableError(NamedFunctionExpression, fun, fun)
listener: endFunctionName(void, (, true)
parseFormalParametersRequiredOpt(fun, MemberKind.Local)
parseFormalParametersRest((, MemberKind.Local)
listener: beginFormalParameters((, MemberKind.Local)
listener: endFormalParameters(0, (, ), MemberKind.Local)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncOptBody(), true, false)
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
parseFunctionBody(), true, false)
listener: beginBlockFunctionBody({)
notEofOrValue(}, })
listener: endBlockFunctionBody(0, {, })
listener: endNamedFunctionExpression(})
listener: endConstantPattern(const)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
inPlainSync()
parseAssert(const, Assert.Expression)
listener: beginAssert(assert, Assert.Expression)
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralBool(()
listener: handleLiteralBool(false)
reportRecoverableError(assert, AssertAsExpression)
listener: handleRecoverableError(AssertAsExpression, assert, assert)
listener: endAssert(assert, Assert.Expression, (, null, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
inPlainSync()
parseSwitchExpression(const)
listener: beginSwitchExpression(switch)
ensureParenthesizedCondition(switch, allowCase: false)
parseExpressionInParenthesisRest((, allowCase: false)
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(o)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(o, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(o)
listener: handleNoArguments())
listener: handleSend(o, o)
ensureCloseParen(o, ()
listener: handleParenthesizedCondition((, null, null)
ensureBlock(), BlockKind(switch expression))
listener: beginSwitchExpressionBlock({)
listener: beginSwitchExpressionCase()
parsePattern({, PatternContext.matching, precedence: 1)
listener: beginPattern({)
parsePrimaryPattern({, PatternContext.matching)
parseVariablePattern({, PatternContext.matching, typeInfo: NoType())
listener: handleNoType(_)
listener: handleWildcardPattern(null, _)
listener: endPattern(_)
listener: handleSwitchExpressionCasePattern(_)
ensureFunctionArrow(_)
parseExpression(=>)
looksLikeOuterPatternEquals(=>)
skipOuterPattern(=>)
parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
parseUnaryExpression(=>, true, ConstantPatternContext.none)
parsePrimary(=>, expression, ConstantPatternContext.none)
parseLiteralBool(=>)
listener: handleLiteralBool(true)
listener: endSwitchExpressionCase(_, null, =>, true)
listener: endSwitchExpressionBlock(1, {, })
listener: endSwitchExpression(switch, })
listener: endConstantPattern(const)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
inPlainSync()
parseAwaitExpression(const, false)
listener: beginAwaitExpression(await)
parsePrecedenceExpression(await, 16, false, ConstantPatternContext.none)
parseUnaryExpression(await, false, ConstantPatternContext.none)
parsePrimary(await, expression, ConstantPatternContext.none)
parseLiteralInt(await)
listener: handleLiteralInt(0)
inAsync()
listener: endAwaitExpression(await, 0)
listener: endConstantPattern(const)
listener: endPattern(0)
listener: handleSwitchCaseNoWhenClause(0)
ensureColon(0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
reportRecoverableError(!, Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}])
listener: handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}], !, !)
parsePrecedenceExpression(!, 16, false, ConstantPatternContext.none)
parseUnaryExpression(!, false, ConstantPatternContext.none)
parsePrimary(!, expression, ConstantPatternContext.none)
parseLiteralBool(!)
listener: handleLiteralBool(false)
listener: handleUnaryPrefixExpression(!)
listener: endConstantPattern(const)
listener: endPattern(false)
listener: handleSwitchCaseNoWhenClause(false)
ensureColon(false)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
reportRecoverableError(~, Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}])
listener: handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}], ~, ~)
parsePrecedenceExpression(~, 16, false, ConstantPatternContext.none)
parseUnaryExpression(~, false, ConstantPatternContext.none)
parsePrimary(~, expression, ConstantPatternContext.none)
parseLiteralInt(~)
listener: handleLiteralInt(0)
listener: handleUnaryPrefixExpression(~)
listener: endConstantPattern(const)
listener: endPattern(0)
listener: handleSwitchCaseNoWhenClause(0)
ensureColon(0)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrecedenceExpression(++, 16, false, ConstantPatternContext.none)
parseUnaryExpression(++, false, ConstantPatternContext.none)
parsePrimary(++, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral(++, expression, ConstantPatternContext.none)
parseSend(++, expression, ConstantPatternContext.none)
isNextIdentifier(++)
ensureIdentifier(++, expression)
listener: handleIdentifier(variable, expression)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(variable)
listener: handleNoArguments(:)
listener: handleSend(variable, variable)
listener: handleUnaryPrefixAssignmentExpression(++)
listener: endConstantPattern(const)
listener: endPattern(variable)
listener: handleSwitchCaseNoWhenClause(variable)
ensureColon(variable)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody(:)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(Class, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(Class)
parseArguments(Class)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: handleSend(Class, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody(:)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(Class, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(Class)
parseArguments(Class)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralInt(()
listener: handleLiteralInt(0)
listener: endArguments(1, (, ))
listener: handleSend(Class, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody(:)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(GenericClass)
parseArguments(GenericClass)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: handleSend(GenericClass, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody(:)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(GenericClass)
parseArguments(GenericClass)
parseArgumentsRest(()
listener: beginArguments(()
ensureIdentifier((, namedArgumentReference)
listener: handleIdentifier(a, namedArgumentReference)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseLiteralInt(:)
listener: handleLiteralInt(0)
listener: handleNamedArgument(:)
listener: endArguments(1, (, ))
listener: handleSend(GenericClass, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody(:)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(GenericClass, expression)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
parseArgumentsOpt(>)
parseArguments(>)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: handleSend(GenericClass, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
looksLikeFunctionBody(:)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(GenericClass, expression)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
parseArgumentsOpt(>)
parseArguments(>)
parseArgumentsRest(()
listener: beginArguments(()
ensureIdentifier((, namedArgumentReference)
listener: handleIdentifier(a, namedArgumentReference)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseLiteralInt(:)
listener: handleLiteralInt(0)
listener: handleNamedArgument(:)
listener: endArguments(1, (, ))
listener: handleSend(GenericClass, ))
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parseImplicitCreationExpression(const, <, SimpleTypeArgument1())
listener: beginImplicitCreationExpression(GenericClass)
parseConstructorReference(const, ConstructorReferenceContext.Implicit, SimpleTypeArgument1())
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(GenericClass, constructorReference)
listener: beginConstructorReference(GenericClass)
parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
ensureIdentifier(., constructorReferenceContinuationAfterTypeArguments)
rewriter()
listener: handleNewAsIdentifier(new)
listener: handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
listener: endConstructorReference(GenericClass, ., new, ConstructorReferenceContext.Implicit)
parseConstructorInvocationArguments(new)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: endImplicitCreationExpression(GenericClass, <)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parseImplicitCreationExpression(const, <, SimpleTypeArgument1())
listener: beginImplicitCreationExpression(GenericClass)
parseConstructorReference(const, ConstructorReferenceContext.Implicit, SimpleTypeArgument1())
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(GenericClass, constructorReference)
listener: beginConstructorReference(GenericClass)
parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
ensureIdentifier(., constructorReferenceContinuationAfterTypeArguments)
rewriter()
listener: handleNewAsIdentifier(new)
listener: handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
listener: endConstructorReference(GenericClass, ., new, ConstructorReferenceContext.Implicit)
parseConstructorInvocationArguments(new)
parseArgumentsRest(()
listener: beginArguments(()
ensureIdentifier((, namedArgumentReference)
listener: handleIdentifier(a, namedArgumentReference)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseLiteralInt(:)
listener: handleLiteralInt(1)
listener: handleNamedArgument(:)
listener: endArguments(1, (, ))
listener: endImplicitCreationExpression(GenericClass, <)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
listener: handleNoTypeArguments([])
parseLiteralListSuffix(const, null)
rewriteSquareBrackets(const)
link([, ])
rewriter()
listener: handleLiteralList(0, [, null, ])
listener: endConstantPattern(const)
listener: endPattern(])
listener: handleSwitchCaseNoWhenClause(])
ensureColon(])
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseLiteralListSetMapOrFunction(const, null)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
parseLiteralListSuffix(>, null)
rewriteSquareBrackets(>)
link([, ])
rewriter()
listener: handleLiteralList(0, [, null, ])
listener: endConstantPattern(const)
listener: endPattern(])
listener: handleSwitchCaseNoWhenClause(])
ensureColon(])
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
listener: handleNoTypeArguments({)
parseLiteralSetOrMapSuffix(const, null)
listener: handleLiteralSetOrMap(0, {, null, }, false)
listener: endConstantPattern(const)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseLiteralListSetMapOrFunction(const, null)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(,)
listener: handleType(int, null)
listener: handleIdentifier(String, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(String, null)
listener: endTypeArguments(2, <, >)
parseLiteralSetOrMapSuffix(>, null)
listener: handleLiteralSetOrMap(0, {, null, }, false)
listener: endConstantPattern(const)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstExpression(const)
parseConstructorReference(const, ConstructorReferenceContext.Const, null)
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(Class, constructorReference)
listener: beginConstructorReference(Class)
parseQualifiedRestOpt(Class, constructorReferenceContinuation)
listener: handleNoTypeArguments(()
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
listener: endConstructorReference(Class, null, Class, ConstructorReferenceContext.Const)
parseConstructorInvocationArguments(Class)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: endConstExpression(const)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstExpression(const)
parseConstructorReference(const, ConstructorReferenceContext.Const, null)
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(Class, constructorReference)
listener: beginConstructorReference(Class)
parseQualifiedRestOpt(Class, constructorReferenceContinuation)
listener: handleNoTypeArguments(()
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
listener: endConstructorReference(Class, null, Class, ConstructorReferenceContext.Const)
parseConstructorInvocationArguments(Class)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralInt(()
listener: handleLiteralInt(0)
listener: endArguments(1, (, ))
listener: endConstExpression(const)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstExpression(const)
parseConstructorReference(const, ConstructorReferenceContext.Const, null)
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(GenericClass, constructorReference)
listener: beginConstructorReference(GenericClass)
parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
listener: handleNoTypeArguments(()
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(GenericClass)
listener: endConstructorReference(GenericClass, null, GenericClass, ConstructorReferenceContext.Const)
parseConstructorInvocationArguments(GenericClass)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: endConstExpression(const)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstExpression(const)
parseConstructorReference(const, ConstructorReferenceContext.Const, null)
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(GenericClass, constructorReference)
listener: beginConstructorReference(GenericClass)
parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
listener: handleNoTypeArguments(()
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(GenericClass)
listener: endConstructorReference(GenericClass, null, GenericClass, ConstructorReferenceContext.Const)
parseConstructorInvocationArguments(GenericClass)
parseArgumentsRest(()
listener: beginArguments(()
ensureIdentifier((, namedArgumentReference)
listener: handleIdentifier(a, namedArgumentReference)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseLiteralInt(:)
listener: handleLiteralInt(0)
listener: handleNamedArgument(:)
listener: endArguments(1, (, ))
listener: endConstExpression(const)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstExpression(const)
parseConstructorReference(const, ConstructorReferenceContext.Const, null)
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(GenericClass, constructorReference)
listener: beginConstructorReference(GenericClass)
parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(>)
listener: endConstructorReference(GenericClass, null, >, ConstructorReferenceContext.Const)
parseConstructorInvocationArguments(>)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: endConstExpression(const)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstExpression(const)
parseConstructorReference(const, ConstructorReferenceContext.Const, null)
ensureIdentifier(const, constructorReference)
listener: handleIdentifier(GenericClass, constructorReference)
listener: beginConstructorReference(GenericClass)
parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(>)
listener: endConstructorReference(GenericClass, null, >, ConstructorReferenceContext.Const)
parseConstructorInvocationArguments(>)
parseArgumentsRest(()
listener: beginArguments(()
ensureIdentifier((, namedArgumentReference)
listener: handleIdentifier(a, namedArgumentReference)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseLiteralInt(:)
listener: handleLiteralInt(0)
listener: handleNamedArgument(:)
listener: endArguments(1, (, ))
listener: endConstExpression(const)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstLiteral([])
listener: handleNoTypeArguments([])
parseLiteralListSuffix(const, const)
rewriteSquareBrackets(const)
link([, ])
rewriter()
listener: handleLiteralList(0, [, const, ])
listener: endConstLiteral(])
listener: endConstantPattern(const)
listener: endPattern(])
listener: handleSwitchCaseNoWhenClause(])
ensureColon(])
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstLiteral(<)
parseLiteralListSetMapOrFunction(const, const)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
parseLiteralListSuffix(>, const)
rewriteSquareBrackets(>)
link([, ])
rewriter()
listener: handleLiteralList(0, [, const, ])
listener: endConstLiteral(])
listener: endConstantPattern(const)
listener: endPattern(])
listener: handleSwitchCaseNoWhenClause(])
ensureColon(])
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstLiteral({)
listener: handleNoTypeArguments({)
parseLiteralSetOrMapSuffix(const, const)
listener: handleLiteralSetOrMap(0, {, const, }, false)
listener: endConstLiteral(})
listener: endConstantPattern(const)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstLiteral(<)
parseLiteralListSetMapOrFunction(const, const)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(,)
listener: handleType(int, null)
listener: handleIdentifier(String, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(String, null)
listener: endTypeArguments(2, <, >)
parseLiteralSetOrMapSuffix(>, const)
listener: handleLiteralSetOrMap(0, {, const, }, false)
listener: endConstLiteral(})
listener: endConstantPattern(const)
listener: endPattern(})
listener: handleSwitchCaseNoWhenClause(})
ensureColon(})
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseNewExpression(const)
isNextIdentifier(new)
listener: beginNewExpression(new)
parseConstructorReference(new, ConstructorReferenceContext.New, null)
ensureIdentifier(new, constructorReference)
listener: handleIdentifier(Class, constructorReference)
listener: beginConstructorReference(Class)
parseQualifiedRestOpt(Class, constructorReferenceContinuation)
listener: handleNoTypeArguments(()
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
listener: endConstructorReference(Class, null, Class, ConstructorReferenceContext.New)
parseConstructorInvocationArguments(Class)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: endNewExpression(new)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseNewExpression(case)
isNextIdentifier(new)
listener: beginNewExpression(new)
parseConstructorReference(new, ConstructorReferenceContext.New, null)
ensureIdentifier(new, constructorReference)
listener: handleIdentifier(Class, constructorReference)
listener: beginConstructorReference(Class)
parseQualifiedRestOpt(Class, constructorReferenceContinuation)
listener: handleNoTypeArguments(()
listener: handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
listener: endConstructorReference(Class, null, Class, ConstructorReferenceContext.New)
parseConstructorInvocationArguments(Class)
parseArgumentsRest(()
listener: beginArguments(()
listener: endArguments(0, (, ))
listener: endNewExpression(new)
listener: endConstantPattern(null)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
ensureCloseParen((, ()
reportRecoverableError((, InvalidConstantPatternEmptyRecordLiteral)
listener: handleRecoverableError(InvalidConstantPatternEmptyRecordLiteral, (, ()
listener: endRecordLiteral((, 0, null)
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
parseConstExpression(const)
listener: beginConstLiteral(()
parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
listener: beginParenthesizedExpressionOrRecordLiteral(()
ensureCloseParen((, ()
listener: endRecordLiteral((, 0, const)
listener: endConstLiteral())
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralInt(()
listener: handleLiteralInt(1)
ensureCloseParen(1, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
parseUnaryExpression(-, true, ConstantPatternContext.none)
parsePrimary(-, expression, ConstantPatternContext.none)
parseLiteralInt(-)
listener: handleLiteralInt(1)
listener: handleUnaryPrefixExpression(-)
ensureCloseParen(1, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(value)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(value)
listener: handleNoArguments())
listener: handleSend(value, value)
ensureCloseParen(value, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
parseUnaryExpression(-, true, ConstantPatternContext.none)
parsePrimary(-, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral(-, expression, ConstantPatternContext.none)
parseSend(-, expression, ConstantPatternContext.none)
isNextIdentifier(-)
ensureIdentifier(-, expression)
listener: handleIdentifier(value, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(value)
listener: handleNoArguments())
listener: handleSend(value, value)
listener: handleUnaryPrefixExpression(-)
ensureCloseParen(value, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralInt(()
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
parseUnaryExpression(+, true, ConstantPatternContext.none)
parsePrimary(+, expression, ConstantPatternContext.none)
parseLiteralInt(+)
listener: handleLiteralInt(2)
listener: endBinaryExpression(+, 2)
ensureCloseParen(2, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
reportRecoverableError(<, InvalidConstantPatternGeneric)
listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
listener: handleTypeArgumentApplication(<)
listener: endConstantPattern(null)
listener: endPattern(>)
listener: handleSwitchCaseNoWhenClause(>)
ensureColon(>)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(GenericClass, expressionContinuation)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: handleEndingBinaryExpression(., GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
reportRecoverableError(<, InvalidConstantPatternGeneric)
listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
listener: handleTypeArgumentApplication(<)
listener: endConstantPattern(null)
listener: endPattern(>)
listener: handleSwitchCaseNoWhenClause(>)
ensureColon(>)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
reportRecoverableError(<, InvalidConstantPatternGeneric)
listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
listener: handleTypeArgumentApplication(<)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
rewriter()
listener: handleNewAsIdentifier(new)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(new, expressionContinuation)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(new)
listener: handleNoArguments(:)
listener: handleSend(new, new)
listener: handleEndingBinaryExpression(., new)
listener: endConstantPattern(null)
listener: endPattern(new)
listener: handleSwitchCaseNoWhenClause(new)
ensureColon(new)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(null)
parsePrecedenceExpression(case, 7, false, ConstantPatternContext.implicit)
parseUnaryExpression(case, false, ConstantPatternContext.implicit)
parsePrimary(case, expression, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
parseSend(case, expression, ConstantPatternContext.implicit)
isNextIdentifier(case)
ensureIdentifier(case, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(GenericClass, expressionContinuation)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: handleEndingBinaryExpression(., GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
reportRecoverableError(<, InvalidConstantPatternGeneric)
listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
listener: handleTypeArgumentApplication(<)
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
rewriter()
listener: handleNewAsIdentifier(new)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(new, expressionContinuation)
listener: handleNoTypeArguments(:)
parseArgumentsOpt(new)
listener: handleNoArguments(:)
listener: handleSend(new, new)
listener: handleEndingBinaryExpression(., new)
listener: endConstantPattern(null)
listener: endPattern(new)
listener: handleSwitchCaseNoWhenClause(new)
ensureColon(new)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
reportRecoverableError(<, InvalidConstantPatternGeneric)
listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
listener: handleTypeArgumentApplication(<)
listener: endConstantPattern(const)
listener: endPattern(>)
listener: handleSwitchCaseNoWhenClause(>)
ensureColon(>)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(const, expression, ConstantPatternContext.explicit)
parseSend(const, expression, ConstantPatternContext.explicit)
isNextIdentifier(const)
ensureIdentifier(const, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.explicit)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.explicit)
parseSend(., expressionContinuation, ConstantPatternContext.explicit)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(GenericClass, expressionContinuation)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: handleEndingBinaryExpression(., GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
reportRecoverableError(<, InvalidConstantPatternGeneric)
listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
listener: handleTypeArgumentApplication(<)
listener: endConstantPattern(const)
listener: endPattern(>)
listener: handleSwitchCaseNoWhenClause(>)
ensureColon(>)
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(GenericClass)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
listener: handleTypeArgumentApplication(<)
ensureCloseParen(>, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(GenericClass)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.none)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
parseSend(., expressionContinuation, ConstantPatternContext.none)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(GenericClass, expressionContinuation)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: handleEndingBinaryExpression(., GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
listener: handleTypeArgumentApplication(<)
ensureCloseParen(>, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(GenericClass)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(GenericClass, expression)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
listener: handleTypeArgumentApplication(<)
parsePrimary(., expressionContinuation, ConstantPatternContext.none)
rewriter()
listener: handleNewAsIdentifier(new)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
parseSend(., expressionContinuation, ConstantPatternContext.none)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(new, expressionContinuation)
listener: handleNoTypeArguments())
parseArgumentsOpt(new)
listener: handleNoArguments())
listener: handleSend(new, new)
listener: handleEndingBinaryExpression(., new)
ensureCloseParen(new, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(case)
listener: beginCaseExpression(case)
parsePattern(case, PatternContext.matching, precedence: 1)
listener: beginPattern(case)
parsePrimaryPattern(case, PatternContext.matching)
listener: beginConstantPattern(const)
parsePrecedenceExpression(const, 7, false, ConstantPatternContext.explicit)
parseUnaryExpression(const, false, ConstantPatternContext.explicit)
parsePrimary(const, expression, ConstantPatternContext.explicit)
parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
listener: beginParenthesizedExpressionOrRecordLiteral(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
skipObjectPatternRest(GenericClass)
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral((, expression, ConstantPatternContext.none)
parseSend((, expression, ConstantPatternContext.none)
isNextIdentifier(()
ensureIdentifier((, expression)
listener: handleIdentifier(prefix, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(prefix)
listener: handleNoArguments(.)
listener: handleSend(prefix, prefix)
parsePrimary(., expressionContinuation, ConstantPatternContext.none)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
parseSend(., expressionContinuation, ConstantPatternContext.none)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(GenericClass, expressionContinuation)
listener: handleNoTypeArguments(<)
parseArgumentsOpt(GenericClass)
listener: handleNoArguments(<)
listener: handleSend(GenericClass, GenericClass)
listener: handleEndingBinaryExpression(., GenericClass)
listener: beginTypeArguments(<)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(>)
listener: handleType(int, null)
listener: endTypeArguments(1, <, >)
listener: handleTypeArgumentApplication(<)
parsePrimary(., expressionContinuation, ConstantPatternContext.none)
rewriter()
listener: handleNewAsIdentifier(new)
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
parseSend(., expressionContinuation, ConstantPatternContext.none)
isNextIdentifier(.)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(new, expressionContinuation)
listener: handleNoTypeArguments())
parseArgumentsOpt(new)
listener: handleNoArguments())
listener: handleSend(new, new)
listener: handleEndingBinaryExpression(., new)
ensureCloseParen(new, ()
listener: endParenthesizedExpression(()
listener: endConstantPattern(const)
listener: endPattern())
listener: handleSwitchCaseNoWhenClause())
ensureColon())
listener: endCaseExpression(case, null, :)
peekPastLabels(print)
parseStatementsInSwitchCase(:, print, case, 0, 68, null, null)
listener: beginSwitchCase(0, 68, case)
parseStatement(:)
parseStatementX(:)
parseExpressionStatementOrDeclarationAfterModifiers(:, :, null, null, null, null)
looksLikeLocalFunction(print)
parseExpressionStatement(:)
parseExpression(:)
looksLikeOuterPatternEquals(:)
skipOuterPattern(:)
skipObjectPatternRest(print)
parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
parseUnaryExpression(:, true, ConstantPatternContext.none)
parsePrimary(:, expression, ConstantPatternContext.none)
parseSendOrFunctionLiteral(:, expression, ConstantPatternContext.none)
looksLikeFunctionBody(;)
parseSend(:, expression, ConstantPatternContext.none)
isNextIdentifier(:)
ensureIdentifier(:, expression)
listener: handleIdentifier(print, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(print)
parseArguments(print)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
looksLikeOuterPatternEquals(()
skipOuterPattern(()
parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
parseUnaryExpression((, true, ConstantPatternContext.none)
parsePrimary((, expression, ConstantPatternContext.none)
parseLiteralInt(()
listener: handleLiteralInt(0)
listener: endArguments(1, (, ))
listener: handleSend(print, ))
ensureSemicolon())
listener: handleExpressionStatement(print, ;)
peekPastLabels(})
listener: endSwitchCase(0, 68, null, null, 1, case, ;)
notEofOrValue(}, })
listener: endSwitchBlock(2, {, })
listener: endSwitchStatement(switch, })
notEofOrValue(}, })
listener: endBlockFunctionBody(3, {, })
listener: endClassMethod(null, test, (, null, })
listener: endMember()
notEofOrValue(}, })
listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 4, {, })
listener: endClassDeclaration(class, })
listener: endTopLevelDeclaration(})
parseTopLevelDeclarationImpl(}, DirectiveContext(DirectiveState.Declarations))
parseMetadataStar(})
listener: beginMetadataStar(class)
listener: endMetadataStar(0)
parseTopLevelKeywordDeclaration(class, }, class, null, null, null, null, DirectiveContext(DirectiveState.Declarations))
parseClassOrNamedMixinApplication(class, null, null, null, null, null, null, null, null, class)
listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
ensureIdentifier(class, classOrMixinDeclaration)
listener: handleIdentifier(GenericClass, classOrMixinDeclaration)
listener: beginTypeVariables(<)
listener: beginMetadataStar(T)
listener: endMetadataStar(0)
listener: handleIdentifier(T, typeVariableDeclaration)
listener: beginTypeVariable(T)
listener: handleTypeVariablesDefined(T, 1)
listener: handleNoType(T)
listener: endTypeVariable(>, 0, null, null)
listener: endTypeVariables(<, >)
listener: beginClassDeclaration(class, null, null, null, null, null, null, null, null, GenericClass)
parseClass(>, class, class, GenericClass)
parseClassHeaderOpt(>, class, class)
parseClassExtendsOpt(>, DeclarationHeaderKind.Class)
listener: handleNoType(>)
listener: handleClassExtends(null, 1)
parseClassWithClauseOpt(>)
listener: handleClassNoWithClause()
parseClassOrMixinOrEnumImplementsOpt(>)
listener: handleImplements(null, 0)
listener: handleClassHeader(class, class, null)
parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, GenericClass)
listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
notEofOrValue(}, const)
parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, GenericClass)
parseMetadataStar({)
listener: beginMetadataStar(const)
listener: endMetadataStar(0)
listener: beginMember()
skipOuterPattern(const)
skipObjectPatternRest(GenericClass)
parseMethod({, null, null, null, null, null, null, const, const, NoType(), null, GenericClass, DeclarationKind.Class, GenericClass, false)
listener: beginMethod(DeclarationKind.Class, null, null, null, null, const, null, GenericClass, GenericClass)
listener: handleNoType(const)
ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
listener: handleIdentifier(GenericClass, methodDeclaration)
parseQualifiedRestOpt(GenericClass, methodDeclarationContinuation)
parseMethodTypeVar(GenericClass)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(GenericClass, GenericClass, false, MemberKind.NonStaticMethod)
parseFormalParameters(GenericClass, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseOptionalNamedParameters((, MemberKind.NonStaticMethod)
listener: beginOptionalFormalParameters({)
parseFormalParameter({, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
parseMetadataStar({)
listener: beginMetadataStar(a)
listener: endMetadataStar(0)
listener: beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
listener: handleNoType({)
ensureIdentifier({, formalParameterDeclaration)
listener: handleIdentifier(a, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(})
listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
listener: endOptionalFormalParameters(1, {, }, MemberKind.NonStaticMethod)
ensureCloseParen(}, ()
listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: handleEmptyFunctionBody(;)
listener: endClassConstructor(null, const, (, null, ;)
listener: endMember()
notEofOrValue(}, })
listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
listener: endClassDeclaration(class, })
listener: endTopLevelDeclaration(})
reportAllErrorTokens(import)
listener: endCompilationUnit(5, )
Reference in New Issue View Git Blame Copy Permalink