Konstantin Shcheglov
5f6daed1e1
Change-Id: If8f0cb6fc1af77fb91774952931db5da214142e9 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/354520 Reviewed-by: Brian Wilkerson <brianwilkerson@google.com> Reviewed-by: Johnni Winther <johnniwinther@google.com>
2338 lines
162 KiB
Plaintext
2338 lines
162 KiB
Plaintext
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_binary.dart')
|
|
listener: endLiteralString(0, as)
|
|
parseConditionalUriStar('const_patterns_binary.dart')
|
|
listener: beginConditionalUris(as)
|
|
listener: endConditionalUris(0)
|
|
parseImportPrefixOpt('const_patterns_binary.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(const)
|
|
parseTopLevelDeclarationImpl(;, DirectiveContext(DirectiveState.ImportAndExport))
|
|
parseMetadataStar(;)
|
|
listener: beginMetadataStar(const)
|
|
listener: endMetadataStar(0)
|
|
parseTopLevelMemberImpl(;)
|
|
listener: beginTopLevelMember(const)
|
|
skipOuterPattern(const)
|
|
skipObjectPatternRest(value)
|
|
parseFields(;, null, null, null, null, null, null, const, const, NoType(), value, DeclarationKind.TopLevel, null, false)
|
|
listener: beginFields(DeclarationKind.TopLevel, null, null, null, null, null, null, const, ;)
|
|
listener: handleNoType(const)
|
|
ensureIdentifierPotentiallyRecovered(const, 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(1)
|
|
listener: endFieldInitializer(=, ;)
|
|
listener: endTopLevelFields(null, null, null, null, null, const, 1, const, ;)
|
|
listener: endTopLevelDeclaration(class)
|
|
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(}, static)
|
|
parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Class)
|
|
parseMetadataStar({)
|
|
listener: beginMetadataStar(static)
|
|
listener: endMetadataStar(0)
|
|
listener: beginMember()
|
|
skipOuterPattern(const)
|
|
skipObjectPatternRest(value)
|
|
parseFields({, null, null, null, static, null, null, const, const, NoType(), value, DeclarationKind.Class, Class, false)
|
|
listener: beginFields(DeclarationKind.Class, null, null, null, static, null, null, const, {)
|
|
listener: handleNoType(const)
|
|
ensureIdentifierPotentiallyRecovered(const, fieldDeclaration, false)
|
|
listener: handleIdentifier(value, fieldDeclaration)
|
|
parseFieldInitializerOpt(value, value, null, null, null, null, const, DeclarationKind.Class, Class)
|
|
listener: beginFieldInitializer(=)
|
|
parseExpression(=)
|
|
looksLikeOuterPatternEquals(=)
|
|
skipOuterPattern(=)
|
|
parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(=, true, ConstantPatternContext.none)
|
|
parsePrimary(=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endFieldInitializer(=, ;)
|
|
listener: endClassFields(null, null, null, static, null, null, const, 1, static, ;)
|
|
listener: endMember()
|
|
notEofOrValue(}, })
|
|
listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
|
|
listener: endClassDeclaration(class, })
|
|
listener: endTopLevelDeclaration(method)
|
|
parseTopLevelDeclarationImpl(}, DirectiveContext(DirectiveState.Declarations))
|
|
parseMetadataStar(})
|
|
listener: beginMetadataStar(method)
|
|
listener: endMetadataStar(0)
|
|
parseTopLevelMemberImpl(})
|
|
listener: beginTopLevelMember(method)
|
|
isReservedKeyword(<)
|
|
parseTopLevelMethod(}, null, null, }, NoType(), null, method, false)
|
|
listener: beginTopLevelMethod(}, null, null)
|
|
listener: handleNoType(})
|
|
ensureIdentifierPotentiallyRecovered(}, topLevelFunctionDeclaration, false)
|
|
listener: handleIdentifier(method, topLevelFunctionDeclaration)
|
|
parseMethodTypeVar(method)
|
|
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(<, >)
|
|
parseGetterOrFormalParameters(>, method, false, MemberKind.TopLevelMethod)
|
|
parseFormalParameters(>, MemberKind.TopLevelMethod)
|
|
parseFormalParametersRest((, MemberKind.TopLevelMethod)
|
|
listener: beginFormalParameters((, MemberKind.TopLevelMethod)
|
|
parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
|
|
parseMetadataStar(()
|
|
listener: beginMetadataStar(o)
|
|
listener: endMetadataStar(0)
|
|
listener: beginFormalParameter(o, MemberKind.TopLevelMethod, null, null, null)
|
|
listener: handleNoType(()
|
|
ensureIdentifier((, formalParameterDeclaration)
|
|
listener: handleIdentifier(o, formalParameterDeclaration)
|
|
listener: handleFormalParameterWithoutValue())
|
|
listener: endFormalParameter(null, null, null, o, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
|
|
listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
|
|
parseAsyncModifierOpt())
|
|
listener: handleAsyncModifier(null, null)
|
|
inPlainSync()
|
|
parseFunctionBody(), false, false)
|
|
listener: beginBlockFunctionBody({)
|
|
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, ))
|
|
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)
|
|
parseLiteralInt(case)
|
|
listener: handleLiteralInt(1)
|
|
listener: endConstantPattern(null)
|
|
listener: beginBinaryPattern(||)
|
|
parsePattern(||, PatternContext.matching, precedence: 6)
|
|
listener: beginPattern(||)
|
|
parsePrimaryPattern(||, PatternContext.matching)
|
|
listener: beginConstantPattern(null)
|
|
parsePrecedenceExpression(||, 7, false, ConstantPatternContext.implicit)
|
|
parseUnaryExpression(||, false, ConstantPatternContext.implicit)
|
|
parsePrimary(||, expression, ConstantPatternContext.implicit)
|
|
parseLiteralInt(||)
|
|
listener: handleLiteralInt(2)
|
|
listener: endConstantPattern(null)
|
|
listener: endPattern(2)
|
|
listener: endBinaryPattern(||)
|
|
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)
|
|
listener: endConstantPattern(null)
|
|
listener: beginBinaryPattern(&&)
|
|
parsePattern(&&, PatternContext.matching, precedence: 7)
|
|
listener: beginPattern(&&)
|
|
parsePrimaryPattern(&&, PatternContext.matching)
|
|
listener: beginConstantPattern(null)
|
|
parsePrecedenceExpression(&&, 7, false, ConstantPatternContext.implicit)
|
|
parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
|
|
parsePrimary(&&, expression, ConstantPatternContext.implicit)
|
|
parseLiteralInt(&&)
|
|
listener: handleLiteralInt(2)
|
|
listener: endConstantPattern(null)
|
|
listener: endPattern(2)
|
|
listener: endBinaryPattern(&&)
|
|
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)
|
|
listener: endConstantPattern(null)
|
|
listener: beginAsOperatorType(as)
|
|
computeTypeAfterIsOrAs(as)
|
|
listener: handleIdentifier(T, typeReference)
|
|
listener: handleNoTypeArguments(:)
|
|
listener: handleType(T, null)
|
|
listener: endAsOperatorType(as)
|
|
listener: handleCastPattern(as)
|
|
listener: endPattern(T)
|
|
listener: handleSwitchCaseNoWhenClause(T)
|
|
ensureColon(T)
|
|
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(Object, expression)
|
|
listener: handleNoTypeArguments(()
|
|
parseArgumentsOpt(Object)
|
|
parseArguments(Object)
|
|
parseArgumentsRest(()
|
|
listener: beginArguments(()
|
|
listener: endArguments(0, (, ))
|
|
listener: handleSend(Object, :)
|
|
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)
|
|
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(+)
|
|
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(-, 14, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(-, false, ConstantPatternContext.none)
|
|
parsePrimary(-, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(-)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(-)
|
|
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(*)
|
|
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(/)
|
|
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(~/)
|
|
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(%)
|
|
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(==, 8, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(==, false, ConstantPatternContext.none)
|
|
parsePrimary(==, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(==)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(==)
|
|
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(!=, 8, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(!=, false, ConstantPatternContext.none)
|
|
parsePrimary(!=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(!=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(!=)
|
|
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(^, 11, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(^, false, ConstantPatternContext.none)
|
|
parsePrimary(^, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(^)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(^)
|
|
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(&, 12, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(&, false, ConstantPatternContext.none)
|
|
parsePrimary(&, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(&)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(&)
|
|
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(|, 10, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(|, false, ConstantPatternContext.none)
|
|
parsePrimary(|, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(|)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(|)
|
|
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(<, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(<, false, ConstantPatternContext.none)
|
|
parsePrimary(<, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<)
|
|
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(<=, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(<=, false, ConstantPatternContext.none)
|
|
parsePrimary(<=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<=)
|
|
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(>, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>, false, ConstantPatternContext.none)
|
|
parsePrimary(>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>)
|
|
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(>=, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>=, false, ConstantPatternContext.none)
|
|
parsePrimary(>=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>=)
|
|
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(<<, 13, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(<<, false, ConstantPatternContext.none)
|
|
parsePrimary(<<, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<<)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<<)
|
|
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(>>, 13, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>>, false, ConstantPatternContext.none)
|
|
parsePrimary(>>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>>)
|
|
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(>>>, 13, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>>>, false, ConstantPatternContext.none)
|
|
parsePrimary(>>>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>>>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>>>)
|
|
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(+, 14, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(+, false, ConstantPatternContext.none)
|
|
parsePrimary(+, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(+)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(+)
|
|
listener: beginBinaryExpression(+)
|
|
parsePrecedenceExpression(+, 14, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(+, false, ConstantPatternContext.none)
|
|
parsePrimary(+, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(+)
|
|
listener: handleLiteralInt(3)
|
|
listener: endBinaryExpression(+)
|
|
listener: endConstantPattern(null)
|
|
listener: endPattern(3)
|
|
listener: handleSwitchCaseNoWhenClause(3)
|
|
ensureColon(3)
|
|
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, .)
|
|
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
|
|
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
|
|
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
|
|
isNextIdentifier(.)
|
|
ensureIdentifier(., expressionContinuation)
|
|
listener: handleIdentifier(value, expressionContinuation)
|
|
listener: handleNoTypeArguments(as)
|
|
parseArgumentsOpt(value)
|
|
listener: handleNoArguments(as)
|
|
listener: handleSend(value, as)
|
|
listener: handleEndingBinaryExpression(.)
|
|
listener: endConstantPattern(null)
|
|
listener: beginAsOperatorType(as)
|
|
computeTypeAfterIsOrAs(as)
|
|
listener: handleIdentifier(T, typeReference)
|
|
listener: handleNoTypeArguments(:)
|
|
listener: handleType(T, null)
|
|
listener: endAsOperatorType(as)
|
|
listener: handleCastPattern(as)
|
|
listener: endPattern(T)
|
|
listener: handleSwitchCaseNoWhenClause(T)
|
|
ensureColon(T)
|
|
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, .)
|
|
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, .)
|
|
listener: handleEndingBinaryExpression(.)
|
|
parsePrimary(., expressionContinuation, ConstantPatternContext.implicit)
|
|
parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.implicit)
|
|
parseSend(., expressionContinuation, ConstantPatternContext.implicit)
|
|
isNextIdentifier(.)
|
|
ensureIdentifier(., expressionContinuation)
|
|
listener: handleIdentifier(value, expressionContinuation)
|
|
listener: handleNoTypeArguments(as)
|
|
parseArgumentsOpt(value)
|
|
listener: handleNoArguments(as)
|
|
listener: handleSend(value, as)
|
|
listener: handleEndingBinaryExpression(.)
|
|
listener: endConstantPattern(null)
|
|
listener: beginAsOperatorType(as)
|
|
computeTypeAfterIsOrAs(as)
|
|
listener: handleIdentifier(T, typeReference)
|
|
listener: handleNoTypeArguments(:)
|
|
listener: handleType(T, null)
|
|
listener: endAsOperatorType(as)
|
|
listener: handleCastPattern(as)
|
|
listener: endPattern(T)
|
|
listener: handleSwitchCaseNoWhenClause(T)
|
|
ensureColon(T)
|
|
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)
|
|
listener: endConstantPattern(const)
|
|
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(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(+)
|
|
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)
|
|
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(-)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(*)
|
|
parsePrecedenceExpression(*, 15, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(*, false, ConstantPatternContext.none)
|
|
parsePrimary(*, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(*)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(*)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(/)
|
|
parsePrecedenceExpression(/, 15, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(/, false, ConstantPatternContext.none)
|
|
parsePrimary(/, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(/)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(/)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(~/)
|
|
parsePrecedenceExpression(~/, 15, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(~/, false, ConstantPatternContext.none)
|
|
parsePrimary(~/, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(~/)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(~/)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(%)
|
|
parsePrecedenceExpression(%, 15, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(%, false, ConstantPatternContext.none)
|
|
parsePrimary(%, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(%)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(%)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(==)
|
|
parsePrecedenceExpression(==, 8, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(==, false, ConstantPatternContext.none)
|
|
parsePrimary(==, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(==)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(==)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(!=)
|
|
parsePrecedenceExpression(!=, 8, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(!=, false, ConstantPatternContext.none)
|
|
parsePrimary(!=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(!=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(!=)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(^)
|
|
parsePrecedenceExpression(^, 11, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(^, false, ConstantPatternContext.none)
|
|
parsePrimary(^, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(^)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(^)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(&)
|
|
parsePrecedenceExpression(&, 12, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(&, false, ConstantPatternContext.none)
|
|
parsePrimary(&, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(&)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(&)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(|)
|
|
parsePrecedenceExpression(|, 10, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(|, false, ConstantPatternContext.none)
|
|
parsePrimary(|, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(|)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(|)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(<)
|
|
parsePrecedenceExpression(<, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(<, false, ConstantPatternContext.none)
|
|
parsePrimary(<, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(<=)
|
|
parsePrecedenceExpression(<=, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(<=, false, ConstantPatternContext.none)
|
|
parsePrimary(<=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<=)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(>)
|
|
parsePrecedenceExpression(>, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>, false, ConstantPatternContext.none)
|
|
parsePrimary(>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(>=)
|
|
parsePrecedenceExpression(>=, 9, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>=, false, ConstantPatternContext.none)
|
|
parsePrimary(>=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>=)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(<<)
|
|
parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(<<, false, ConstantPatternContext.none)
|
|
parsePrimary(<<, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<<)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<<)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(>>)
|
|
parsePrecedenceExpression(>>, 13, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>>, false, ConstantPatternContext.none)
|
|
parsePrimary(>>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>>)
|
|
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)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
parseLiteralInt(const)
|
|
listener: handleLiteralInt(1)
|
|
reportRecoverableError(1, InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
|
|
listener: beginBinaryExpression(>>>)
|
|
parsePrecedenceExpression(>>>, 13, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(>>>, false, ConstantPatternContext.none)
|
|
parsePrimary(>>>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>>>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>>>)
|
|
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)
|
|
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(+)
|
|
listener: beginBinaryExpression(+)
|
|
parsePrecedenceExpression(+, 14, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(+, false, ConstantPatternContext.none)
|
|
parsePrimary(+, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(+)
|
|
listener: handleLiteralInt(3)
|
|
listener: endBinaryExpression(+)
|
|
listener: endConstantPattern(const)
|
|
listener: endPattern(3)
|
|
listener: handleSwitchCaseNoWhenClause(3)
|
|
ensureColon(3)
|
|
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(Object, expression)
|
|
listener: handleNoTypeArguments(()
|
|
parseArgumentsOpt(Object)
|
|
parseArguments(Object)
|
|
parseArgumentsRest(()
|
|
listener: beginArguments(()
|
|
listener: endArguments(0, (, ))
|
|
listener: handleSend(Object, ==)
|
|
reportRecoverableError(), InvalidConstantPatternConstPrefix)
|
|
listener: handleRecoverableError(InvalidConstantPatternConstPrefix, ), ))
|
|
listener: beginBinaryExpression(==)
|
|
parsePrecedenceExpression(==, 8, false, ConstantPatternContext.none)
|
|
parseUnaryExpression(==, false, ConstantPatternContext.none)
|
|
parsePrimary(==, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(==)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(==)
|
|
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)
|
|
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: beginAsOperatorType(as)
|
|
computeTypeAfterIsOrAs(as)
|
|
listener: handleIdentifier(List, typeReference)
|
|
listener: beginTypeArguments(<)
|
|
listener: handleIdentifier(T, typeReference)
|
|
listener: handleNoTypeArguments(>)
|
|
listener: handleType(T, null)
|
|
listener: endTypeArguments(1, <, >)
|
|
listener: handleType(List, null)
|
|
listener: endAsOperatorType(as)
|
|
listener: handleCastPattern(as)
|
|
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(+)
|
|
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(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(-)
|
|
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(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(*, 15, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(*, true, ConstantPatternContext.none)
|
|
parsePrimary(*, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(*)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(*)
|
|
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(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(/, 15, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(/, true, ConstantPatternContext.none)
|
|
parsePrimary(/, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(/)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(/)
|
|
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(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(~/, 15, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(~/, true, ConstantPatternContext.none)
|
|
parsePrimary(~/, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(~/)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(~/)
|
|
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(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(%, 15, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(%, true, ConstantPatternContext.none)
|
|
parsePrimary(%, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(%)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(%)
|
|
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(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(==, 8, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(==, true, ConstantPatternContext.none)
|
|
parsePrimary(==, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(==)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(==)
|
|
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(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(!=, 8, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(!=, true, ConstantPatternContext.none)
|
|
parsePrimary(!=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(!=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(!=)
|
|
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(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(^, 11, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(^, true, ConstantPatternContext.none)
|
|
parsePrimary(^, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(^)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(^)
|
|
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(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(&, 12, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(&, true, ConstantPatternContext.none)
|
|
parsePrimary(&, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(&)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(&)
|
|
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(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(|, 10, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(|, true, ConstantPatternContext.none)
|
|
parsePrimary(|, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(|)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(|)
|
|
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(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(<, 9, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(<, true, ConstantPatternContext.none)
|
|
parsePrimary(<, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<)
|
|
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(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(<=, 9, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(<=, true, ConstantPatternContext.none)
|
|
parsePrimary(<=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<=)
|
|
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(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(>, 9, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(>, true, ConstantPatternContext.none)
|
|
parsePrimary(>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>)
|
|
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(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(>=, 9, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(>=, true, ConstantPatternContext.none)
|
|
parsePrimary(>=, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>=)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>=)
|
|
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(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(<<, 13, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(<<, true, ConstantPatternContext.none)
|
|
parsePrimary(<<, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(<<)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(<<)
|
|
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(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(>>, 13, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(>>, true, ConstantPatternContext.none)
|
|
parsePrimary(>>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>>)
|
|
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(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(>>>, 13, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(>>>, true, ConstantPatternContext.none)
|
|
parsePrimary(>>>, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(>>>)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(>>>)
|
|
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(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(+)
|
|
listener: beginBinaryExpression(+)
|
|
parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(+, true, ConstantPatternContext.none)
|
|
parsePrimary(+, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(+)
|
|
listener: handleLiteralInt(3)
|
|
listener: endBinaryExpression(+)
|
|
ensureCloseParen(3, ()
|
|
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)
|
|
parseLiteralInt(case)
|
|
listener: handleLiteralInt(1)
|
|
listener: endConstantPattern(null)
|
|
listener: endPattern(1)
|
|
listener: handleSwitchCaseNoWhenClause(1)
|
|
ensureColon(1)
|
|
rewriteAndRecover(1, 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, 67, null, null)
|
|
listener: beginSwitchCase(0, 67, 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)
|
|
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(, ??)
|
|
listener: beginBinaryExpression(??)
|
|
parsePrecedenceExpression(??, 5, true, ConstantPatternContext.none)
|
|
parseUnaryExpression(??, true, ConstantPatternContext.none)
|
|
parsePrimary(??, expression, ConstantPatternContext.none)
|
|
parseLiteralInt(??)
|
|
listener: handleLiteralInt(2)
|
|
listener: endBinaryExpression(??)
|
|
ensureSemicolon(2)
|
|
reportRecoverableError(2, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
|
|
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
|
|
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(2, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
|
|
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
|
|
rewriter()
|
|
listener: handleExpressionStatement(;)
|
|
reportRecoverableError(:, Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}])
|
|
listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
|
|
peekPastLabels(case)
|
|
listener: endSwitchCase(0, 67, null, null, 2, case, 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)
|
|
parseSendOrFunctionLiteral(case, expression, ConstantPatternContext.implicit)
|
|
parseSend(case, expression, ConstantPatternContext.implicit)
|
|
isNextIdentifier(case)
|
|
ensureIdentifier(case, expression)
|
|
listener: handleIdentifier(o, expression)
|
|
listener: handleNoTypeArguments(++)
|
|
parseArgumentsOpt(o)
|
|
listener: handleNoArguments(++)
|
|
listener: handleSend(o, ++)
|
|
listener: handleUnaryPostfixAssignmentExpression(++)
|
|
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(o, expression)
|
|
listener: handleNoTypeArguments(--)
|
|
parseArgumentsOpt(o)
|
|
listener: handleNoArguments(--)
|
|
listener: handleSend(o, --)
|
|
listener: handleUnaryPostfixAssignmentExpression(--)
|
|
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)
|
|
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(o, expression)
|
|
listener: handleNoTypeArguments(:)
|
|
parseArgumentsOpt(o)
|
|
listener: handleNoArguments(:)
|
|
listener: handleSend(o, :)
|
|
listener: handleUnaryPrefixAssignmentExpression(++)
|
|
listener: endConstantPattern(null)
|
|
listener: endPattern(o)
|
|
listener: handleSwitchCaseNoWhenClause(o)
|
|
ensureColon(o)
|
|
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(o, expression)
|
|
listener: handleNoTypeArguments(:)
|
|
parseArgumentsOpt(o)
|
|
listener: handleNoArguments(:)
|
|
listener: handleSend(o, :)
|
|
listener: handleUnaryPrefixAssignmentExpression(--)
|
|
listener: endConstantPattern(null)
|
|
listener: endPattern(o)
|
|
listener: handleSwitchCaseNoWhenClause(o)
|
|
ensureColon(o)
|
|
listener: endCaseExpression(case, null, :)
|
|
peekPastLabels(})
|
|
parseStatementsInSwitchCase(:, }, case, 0, 4, null, null)
|
|
listener: beginSwitchCase(0, 4, case)
|
|
listener: endSwitchCase(0, 4, null, null, 0, case, })
|
|
notEofOrValue(}, })
|
|
listener: endSwitchBlock(2, {, })
|
|
listener: endSwitchStatement(switch, })
|
|
notEofOrValue(}, })
|
|
listener: endBlockFunctionBody(1, {, })
|
|
listener: endTopLevelMethod(method, null, })
|
|
listener: endTopLevelDeclaration()
|
|
reportAllErrorTokens(import)
|
|
listener: endCompilationUnit(4, )
|