Problems reported:

parser/patterns/const_patterns:37:13: Only negation of a numeric literal is supported as a constant pattern.
      case -value: // Error
            ^^^^^

parser/patterns/const_patterns:39:13: Only negation of a numeric literal is supported as a constant pattern.
      case -local: // Error
            ^^^^^

parser/patterns/const_patterns:42:13: Only negation of a numeric literal is supported as a constant pattern.
      case -prefix.value: // Error
            ^^^^^^

parser/patterns/const_patterns:42:20: Only negation of a numeric literal is supported as a constant pattern.
      case -prefix.value: // Error
                   ^^^^^

parser/patterns/const_patterns:44:14: The binary operator + is not supported as a constant pattern.
      case 1 + 2: // Error
             ^

parser/patterns/const_patterns:45:14: The binary operator * is not supported as a constant pattern.
      case 1 * 2: // Error
             ^

parser/patterns/const_patterns:46:20: Expected ':' before this.
      case void fun() {}: // Error
                   ^

parser/patterns/const_patterns:46:24: Expected ';' after this.
      case void fun() {}: // Error
                       ^

parser/patterns/const_patterns:46:25: Expected an identifier, but got ':'.
      case void fun() {}: // Error
                        ^

parser/patterns/const_patterns:46:24: Expected ';' after this.
      case void fun() {}: // Error
                       ^

parser/patterns/const_patterns:46:25: Unexpected token ':'.
      case void fun() {}: // Error
                        ^

parser/patterns/const_patterns:47:12: `assert` can't be used as an expression.
      case assert(false): // Error
           ^^^^^^

parser/patterns/const_patterns:50:12: The unary operator ! is not supported as a constant pattern.
      case !false: // Error
           ^

parser/patterns/const_patterns:51:12: The unary operator ~ is not supported as a constant pattern.
      case ~0: // Error
           ^

parser/patterns/const_patterns:53:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const 0: // Error
                 ^

parser/patterns/const_patterns:54:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const 0x0: // Error
                 ^^^

parser/patterns/const_patterns:55:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const 0.5: // Error
                 ^^^

parser/patterns/const_patterns:56:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const true: // Error
                 ^^^^

parser/patterns/const_patterns:57:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const null: // Error
                 ^^^^

parser/patterns/const_patterns:58:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const -0: // Error
                 ^

parser/patterns/const_patterns:59:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const 'foo': // Error
                 ^^^^^

parser/patterns/const_patterns:60:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const #a: // Error
                 ^

parser/patterns/const_patterns:61:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const value: // Error
                 ^^^^^

parser/patterns/const_patterns:62:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const local: // Error
                 ^^^^^

parser/patterns/const_patterns:63:25: The expression can't be prefixed by 'const' to form a constant pattern.
      case const prefix.value: // Error
                        ^^^^^

parser/patterns/const_patterns:64:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const -prefix.value: // Error
                 ^

parser/patterns/const_patterns:65:31: The expression can't be prefixed by 'const' to form a constant pattern.
      case const prefix.Class.named: // Error
                              ^^^^^

parser/patterns/const_patterns:66:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const 1 + 2: // Error
                 ^

parser/patterns/const_patterns:66:18: The expression can't be prefixed by 'const' to form a constant pattern.
      case const 1 + 2: // Error
                 ^

parser/patterns/const_patterns:67:23: A function expression can't have a name.
      case const void fun() {}: // Error
                      ^^^

parser/patterns/const_patterns:68:18: `assert` can't be used as an expression.
      case const assert(false): // Error
                 ^^^^^^

parser/patterns/const_patterns:71:18: The unary operator ! is not supported as a constant pattern.
      case const !false: // Error
                 ^

parser/patterns/const_patterns:72:18: The unary operator ~ is not supported as a constant pattern.
      case const ~0: // Error
                 ^

parser/patterns/const_patterns:86:18: Duplicate 'const' keyword in constant expression.
      case const const Class(): // Error
                 ^^^^^

parser/patterns/const_patterns:87:18: Duplicate 'const' keyword in constant expression.
      case const const Class(0): // Error
                 ^^^^^

parser/patterns/const_patterns:88:18: Duplicate 'const' keyword in constant expression.
      case const const GenericClass(): // Error
                 ^^^^^

parser/patterns/const_patterns:89:18: Duplicate 'const' keyword in constant expression.
      case const const GenericClass(a: 0): // Error
                 ^^^^^

parser/patterns/const_patterns:90:18: Duplicate 'const' keyword in constant expression.
      case const const GenericClass<int>(): // Error
                 ^^^^^

parser/patterns/const_patterns:91:18: Duplicate 'const' keyword in constant expression.
      case const const GenericClass<int>(a: 0): // Error
                 ^^^^^

parser/patterns/const_patterns:92:18: Duplicate 'const' keyword in constant expression.
      case const const []: // Error
                 ^^^^^

parser/patterns/const_patterns:93:18: Duplicate 'const' keyword in constant expression.
      case const const <int>[]: // Error
                 ^^^^^

parser/patterns/const_patterns:94:18: Duplicate 'const' keyword in constant expression.
      case const const {}: // Error
                 ^^^^^

