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