parser/patterns/const_patterns:95:18: Duplicate 'const' keyword in constant expression.
      case const const <int, String>{}: // Error
                 ^^^^^

parser/patterns/const_patterns:98:18: The empty record literal is not supported as a constant pattern.
      case const (): // Error
                 ^

parser/patterns/const_patterns:99:18: Duplicate 'const' keyword in constant expression.
      case const const (): // Error
                 ^^^^^

parser/patterns/const_patterns:105:24: This expression is not supported as a constant pattern.
      case GenericClass<int>: // Error
                       ^

parser/patterns/const_patterns:106:31: This expression is not supported as a constant pattern.
      case prefix.GenericClass<int>: // Error
                              ^

parser/patterns/const_patterns:107:24: This expression is not supported as a constant pattern.
      case GenericClass<int>.new: // Error
                       ^

parser/patterns/const_patterns:108:31: This expression is not supported as a constant pattern.
      case prefix.GenericClass<int>.new: // Error
                              ^

parser/patterns/const_patterns:109:30: This expression is not supported as a constant pattern.
      case const GenericClass<int>: // Error
                             ^

parser/patterns/const_patterns:110:37: This expression is not supported as a constant pattern.
      case const prefix.GenericClass<int>: // Error
                                    ^

beginCompilationUnit(import)
  beginMetadataStar(import)
  endMetadataStar(0)
  beginUncategorizedTopLevelDeclaration(import)
    beginImport(import)
      beginLiteralString('const_patterns.dart')
      endLiteralString(0, as)
      beginConditionalUris(as)
      endConditionalUris(0)
      handleIdentifier(prefix, importPrefixDeclaration)
      handleImportPrefix(null, as)
      beginCombinators(;)
      endCombinators(0)
    endImport(import, null, ;)
  endTopLevelDeclaration(;)
  beginMetadataStar(const)
  endMetadataStar(0)
  beginTopLevelMember(const)
    beginFields(DeclarationKind.TopLevel, null, null, null, null, null, null, const, ;)
      handleIdentifier(int, typeReference)
      handleNoTypeArguments(value)
      handleType(int, null)
      handleIdentifier(value, topLevelVariableDeclaration)
      beginFieldInitializer(=)
        handleLiteralInt(42)
      endFieldInitializer(=, 42)
    endTopLevelFields(null, null, null, null, null, const, 1, const, ;)
  endTopLevelDeclaration(;)
  beginMetadataStar(void)
  endMetadataStar(0)
  beginTopLevelMember(void)
    beginTopLevelMethod(;, null, null)
      handleVoidKeyword(void)
      handleIdentifier(func, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
      handleAsyncModifier(null, null)
      beginBlockFunctionBody({)
      endBlockFunctionBody(0, {, })
    endTopLevelMethod(void, null, })
  endTopLevelDeclaration(})
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
    handleIdentifier(Class, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, null, null, null, null, null, null, null, Class)
      handleNoType(Class)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
        beginMetadataStar(const)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, const, null, Class, Class)
            handleNoType(const)
            handleIdentifier(Class, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginOptionalFormalParameters([)
                beginMetadataStar(a)
                endMetadataStar(0)
                beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
                  handleNoType([)
                  handleIdentifier(a, formalParameterDeclaration)
                  handleFormalParameterWithoutValue(])
                endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalPositional, MemberKind.NonStaticMethod)
              endOptionalFormalParameters(1, [, ], MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            handleEmptyFunctionBody(;)
          endClassConstructor(null, const, (, null, ;)
        endMember()
        beginMetadataStar(const)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, const, null, Class, Class)
            handleNoType(const)
            handleIdentifier(Class, methodDeclaration)
            handleIdentifier(named, methodDeclarationContinuation)
            handleQualified(.)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
            endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            handleEmptyFunctionBody(;)
          endClassConstructor(null, const, (, null, ;)
        endMember()
        beginMetadataStar(call)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, call, Class)
            handleNoType(;)
            handleIdentifier(call, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
            endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            beginBlockFunctionBody({)
            endBlockFunctionBody(0, {, })
          endClassMethod(null, call, (, null, })
        endMember()
        beginMetadataStar(test)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, test, Class)
            handleNoType(})
            handleIdentifier(test, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginMetadataStar(o)
              endMetadataStar(0)
              beginFormalParameter(o, MemberKind.NonStaticMethod, null, null, null)
                handleNoType(()
                handleIdentifier(o, formalParameterDeclaration)
                handleFormalParameterWithoutValue())
              endFormalParameter(null, null, null, o, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(async, null)
            beginBlockFunctionBody({)
              beginMetadataStar(const)
              endMetadataStar(0)
              handleIdentifier(dynamic, typeReference)
              handleNoTypeArguments(local)
              handleType(dynamic, null)
              beginVariablesDeclaration(local, null, const)
                handleIdentifier(local, localVariableDeclaration)
                beginInitializedIdentifier(local)
                  beginVariableInitializer(=)
                    handleLiteralInt(0)
                  endVariableInitializer(=)
                endInitializedIdentifier(local)
              endVariablesDeclaration(1, ;)
              beginMetadataStar(dynamic)
              endMetadataStar(0)
              handleIdentifier(dynamic, typeReference)
              handleNoTypeArguments(variable)
              handleType(dynamic, null)
              beginVariablesDeclaration(variable, null, null)
                handleIdentifier(variable, localVariableDeclaration)
                beginInitializedIdentifier(variable)
                  beginVariableInitializer(=)
                    handleLiteralInt(0)
                  endVariableInitializer(=)
                endInitializedIdentifier(variable)
              endVariablesDeclaration(1, ;)
              beginSwitchStatement(switch)
                handleIdentifier(o, expression)
                handleNoTypeArguments())
                handleNoArguments())
                handleSend(o, ))
                handleParenthesizedCondition((, null, null)
                beginSwitchBlock({)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralBool(true)
                      endConstantPattern(null)
                    endPattern(true)
                    handleSwitchCaseNoWhenClause(true)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralNull(null)
                      endConstantPattern(null)
                    endPattern(null)
                    handleSwitchCaseNoWhenClause(null)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleThisExpression(this, expression)
                      endConstantPattern(null)
                    endPattern(this)
                    handleSwitchCaseNoWhenClause(this)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleThisExpression(this, expression)
                        handleNoTypeArguments(()
                        beginArguments(()
                        endArguments(0, (, ))
                        handleSend(this, :)
                      endConstantPattern(null)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleSuperExpression(super, expression)
                        handleNoTypeArguments(()
                        beginArguments(()
                        endArguments(0, (, ))
                        handleSend(super, :)
                      endConstantPattern(null)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralInt(42)
                      endConstantPattern(null)
                    endPattern(42)
                    handleSwitchCaseNoWhenClause(42)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralInt(42)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(null)
                    endPattern(42)
                    handleSwitchCaseNoWhenClause(42)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralDouble(42.5)
                      endConstantPattern(null)
                    endPattern(42.5)
                    handleSwitchCaseNoWhenClause(42.5)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralDouble(42.5)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(null)
                    endPattern(42.5)
                    handleSwitchCaseNoWhenClause(42.5)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        beginLiteralString('foo')
                        endLiteralString(0, :)
                      endConstantPattern(null)
                    endPattern('foo')
                    handleSwitchCaseNoWhenClause('foo')
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        beginLiteralString('foo')
                        endLiteralString(0, 'bar')
                        beginLiteralString('bar')
                        endLiteralString(0, :)
                        handleAdjacentStringLiterals(case, 2)
                      endConstantPattern(null)
                    endPattern('bar')
                    handleSwitchCaseNoWhenClause('bar')
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(value, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(value, :)
                      endConstantPattern(null)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(value, expression)
                        handleNoTypeArguments(!)
                        handleNoArguments(!)
                        handleSend(value, !)
                      endConstantPattern(null)
                      handleNullAssertPattern(!)
                    endPattern(!)
                    handleSwitchCaseNoWhenClause(!)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(value, expression)
                        handleNoTypeArguments(?)
                        handleNoArguments(?)
                        handleSend(value, ?)
                      endConstantPattern(null)
                      handleNullCheckPattern(?)
                    endPattern(?)
                    handleSwitchCaseNoWhenClause(?)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(value, expression)
                        handleNoTypeArguments(as)
                        handleNoArguments(as)
                        handleSend(value, as)
                      endConstantPattern(null)
                      beginAsOperatorType(as)
                        handleIdentifier(int, typeReference)
                        handleNoTypeArguments(:)
                        handleType(int, null)
                      endAsOperatorType(as)
                      handleCastPattern(as)
                    endPattern(int)
                    handleSwitchCaseNoWhenClause(int)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleRecoverableError(InvalidConstantPatternNegation, value, value)
                        handleIdentifier(value, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(value, :)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(null)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(local, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(local, :)
                      endConstantPattern(null)
                    endPattern(local)
                    handleSwitchCaseNoWhenClause(local)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleRecoverableError(InvalidConstantPatternNegation, local, local)
                        handleIdentifier(local, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(local, :)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(null)
                    endPattern(local)
                    handleSwitchCaseNoWhenClause(local)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(func, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(func, :)
                      endConstantPattern(null)
                    endPattern(func)
                    handleSwitchCaseNoWhenClause(func)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(value, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(value, :)
                        handleEndingBinaryExpression(., value)
                      endConstantPattern(null)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleRecoverableError(InvalidConstantPatternNegation, prefix, prefix)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleRecoverableError(InvalidConstantPatternNegation, value, value)
                        handleIdentifier(value, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(value, :)
                        handleEndingBinaryExpression(., value)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(null)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(Class, expressionContinuation)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(Class, .)
                        handleEndingBinaryExpression(., Class)
                        handleIdentifier(named, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(named, :)
                        handleEndingBinaryExpression(., named)
                      endConstantPattern(null)
                    endPattern(named)
                    handleSwitchCaseNoWhenClause(named)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralInt(1)
                        handleRecoverableError(Message[InvalidConstantPatternBinary, The binary operator + is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: +}], +, +)
                        beginBinaryExpression(+)
                          handleLiteralInt(2)
                        endBinaryExpression(+, 2)
                      endConstantPattern(null)
                    endPattern(2)
                    handleSwitchCaseNoWhenClause(2)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleLiteralInt(1)
                        handleRecoverableError(Message[InvalidConstantPatternBinary, The binary operator * is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: *}], *, *)
                        beginBinaryExpression(*)
                          handleLiteralInt(2)
                        endBinaryExpression(*, 2)
                      endConstantPattern(null)
                    endPattern(2)
                    handleSwitchCaseNoWhenClause(2)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      handleVoidKeyword(void)
                      handleDeclaredVariablePattern(null, fun, false)
                    endPattern(fun)
                    handleSwitchCaseNoWhenClause(fun)
                    handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], (, ()
                  endCaseExpression(case, null, :)
                  beginSwitchCase(0, 25, case)
                    handleNoTypeVariables(()
                    beginFunctionExpression(()
                      beginFormalParameters((, MemberKind.Local)
                      endFormalParameters(0, (, ), MemberKind.Local)
                      handleAsyncModifier(null, null)
                      beginBlockFunctionBody({)
                      endBlockFunctionBody(0, {, })
                    endFunctionExpression((, })
                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
                    handleExpressionStatement((, ;)
                    handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ':'., Try inserting an identifier before ':'., {lexeme: :}], :, :)
                    handleIdentifier(, expression)
                    handleNoTypeArguments(:)
                    handleNoArguments(:)
                    handleSend(, :)
                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
                    handleExpressionStatement(:, ;)
                    handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
                  endSwitchCase(0, 25, null, null, 2, case, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        beginAssert(assert, Assert.Expression)
                          handleLiteralBool(false)
                          handleRecoverableError(AssertAsExpression, assert, assert)
                        endAssert(assert, Assert.Expression, (, null, ))
                      endConstantPattern(null)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        beginSwitchExpression(switch)
                          handleIdentifier(o, expression)
                          handleNoTypeArguments())
                          handleNoArguments())
                          handleSend(o, ))
                          handleParenthesizedCondition((, null, null)
                          beginSwitchExpressionBlock({)
                            beginSwitchExpressionCase()
                              beginPattern({)
                                handleNoType(_)
                                handleWildcardPattern(null, _)
                              endPattern(_)
                              handleSwitchExpressionCasePattern(_)
                              handleLiteralBool(true)
                            endSwitchExpressionCase(_, null, =>, true)
                          endSwitchExpressionBlock(1, {, })
                        endSwitchExpression(switch, })
                      endConstantPattern(null)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        beginAwaitExpression(await)
                          handleLiteralInt(0)
                        endAwaitExpression(await, 0)
                      endConstantPattern(null)
                    endPattern(0)
                    handleSwitchCaseNoWhenClause(0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}], !, !)
                        handleLiteralBool(false)
                        handleUnaryPrefixExpression(!)
                      endConstantPattern(null)
                    endPattern(false)
                    handleSwitchCaseNoWhenClause(false)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}], ~, ~)
                        handleLiteralInt(0)
                        handleUnaryPrefixExpression(~)
                      endConstantPattern(null)
                    endPattern(0)
                    handleSwitchCaseNoWhenClause(0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(variable, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(variable, :)
                        handleUnaryPrefixAssignmentExpression(++)
                      endConstantPattern(null)
                    endPattern(variable)
                    handleSwitchCaseNoWhenClause(variable)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, 0, 0)
                        handleLiteralInt(0)
                      endConstantPattern(const)
                    endPattern(0)
                    handleSwitchCaseNoWhenClause(0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, 0x0, 0x0)
                        handleLiteralInt(0x0)
                      endConstantPattern(const)
                    endPattern(0x0)
                    handleSwitchCaseNoWhenClause(0x0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, 0.5, 0.5)
                        handleLiteralDouble(0.5)
                      endConstantPattern(const)
                    endPattern(0.5)
                    handleSwitchCaseNoWhenClause(0.5)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, true, true)
                        handleLiteralBool(true)
                      endConstantPattern(const)
                    endPattern(true)
                    handleSwitchCaseNoWhenClause(true)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, null, null)
                        handleLiteralNull(null)
                      endConstantPattern(const)
                    endPattern(null)
                    handleSwitchCaseNoWhenClause(null)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, -, -)
                        handleLiteralInt(0)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(const)
                    endPattern(0)
                    handleSwitchCaseNoWhenClause(0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, 'foo', 'foo')
                        beginLiteralString('foo')
                        endLiteralString(0, :)
                      endConstantPattern(const)
                    endPattern('foo')
                    handleSwitchCaseNoWhenClause('foo')
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, #, #)
                        beginLiteralSymbol(#)
                          handleIdentifier(a, literalSymbol)
                        endLiteralSymbol(#, 1)
                      endConstantPattern(const)
                    endPattern(a)
                    handleSwitchCaseNoWhenClause(a)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(value, expression)
                        handleNoTypeArguments(:)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, value, value)
                        handleNoArguments(:)
                        handleSend(value, :)
                      endConstantPattern(const)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(local, expression)
                        handleNoTypeArguments(:)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, local, local)
                        handleNoArguments(:)
                        handleSend(local, :)
                      endConstantPattern(const)
                    endPattern(local)
                    handleSwitchCaseNoWhenClause(local)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(value, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, value, value)
                        handleNoArguments(:)
                        handleSend(value, :)
                        handleEndingBinaryExpression(., value)
                      endConstantPattern(const)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, -, -)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(value, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(value, :)
                        handleEndingBinaryExpression(., value)
                        handleUnaryPrefixExpression(-)
                      endConstantPattern(const)
                    endPattern(value)
                    handleSwitchCaseNoWhenClause(value)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(Class, expressionContinuation)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(Class, .)
                        handleEndingBinaryExpression(., Class)
                        handleIdentifier(named, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, named, named)
                        handleNoArguments(:)
                        handleSend(named, :)
                        handleEndingBinaryExpression(., named)
                      endConstantPattern(const)
                    endPattern(named)
                    handleSwitchCaseNoWhenClause(named)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
                        handleLiteralInt(1)
                        handleRecoverableError(InvalidConstantPatternConstPrefix, 1, 1)
                        beginBinaryExpression(+)
                          handleLiteralInt(2)
                        endBinaryExpression(+, 2)
                      endConstantPattern(const)
                    endPattern(2)
                    handleSwitchCaseNoWhenClause(2)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleNoTypeVariables(()
                        beginNamedFunctionExpression(void)
                          handleVoidKeyword(void)
                          beginFunctionName(fun)
                            handleIdentifier(fun, localFunctionDeclaration)
                            handleRecoverableError(NamedFunctionExpression, fun, fun)
                          endFunctionName(void, ()
                          beginFormalParameters((, MemberKind.Local)
                          endFormalParameters(0, (, ), MemberKind.Local)
                          handleNoInitializers()
                          handleAsyncModifier(null, null)
                          beginBlockFunctionBody({)
                          endBlockFunctionBody(0, {, })
                        endNamedFunctionExpression(})
                      endConstantPattern(const)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginAssert(assert, Assert.Expression)
                          handleLiteralBool(false)
                          handleRecoverableError(AssertAsExpression, assert, assert)
                        endAssert(assert, Assert.Expression, (, null, ))
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginSwitchExpression(switch)
                          handleIdentifier(o, expression)
                          handleNoTypeArguments())
                          handleNoArguments())
                          handleSend(o, ))
                          handleParenthesizedCondition((, null, null)
                          beginSwitchExpressionBlock({)
                            beginSwitchExpressionCase()
                              beginPattern({)
                                handleNoType(_)
                                handleWildcardPattern(null, _)
                              endPattern(_)
                              handleSwitchExpressionCasePattern(_)
                              handleLiteralBool(true)
                            endSwitchExpressionCase(_, null, =>, true)
                          endSwitchExpressionBlock(1, {, })
                        endSwitchExpression(switch, })
                      endConstantPattern(const)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginAwaitExpression(await)
                          handleLiteralInt(0)
                        endAwaitExpression(await, 0)
                      endConstantPattern(const)
                    endPattern(0)
                    handleSwitchCaseNoWhenClause(0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}], !, !)
                        handleLiteralBool(false)
                        handleUnaryPrefixExpression(!)
                      endConstantPattern(const)
                    endPattern(false)
                    handleSwitchCaseNoWhenClause(false)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}], ~, ~)
                        handleLiteralInt(0)
                        handleUnaryPrefixExpression(~)
                      endConstantPattern(const)
                    endPattern(0)
                    handleSwitchCaseNoWhenClause(0)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(variable, expression)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(variable, :)
                        handleUnaryPrefixAssignmentExpression(++)
                      endConstantPattern(const)
                    endPattern(variable)
                    handleSwitchCaseNoWhenClause(variable)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(Class, expression)
                        handleNoTypeArguments(()
                        beginArguments(()
                        endArguments(0, (, ))
                        handleSend(Class, :)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(Class, expression)
                        handleNoTypeArguments(()
                        beginArguments(()
                          handleLiteralInt(0)
                        endArguments(1, (, ))
                        handleSend(Class, :)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(GenericClass, expression)
                        handleNoTypeArguments(()
                        beginArguments(()
                        endArguments(0, (, ))
                        handleSend(GenericClass, :)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(GenericClass, expression)
                        handleNoTypeArguments(()
                        beginArguments(()
                          handleIdentifier(a, namedArgumentReference)
                          handleLiteralInt(0)
                          handleNamedArgument(:)
                        endArguments(1, (, ))
                        handleSend(GenericClass, :)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(GenericClass, expression)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        beginArguments(()
                        endArguments(0, (, ))
                        handleSend(GenericClass, :)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(GenericClass, expression)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        beginArguments(()
                          handleIdentifier(a, namedArgumentReference)
                          handleLiteralInt(0)
                          handleNamedArgument(:)
                        endArguments(1, (, ))
                        handleSend(GenericClass, :)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginImplicitCreationExpression(GenericClass)
                          handleIdentifier(GenericClass, constructorReference)
                          beginConstructorReference(GenericClass)
                            beginTypeArguments(<)
                              handleIdentifier(int, typeReference)
                              handleNoTypeArguments(>)
                              handleType(int, null)
                            endTypeArguments(1, <, >)
                            handleNewAsIdentifier(new)
                            handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
                          endConstructorReference(GenericClass, ., new, ConstructorReferenceContext.Implicit)
                          beginArguments(()
                          endArguments(0, (, ))
                        endImplicitCreationExpression(GenericClass, <)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginImplicitCreationExpression(GenericClass)
                          handleIdentifier(GenericClass, constructorReference)
                          beginConstructorReference(GenericClass)
                            beginTypeArguments(<)
                              handleIdentifier(int, typeReference)
                              handleNoTypeArguments(>)
                              handleType(int, null)
                            endTypeArguments(1, <, >)
                            handleNewAsIdentifier(new)
                            handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
                          endConstructorReference(GenericClass, ., new, ConstructorReferenceContext.Implicit)
                          beginArguments(()
                            handleIdentifier(a, namedArgumentReference)
                            handleLiteralInt(1)
                            handleNamedArgument(:)
                          endArguments(1, (, ))
                        endImplicitCreationExpression(GenericClass, <)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleNoTypeArguments([])
                        handleLiteralList(0, [, null, ])
                      endConstantPattern(const)
                    endPattern(])
                    handleSwitchCaseNoWhenClause(])
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleLiteralList(0, [, null, ])
                      endConstantPattern(const)
                    endPattern(])
                    handleSwitchCaseNoWhenClause(])
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleNoTypeArguments({)
                        handleLiteralSetOrMap(0, {, null, }, false)
                      endConstantPattern(const)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(,)
                          handleType(int, null)
                          handleIdentifier(String, typeReference)
                          handleNoTypeArguments(>)
                          handleType(String, null)
                        endTypeArguments(2, <, >)
                        handleLiteralSetOrMap(0, {, null, }, false)
                      endConstantPattern(const)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstExpression(const)
                          handleIdentifier(Class, constructorReference)
                          beginConstructorReference(Class)
                            handleNoTypeArguments(()
                            handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
                          endConstructorReference(Class, null, Class, ConstructorReferenceContext.Const)
                          beginArguments(()
                          endArguments(0, (, ))
                        endConstExpression(const)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstExpression(const)
                          handleIdentifier(Class, constructorReference)
                          beginConstructorReference(Class)
                            handleNoTypeArguments(()
                            handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
                          endConstructorReference(Class, null, Class, ConstructorReferenceContext.Const)
                          beginArguments(()
                            handleLiteralInt(0)
                          endArguments(1, (, ))
                        endConstExpression(const)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstExpression(const)
                          handleIdentifier(GenericClass, constructorReference)
                          beginConstructorReference(GenericClass)
                            handleNoTypeArguments(()
                            handleNoConstructorReferenceContinuationAfterTypeArguments(GenericClass)
                          endConstructorReference(GenericClass, null, GenericClass, ConstructorReferenceContext.Const)
                          beginArguments(()
                          endArguments(0, (, ))
                        endConstExpression(const)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstExpression(const)
                          handleIdentifier(GenericClass, constructorReference)
                          beginConstructorReference(GenericClass)
                            handleNoTypeArguments(()
                            handleNoConstructorReferenceContinuationAfterTypeArguments(GenericClass)
                          endConstructorReference(GenericClass, null, GenericClass, ConstructorReferenceContext.Const)
                          beginArguments(()
                            handleIdentifier(a, namedArgumentReference)
                            handleLiteralInt(0)
                            handleNamedArgument(:)
                          endArguments(1, (, ))
                        endConstExpression(const)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstExpression(const)
                          handleIdentifier(GenericClass, constructorReference)
                          beginConstructorReference(GenericClass)
                            beginTypeArguments(<)
                              handleIdentifier(int, typeReference)
                              handleNoTypeArguments(>)
                              handleType(int, null)
                            endTypeArguments(1, <, >)
                            handleNoConstructorReferenceContinuationAfterTypeArguments(>)
                          endConstructorReference(GenericClass, null, >, ConstructorReferenceContext.Const)
                          beginArguments(()
                          endArguments(0, (, ))
                        endConstExpression(const)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstExpression(const)
                          handleIdentifier(GenericClass, constructorReference)
                          beginConstructorReference(GenericClass)
                            beginTypeArguments(<)
                              handleIdentifier(int, typeReference)
                              handleNoTypeArguments(>)
                              handleType(int, null)
                            endTypeArguments(1, <, >)
                            handleNoConstructorReferenceContinuationAfterTypeArguments(>)
                          endConstructorReference(GenericClass, null, >, ConstructorReferenceContext.Const)
                          beginArguments(()
                            handleIdentifier(a, namedArgumentReference)
                            handleLiteralInt(0)
                            handleNamedArgument(:)
                          endArguments(1, (, ))
                        endConstExpression(const)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstLiteral([])
                          handleNoTypeArguments([])
                          handleLiteralList(0, [, const, ])
                        endConstLiteral(])
                      endConstantPattern(const)
                    endPattern(])
                    handleSwitchCaseNoWhenClause(])
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstLiteral(<)
                          beginTypeArguments(<)
                            handleIdentifier(int, typeReference)
                            handleNoTypeArguments(>)
                            handleType(int, null)
                          endTypeArguments(1, <, >)
                          handleLiteralList(0, [, const, ])
                        endConstLiteral(])
                      endConstantPattern(const)
                    endPattern(])
                    handleSwitchCaseNoWhenClause(])
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstLiteral({)
                          handleNoTypeArguments({)
                          handleLiteralSetOrMap(0, {, const, }, false)
                        endConstLiteral(})
                      endConstantPattern(const)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstLiteral(<)
                          beginTypeArguments(<)
                            handleIdentifier(int, typeReference)
                            handleNoTypeArguments(,)
                            handleType(int, null)
                            handleIdentifier(String, typeReference)
                            handleNoTypeArguments(>)
                            handleType(String, null)
                          endTypeArguments(2, <, >)
                          handleLiteralSetOrMap(0, {, const, }, false)
                        endConstLiteral(})
                      endConstantPattern(const)
                    endPattern(})
                    handleSwitchCaseNoWhenClause(})
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginNewExpression(new)
                          handleIdentifier(Class, constructorReference)
                          beginConstructorReference(Class)
                            handleNoTypeArguments(()
                            handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
                          endConstructorReference(Class, null, Class, ConstructorReferenceContext.New)
                          beginArguments(()
                          endArguments(0, (, ))
                        endNewExpression(new)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        beginNewExpression(new)
                          handleIdentifier(Class, constructorReference)
                          beginConstructorReference(Class)
                            handleNoTypeArguments(()
                            handleNoConstructorReferenceContinuationAfterTypeArguments(Class)
                          endConstructorReference(Class, null, Class, ConstructorReferenceContext.New)
                          beginArguments(()
                          endArguments(0, (, ))
                        endNewExpression(new)
                      endConstantPattern(null)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleRecoverableError(InvalidConstantPatternEmptyRecordLiteral, (, ()
                        endRecordLiteral((, 0, null)
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
                        beginConstLiteral(()
                          beginParenthesizedExpressionOrRecordLiteral(()
                          endRecordLiteral((, 0, const)
                        endConstLiteral())
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleLiteralInt(1)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleLiteralInt(1)
                          handleUnaryPrefixExpression(-)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleIdentifier(value, expression)
                          handleNoTypeArguments())
                          handleNoArguments())
                          handleSend(value, ))
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleIdentifier(value, expression)
                          handleNoTypeArguments())
                          handleNoArguments())
                          handleSend(value, ))
                          handleUnaryPrefixExpression(-)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleLiteralInt(1)
                          beginBinaryExpression(+)
                            handleLiteralInt(2)
                          endBinaryExpression(+, 2)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(GenericClass, expression)
                        handleNoTypeArguments(<)
                        handleNoArguments(<)
                        handleSend(GenericClass, <)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleRecoverableError(InvalidConstantPatternGeneric, <, <)
                        handleTypeArgumentApplication(<)
                      endConstantPattern(null)
                    endPattern(>)
                    handleSwitchCaseNoWhenClause(>)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(GenericClass, expressionContinuation)
                        handleNoTypeArguments(<)
                        handleNoArguments(<)
                        handleSend(GenericClass, <)
                        handleEndingBinaryExpression(., GenericClass)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleRecoverableError(InvalidConstantPatternGeneric, <, <)
                        handleTypeArgumentApplication(<)
                      endConstantPattern(null)
                    endPattern(>)
                    handleSwitchCaseNoWhenClause(>)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(GenericClass, expression)
                        handleNoTypeArguments(<)
                        handleNoArguments(<)
                        handleSend(GenericClass, <)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleRecoverableError(InvalidConstantPatternGeneric, <, <)
                        handleTypeArgumentApplication(<)
                        handleNewAsIdentifier(new)
                        handleIdentifier(new, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(new, :)
                        handleEndingBinaryExpression(., new)
                      endConstantPattern(null)
                    endPattern(new)
                    handleSwitchCaseNoWhenClause(new)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(null)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(GenericClass, expressionContinuation)
                        handleNoTypeArguments(<)
                        handleNoArguments(<)
                        handleSend(GenericClass, <)
                        handleEndingBinaryExpression(., GenericClass)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleRecoverableError(InvalidConstantPatternGeneric, <, <)
                        handleTypeArgumentApplication(<)
                        handleNewAsIdentifier(new)
                        handleIdentifier(new, expressionContinuation)
                        handleNoTypeArguments(:)
                        handleNoArguments(:)
                        handleSend(new, :)
                        handleEndingBinaryExpression(., new)
                      endConstantPattern(null)
                    endPattern(new)
                    handleSwitchCaseNoWhenClause(new)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(GenericClass, expression)
                        handleNoTypeArguments(<)
                        handleNoArguments(<)
                        handleSend(GenericClass, <)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleRecoverableError(InvalidConstantPatternGeneric, <, <)
                        handleTypeArgumentApplication(<)
                      endConstantPattern(const)
                    endPattern(>)
                    handleSwitchCaseNoWhenClause(>)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        handleIdentifier(prefix, expression)
                        handleNoTypeArguments(.)
                        handleNoArguments(.)
                        handleSend(prefix, .)
                        handleIdentifier(GenericClass, expressionContinuation)
                        handleNoTypeArguments(<)
                        handleNoArguments(<)
                        handleSend(GenericClass, <)
                        handleEndingBinaryExpression(., GenericClass)
                        beginTypeArguments(<)
                          handleIdentifier(int, typeReference)
                          handleNoTypeArguments(>)
                          handleType(int, null)
                        endTypeArguments(1, <, >)
                        handleRecoverableError(InvalidConstantPatternGeneric, <, <)
                        handleTypeArgumentApplication(<)
                      endConstantPattern(const)
                    endPattern(>)
                    handleSwitchCaseNoWhenClause(>)
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleIdentifier(GenericClass, expression)
                          handleNoTypeArguments(<)
                          handleNoArguments(<)
                          handleSend(GenericClass, <)
                          beginTypeArguments(<)
                            handleIdentifier(int, typeReference)
                            handleNoTypeArguments(>)
                            handleType(int, null)
                          endTypeArguments(1, <, >)
                          handleTypeArgumentApplication(<)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleIdentifier(prefix, expression)
                          handleNoTypeArguments(.)
                          handleNoArguments(.)
                          handleSend(prefix, .)
                          handleIdentifier(GenericClass, expressionContinuation)
                          handleNoTypeArguments(<)
                          handleNoArguments(<)
                          handleSend(GenericClass, <)
                          handleEndingBinaryExpression(., GenericClass)
                          beginTypeArguments(<)
                            handleIdentifier(int, typeReference)
                            handleNoTypeArguments(>)
                            handleType(int, null)
                          endTypeArguments(1, <, >)
                          handleTypeArgumentApplication(<)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleIdentifier(GenericClass, expression)
                          handleNoTypeArguments(<)
                          handleNoArguments(<)
                          handleSend(GenericClass, <)
                          beginTypeArguments(<)
                            handleIdentifier(int, typeReference)
                            handleNoTypeArguments(>)
                            handleType(int, null)
                          endTypeArguments(1, <, >)
                          handleTypeArgumentApplication(<)
                          handleNewAsIdentifier(new)
                          handleIdentifier(new, expressionContinuation)
                          handleNoTypeArguments())
                          handleNoArguments())
                          handleSend(new, ))
                          handleEndingBinaryExpression(., new)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginCaseExpression(case)
                    beginPattern(case)
                      beginConstantPattern(const)
                        beginParenthesizedExpressionOrRecordLiteral(()
                          handleIdentifier(prefix, expression)
                          handleNoTypeArguments(.)
                          handleNoArguments(.)
                          handleSend(prefix, .)
                          handleIdentifier(GenericClass, expressionContinuation)
                          handleNoTypeArguments(<)
                          handleNoArguments(<)
                          handleSend(GenericClass, <)
                          handleEndingBinaryExpression(., GenericClass)
                          beginTypeArguments(<)
                            handleIdentifier(int, typeReference)
                            handleNoTypeArguments(>)
                            handleType(int, null)
                          endTypeArguments(1, <, >)
                          handleTypeArgumentApplication(<)
                          handleNewAsIdentifier(new)
                          handleIdentifier(new, expressionContinuation)
                          handleNoTypeArguments())
                          handleNoArguments())
                          handleSend(new, ))
                          handleEndingBinaryExpression(., new)
                        endParenthesizedExpression(()
                      endConstantPattern(const)
                    endPattern())
                    handleSwitchCaseNoWhenClause())
                  endCaseExpression(case, null, :)
                  beginSwitchCase(0, 68, case)
                    handleIdentifier(print, expression)
                    handleNoTypeArguments(()
                    beginArguments(()
                      handleLiteralInt(0)
                    endArguments(1, (, ))
                    handleSend(print, ;)
                    handleExpressionStatement(print, ;)
                  endSwitchCase(0, 68, null, null, 1, case, ;)
                endSwitchBlock(2, {, })
              endSwitchStatement(switch, })
            endBlockFunctionBody(3, {, })
          endClassMethod(null, test, (, null, })
        endMember()
      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 4, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(})
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
    handleIdentifier(GenericClass, classOrMixinDeclaration)
    beginTypeVariables(<)
      beginMetadataStar(T)
      endMetadataStar(0)
      handleIdentifier(T, typeVariableDeclaration)
      beginTypeVariable(T)
        handleTypeVariablesDefined(T, 1)
        handleNoType(T)
      endTypeVariable(>, 0, null, null)
    endTypeVariables(<, >)
    beginClassDeclaration(class, null, null, null, null, null, null, null, null, GenericClass)
      handleNoType(>)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
        beginMetadataStar(const)
        endMetadataStar(0)
        beginMember()
          beginMethod(DeclarationKind.Class, null, null, null, null, const, null, GenericClass, GenericClass)
            handleNoType(const)
            handleIdentifier(GenericClass, methodDeclaration)
            handleNoTypeVariables(()
            beginFormalParameters((, MemberKind.NonStaticMethod)
              beginOptionalFormalParameters({)
                beginMetadataStar(a)
                endMetadataStar(0)
                beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
                  handleNoType({)
                  handleIdentifier(a, formalParameterDeclaration)
                  handleFormalParameterWithoutValue(})
                endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
              endOptionalFormalParameters(1, {, }, MemberKind.NonStaticMethod)
            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
            handleNoInitializers()
            handleAsyncModifier(null, null)
            handleEmptyFunctionBody(;)
          endClassConstructor(null, const, (, null, ;)
        endMember()
      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration(})
endCompilationUnit(5, )