pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect

parseUnit(int)
  skipErrorTokens(int)
  listener: beginCompilationUnit(int)
  syntheticPreviousToken(int)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(, null, , Instance of 'SimpleType', null, abstract, false)
        listener: beginTopLevelMethod(, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(abstract)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(abstract, topLevelFunctionDeclaration)
        parseMethodTypeVar(abstract)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(abstract, abstract, false, MemberKind.TopLevelMethod)
          parseFormalParameters(abstract, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(abstract, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(abstract)
                              parseArguments(abstract)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(abstract, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, as, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(as)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(as, topLevelFunctionDeclaration)
        parseMethodTypeVar(as)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(as, as, false, MemberKind.TopLevelMethod)
          parseFormalParameters(as, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(as, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(as)
                              parseArguments(as)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(as, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(assert)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, assert, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(assert)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(assert, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: assert}], assert, assert)
          listener: handleIdentifier(assert, topLevelFunctionDeclaration)
        parseMethodTypeVar(assert)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(assert, assert, false, MemberKind.TopLevelMethod)
          parseFormalParameters(assert, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseAssert(return, Assert.Expression)
                          listener: beginAssert(assert, Assert.Expression)
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseSendOrFunctionLiteral((, expression)
                                    parseSend((, expression)
                                      ensureIdentifier((, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(-)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(-)
                                      listener: handleSend(x, -)
                              listener: beginBinaryExpression(-)
                              parsePrecedenceExpression(-, 14, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseLiteralInt(-)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(-)
                          reportRecoverableError(assert, AssertAsExpression)
                            listener: handleRecoverableError(AssertAsExpression, assert, assert)
                          listener: endAssert(assert, Assert.Expression, (, null, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, async, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(async)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(async, topLevelFunctionDeclaration)
        parseMethodTypeVar(async)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(async, async, false, MemberKind.TopLevelMethod)
          parseFormalParameters(async, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(async, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(async)
                              parseArguments(async)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(async, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, await, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(await)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(await, topLevelFunctionDeclaration)
        parseMethodTypeVar(await)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(await, await, false, MemberKind.TopLevelMethod)
          parseFormalParameters(await, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      inPlainSync()
                      looksLikeAwaitExpression(return)
                        looksLikeExpression(await)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(await, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(await)
                              parseArguments(await)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(await, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(break)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, break, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(break)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: break}], break, break)
          listener: handleIdentifier(break, topLevelFunctionDeclaration)
        parseMethodTypeVar(break)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(break, break, false, MemberKind.TopLevelMethod)
          parseFormalParameters(break, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {token: break}], break, break)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(break)
                          parseArgumentsOpt()
                            listener: handleNoArguments(break)
                          listener: handleSend(, break)
                ensureSemicolon()
                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, break)
          parseStatement(;)
            parseStatementX(;)
              parseBreakStatement(;)
                isBreakAllowed()
                reportRecoverableError(break, BreakOutsideOfLoop)
                  listener: handleRecoverableError(BreakOutsideOfLoop, break, break)
                ensureSemicolon(break)
                  reportRecoverableError(break, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break)
                  rewriter()
                listener: handleBreakStatement(false, break, ;)
          notEofOrValue(}, ()
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(;)
                              parseParenthesizedExpression(;)
                                parseExpressionInParenthesis(;)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(case)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, case, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(case)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: case}], case, case)
          listener: handleIdentifier(case, topLevelFunctionDeclaration)
        parseMethodTypeVar(case)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(case, case, false, MemberKind.TopLevelMethod)
          parseFormalParameters(case, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: case}], case, case)
                            listener: handleIdentifier(case, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(case)
                            parseArguments(case)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(case, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(catch)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, catch, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(catch)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: catch}], catch, catch)
          listener: handleIdentifier(catch, topLevelFunctionDeclaration)
        parseMethodTypeVar(catch)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(catch, catch, false, MemberKind.TopLevelMethod)
          parseFormalParameters(catch, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: catch}], catch, catch)
                            listener: handleIdentifier(catch, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(catch)
                            parseArguments(catch)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(catch, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(class)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, class, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(class)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: class}], class, class)
          listener: handleIdentifier(class, topLevelFunctionDeclaration)
        parseMethodTypeVar(class)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(class, class, false, MemberKind.TopLevelMethod)
          parseFormalParameters(class, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: class}], class, class)
                            listener: handleIdentifier(class, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(class)
                            parseArguments(class)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(class, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(const)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, const, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(const)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(const, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: const}], const, const)
          listener: handleIdentifier(const, topLevelFunctionDeclaration)
        parseMethodTypeVar(const)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(const, const, false, MemberKind.TopLevelMethod)
          parseFormalParameters(const, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseConstExpression(return)
                          listener: beginConstExpression(const)
                          parseConstructorReference(const, null)
                            ensureIdentifier(const, constructorReference)
                              insertSyntheticIdentifier(const, constructorReference, message: Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {token: (}], messageOnToken: null)
                                reportRecoverableError((, Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {token: (}])
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {token: (}], (, ()
                                rewriter()
                              listener: handleIdentifier(, constructorReference)
                            listener: beginConstructorReference()
                            parseQualifiedRestOpt(, constructorReferenceContinuation)
                            listener: handleNoTypeArguments(()
                            listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                            listener: endConstructorReference(, null, ()
                          parseConstructorInvocationArguments()
                            parseArgumentsRest(()
                              listener: beginArguments(()
                              parseExpression(()
                                parsePrecedenceExpression((, 1, true)
                                  parseUnaryExpression((, true)
                                    parsePrimary((, expression)
                                      parseSendOrFunctionLiteral((, expression)
                                        parseSend((, expression)
                                          ensureIdentifier((, expression)
                                            listener: handleIdentifier(x, expression)
                                          listener: handleNoTypeArguments(-)
                                          parseArgumentsOpt(x)
                                            listener: handleNoArguments(-)
                                          listener: handleSend(x, -)
                                  listener: beginBinaryExpression(-)
                                  parsePrecedenceExpression(-, 14, true)
                                    parseUnaryExpression(-, true)
                                      parsePrimary(-, expression)
                                        parseLiteralInt(-)
                                          listener: handleLiteralInt(1)
                                  listener: endBinaryExpression(-)
                              listener: endArguments(1, (, ))
                          listener: endConstExpression(const)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(continue)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, continue, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(continue)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: continue}], continue, continue)
          listener: handleIdentifier(continue, topLevelFunctionDeclaration)
        parseMethodTypeVar(continue)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(continue, continue, false, MemberKind.TopLevelMethod)
          parseFormalParameters(continue, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {token: continue}], continue, continue)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(continue)
                          parseArgumentsOpt()
                            listener: handleNoArguments(continue)
                          listener: handleSend(, continue)
                ensureSemicolon()
                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, continue)
          parseStatement(;)
            parseStatementX(;)
              parseContinueStatement(;)
                isContinueAllowed()
                reportRecoverableError(continue, ContinueOutsideOfLoop)
                  listener: handleRecoverableError(ContinueOutsideOfLoop, continue, continue)
                ensureSemicolon(continue)
                  reportRecoverableError(continue, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue)
                  rewriter()
                listener: handleContinueStatement(false, continue, ;)
          notEofOrValue(}, ()
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(;)
                              parseParenthesizedExpression(;)
                                parseExpressionInParenthesis(;)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, covariant, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(covariant)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(covariant, topLevelFunctionDeclaration)
        parseMethodTypeVar(covariant)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(covariant, covariant, false, MemberKind.TopLevelMethod)
          parseFormalParameters(covariant, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(covariant, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(covariant)
                              parseArguments(covariant)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(covariant, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(default)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, default, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(default)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: default}], default, default)
          listener: handleIdentifier(default, topLevelFunctionDeclaration)
        parseMethodTypeVar(default)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(default, default, false, MemberKind.TopLevelMethod)
          parseFormalParameters(default, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: default}], default, default)
                            listener: handleIdentifier(default, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(default)
                            parseArguments(default)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(default, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, deferred, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(deferred)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(deferred, topLevelFunctionDeclaration)
        parseMethodTypeVar(deferred)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(deferred, deferred, false, MemberKind.TopLevelMethod)
          parseFormalParameters(deferred, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(deferred, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(deferred)
                              parseArguments(deferred)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(deferred, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(do)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, do, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(do)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: do}], do, do)
          listener: handleIdentifier(do, topLevelFunctionDeclaration)
        parseMethodTypeVar(do)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(do, do, false, MemberKind.TopLevelMethod)
          parseFormalParameters(do, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {token: do}], do, do)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(do)
                          parseArgumentsOpt()
                            listener: handleNoArguments(do)
                          listener: handleSend(, do)
                ensureSemicolon()
                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], do, do)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, do)
          parseStatement(;)
            parseStatementX(;)
              parseDoWhileStatement(;)
                listener: beginDoWhileStatement(do)
                listener: beginDoWhileStatementBody(()
                parseStatement(do)
                  parseStatementX(do)
                    parseExpressionStatementOrDeclaration(do, false)
                      parseExpressionStatementOrDeclarationAfterModifiers(do, do, null, null, null, false)
                        looksLikeLocalFunction(()
                        parseExpressionStatement(do)
                          parseExpression(do)
                            parsePrecedenceExpression(do, 1, true)
                              parseUnaryExpression(do, true)
                                parsePrimary(do, expression)
                                  parseParenthesizedExpressionOrFunctionLiteral(do)
                                    parseParenthesizedExpression(do)
                                      parseExpressionInParenthesis(do)
                                        parseExpressionInParenthesisRest(()
                                          parseExpression(()
                                            parsePrecedenceExpression((, 1, true)
                                              parseUnaryExpression((, true)
                                                parsePrimary((, expression)
                                                  parseSendOrFunctionLiteral((, expression)
                                                    parseSend((, expression)
                                                      ensureIdentifier((, expression)
                                                        listener: handleIdentifier(x, expression)
                                                      listener: handleNoTypeArguments(-)
                                                      parseArgumentsOpt(x)
                                                        listener: handleNoArguments(-)
                                                      listener: handleSend(x, -)
                                              listener: beginBinaryExpression(-)
                                              parsePrecedenceExpression(-, 14, true)
                                                parseUnaryExpression(-, true)
                                                  parsePrimary(-, expression)
                                                    parseLiteralInt(-)
                                                      listener: handleLiteralInt(1)
                                              listener: endBinaryExpression(-)
                                          ensureCloseParen(1, ()
                                      listener: handleParenthesizedExpression(()
                              listener: beginBinaryExpression(+)
                              parsePrecedenceExpression(+, 14, true)
                                parseUnaryExpression(+, true)
                                  parsePrimary(+, expression)
                                    parseLiteralInt(+)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(+)
                          ensureSemicolon(1)
                          listener: handleExpressionStatement(;)
                listener: endDoWhileStatementBody(;)
                reportRecoverableError(}, Message[ExpectedButGot, Expected 'while' before this., null, {string: while}])
                  listener: handleRecoverableError(Message[ExpectedButGot, Expected 'while' before this., null, {string: while}], }, })
                rewriter()
                ensureParenthesizedCondition(while)
                  reportRecoverableError(}, Message[ExpectedToken, Expected to find '('., null, {string: (}])
                    listener: handleRecoverableError(Message[ExpectedToken, Expected to find '('., null, {string: (}], }, })
                  rewriter()
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSend((, expression)
                              ensureIdentifier((, expression)
                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {token: }}], }, })
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments())
                              parseArgumentsOpt()
                                listener: handleNoArguments())
                              listener: handleSend(, ))
                    ensureCloseParen(, ()
                  listener: handleParenthesizedCondition(()
                ensureSemicolon())
                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
                  rewriter()
                listener: endDoWhileStatement(do, while, ;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(3, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, dynamic, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(dynamic)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(dynamic, topLevelFunctionDeclaration)
        parseMethodTypeVar(dynamic)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(dynamic, dynamic, false, MemberKind.TopLevelMethod)
          parseFormalParameters(dynamic, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(dynamic, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(dynamic)
                              parseArguments(dynamic)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(dynamic, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(else)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, else, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(else)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: else}], else, else)
          listener: handleIdentifier(else, topLevelFunctionDeclaration)
        parseMethodTypeVar(else)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(else, else, false, MemberKind.TopLevelMethod)
          parseFormalParameters(else, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {token: else}], else, else)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(else)
                          parseArgumentsOpt()
                            listener: handleNoArguments(else)
                          listener: handleSend(, else)
                ensureSemicolon()
                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, else)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction(else)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            inPlainSync()
                            parseSend(;, expression)
                              ensureIdentifier(;, expression)
                                reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {token: else}], else, else)
                                rewriter()
                                listener: handleIdentifier(, expression)
                              listener: handleNoTypeArguments(else)
                              parseArgumentsOpt()
                                listener: handleNoArguments(else)
                              listener: handleSend(, else)
                    ensureSemicolon()
                      reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                        listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else)
                      rewriter()
                    listener: handleExpressionStatement(;)
          reportRecoverableError(;, Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}])
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], else, else)
          notEofOrValue(}, ()
          parseStatement(else)
            parseStatementX(else)
              parseExpressionStatementOrDeclaration(else, false)
                parseExpressionStatementOrDeclarationAfterModifiers(else, else, null, null, null, false)
                  looksLikeLocalFunction(()
                  parseExpressionStatement(else)
                    parseExpression(else)
                      parsePrecedenceExpression(else, 1, true)
                        parseUnaryExpression(else, true)
                          parsePrimary(else, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(else)
                              parseParenthesizedExpression(else)
                                parseExpressionInParenthesis(else)
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(x, expression)
                                                listener: handleNoTypeArguments(-)
                                                parseArgumentsOpt(x)
                                                  listener: handleNoArguments(-)
                                                listener: handleSend(x, -)
                                        listener: beginBinaryExpression(-)
                                        parsePrecedenceExpression(-, 14, true)
                                          parseUnaryExpression(-, true)
                                            parsePrimary(-, expression)
                                              parseLiteralInt(-)
                                                listener: handleLiteralInt(1)
                                        listener: endBinaryExpression(-)
                                    ensureCloseParen(1, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(4, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(enum)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, enum, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(enum)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: enum}], enum, enum)
          listener: handleIdentifier(enum, topLevelFunctionDeclaration)
        parseMethodTypeVar(enum)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(enum, enum, false, MemberKind.TopLevelMethod)
          parseFormalParameters(enum, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: enum}], enum, enum)
                            listener: handleIdentifier(enum, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(enum)
                            parseArguments(enum)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(enum, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, export, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(export)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(export, topLevelFunctionDeclaration)
        parseMethodTypeVar(export)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(export, export, false, MemberKind.TopLevelMethod)
          parseFormalParameters(export, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(export, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(export)
                              parseArguments(export)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(export, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(extends)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, extends, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(extends)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: extends}], extends, extends)
          listener: handleIdentifier(extends, topLevelFunctionDeclaration)
        parseMethodTypeVar(extends)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(extends, extends, false, MemberKind.TopLevelMethod)
          parseFormalParameters(extends, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: extends}], extends, extends)
                            listener: handleIdentifier(extends, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(extends)
                            parseArguments(extends)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(extends, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, extension, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(extension)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(extension, topLevelFunctionDeclaration)
        parseMethodTypeVar(extension)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(extension, extension, false, MemberKind.TopLevelMethod)
          parseFormalParameters(extension, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(extension, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(extension)
                              parseArguments(extension)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(extension, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, external, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(external)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(external, topLevelFunctionDeclaration)
        parseMethodTypeVar(external)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(external, external, false, MemberKind.TopLevelMethod)
          parseFormalParameters(external, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(external, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(external)
                              parseArguments(external)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(external, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, factory, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(factory)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(factory, topLevelFunctionDeclaration)
        parseMethodTypeVar(factory)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(factory, factory, false, MemberKind.TopLevelMethod)
          parseFormalParameters(factory, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSendOrFunctionLiteral(return, expression)
                          looksLikeFunctionBody(+)
                          parseSend(return, expression)
                            ensureIdentifier(return, expression)
                              inPlainSync()
                              listener: handleIdentifier(factory, expression)
                            listener: handleNoTypeArguments(()
                            parseArgumentsOpt(factory)
                              parseArguments(factory)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  parseExpression(()
                                    parsePrecedenceExpression((, 1, true)
                                      parseUnaryExpression((, true)
                                        parsePrimary((, expression)
                                          parseSendOrFunctionLiteral((, expression)
                                            parseSend((, expression)
                                              ensureIdentifier((, expression)
                                                listener: handleIdentifier(x, expression)
                                              listener: handleNoTypeArguments(-)
                                              parseArgumentsOpt(x)
                                                listener: handleNoArguments(-)
                                              listener: handleSend(x, -)
                                      listener: beginBinaryExpression(-)
                                      parsePrecedenceExpression(-, 14, true)
                                        parseUnaryExpression(-, true)
                                          parsePrimary(-, expression)
                                            parseLiteralInt(-)
                                              listener: handleLiteralInt(1)
                                      listener: endBinaryExpression(-)
                                  listener: endArguments(1, (, ))
                            listener: handleSend(factory, +)
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(false)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, false, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(false)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(false, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: false}], false, false)
          listener: handleIdentifier(false, topLevelFunctionDeclaration)
        parseMethodTypeVar(false)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(false, false, false, MemberKind.TopLevelMethod)
          parseFormalParameters(false, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        parseLiteralBool(return)
                          listener: handleLiteralBool(false)
                    parseArgumentOrIndexStar(false, Instance of 'NoTypeParamOrArg', false)
                      listener: handleNoTypeArguments(()
                      parseArguments(false)
                        parseArgumentsRest(()
                          listener: beginArguments(()
                          parseExpression(()
                            parsePrecedenceExpression((, 1, true)
                              parseUnaryExpression((, true)
                                parsePrimary((, expression)
                                  parseSendOrFunctionLiteral((, expression)
                                    parseSend((, expression)
                                      ensureIdentifier((, expression)
                                        listener: handleIdentifier(x, expression)
                                      listener: handleNoTypeArguments(-)
                                      parseArgumentsOpt(x)
                                        listener: handleNoArguments(-)
                                      listener: handleSend(x, -)
                              listener: beginBinaryExpression(-)
                              parsePrecedenceExpression(-, 14, true)
                                parseUnaryExpression(-, true)
                                  parsePrimary(-, expression)
                                    parseLiteralInt(-)
                                      listener: handleLiteralInt(1)
                              listener: endBinaryExpression(-)
                          listener: endArguments(1, (, ))
                      listener: handleSend((, ))
                    listener: beginBinaryExpression(+)
                    parsePrecedenceExpression(+, 14, true)
                      parseUnaryExpression(+, true)
                        parsePrimary(+, expression)
                          parseLiteralInt(+)
                            listener: handleLiteralInt(1)
                    listener: endBinaryExpression(+)
                ensureSemicolon(1)
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(final)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, final, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(final)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: final}], final, final)
          listener: handleIdentifier(final, topLevelFunctionDeclaration)
        parseMethodTypeVar(final)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(final, final, false, MemberKind.TopLevelMethod)
          parseFormalParameters(final, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {token: final}], final, final)
                            rewriter()
                            listener: handleIdentifier(, expression)
                          listener: handleNoTypeArguments(final)
                          parseArgumentsOpt()
                            listener: handleNoArguments(final)
                          listener: handleSend(, final)
                ensureSemicolon()
                  reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                    listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], final, final)
                  rewriter()
                listener: endReturnStatement(true, return, ;)
                inGenerator()
          notEofOrValue(}, final)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(final, ;, null, final, null, false)
                looksLikeLocalFunction(()
                listener: beginMetadataStar(final)
                listener: endMetadataStar(0)
                listener: handleNoType(final)
                listener: beginVariablesDeclaration((, null, final)
                parseVariablesDeclarationRest(final, true)
                  parseOptionallyInitializedIdentifier(final)
                    ensureIdentifier(final, localVariableDeclaration)
                      reportRecoverableErrorWithToken((, Instance of 'Template<(Token) => Message>')
                        listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {token: (}], (, ()
                      rewriter()
                      listener: handleIdentifier(, localVariableDeclaration)
                    listener: beginInitializedIdentifier()
                    parseVariableInitializerOpt()
                      listener: handleNoVariableInitializer()
                    listener: endInitializedIdentifier()
                  ensureSemicolon()
                    reportRecoverableError(, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x)
                    rewriter()
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, x)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(x)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            parseSend(;, expression)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(x, expression)
                              listener: handleNoTypeArguments(-)
                              parseArgumentsOpt(x)
                                listener: handleNoArguments(-)
                              listener: handleSend(x, -)
                      listener: beginBinaryExpression(-)
                      parsePrecedenceExpression(-, 14, true)
                        parseUnaryExpression(-, true)
                          parsePrimary(-, expression)
                            parseLiteralInt(-)
                              listener: handleLiteralInt(1)
                      listener: endBinaryExpression(-)
                  ensureSemicolon(1)
                    reportRecoverableError(1, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1)
                    rewriter()
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, ))
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, false)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                  looksLikeLocalFunction())
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true)
                        parseUnaryExpression(;, true)
                          parsePrimary(;, expression)
                            parseSend(;, expression)
                              ensureIdentifier(;, expression)
                                reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                  listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {token: )}], ), ))
                                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, {token: ;}])
            listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {token: ;}], ), ))
          notEofOrValue(}, +)
          parseStatement())
            parseStatementX())
              parseExpressionStatementOrDeclaration(), false)
                parseExpressionStatementOrDeclarationAfterModifiers(), ), null, null, null, false)
                  looksLikeLocalFunction(+)
                  parseExpressionStatement())
                    parseExpression())
                      parsePrecedenceExpression(), 1, true)
                        parseUnaryExpression(), true)
                          rewriteAndRecover(), UnsupportedPrefixPlus, )
                            reportRecoverableError(+, UnsupportedPrefixPlus)
                              listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                            rewriter()
                          parsePrimary(), expression)
                            parseSendOrFunctionLiteral(), expression)
                              parseSend(), expression)
                                ensureIdentifier(), expression)
                                  listener: handleIdentifier(, expression)
                                listener: handleNoTypeArguments(+)
                                parseArgumentsOpt()
                                  listener: handleNoArguments(+)
                                listener: handleSend(, +)
                        listener: beginBinaryExpression(+)
                        parsePrecedenceExpression(+, 14, true)
                          parseUnaryExpression(+, true)
                            parsePrimary(+, expression)
                              parseLiteralInt(+)
                                listener: handleLiteralInt(1)
                        listener: endBinaryExpression(+)
                    ensureSemicolon(1)
                    listener: handleExpressionStatement(;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(6, {, })
        listener: endTopLevelMethod(int, null, })
  listener: endTopLevelDeclaration(int)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(int)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(int)
      isReservedKeyword(finally)
      indicatesMethodOrField(()
      parseTopLevelMethod(}, null, }, Instance of 'SimpleType', null, finally, true)
        listener: beginTopLevelMethod(}, null)
        listener: handleIdentifier(int, typeReference)
        listener: handleNoTypeArguments(finally)
        listener: handleType(int, null)
        ensureIdentifierPotentiallyRecovered(int, topLevelFunctionDeclaration, true)
          reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
            listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: finally}], finally, finally)
          listener: handleIdentifier(finally, topLevelFunctionDeclaration)
        parseMethodTypeVar(finally)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(finally, finally, false, MemberKind.TopLevelMethod)
          parseFormalParameters(finally, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
                parseMetadataStar(()
                  listener: beginMetadataStar(int)
                  listener: endMetadataStar(0)
                listener: beginFormalParameter(int, MemberKind.TopLevelMethod, null, null, null)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(x)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(x, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, if)
          parseStatement({)
            parseStatementX({)
              parseIfStatement({)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseSendOrFunctionLiteral((, expression)
                              parseSend((, expression)
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(x, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(x)
                                  listener: handleNoArguments(==)
                                listener: handleSend(x, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralInt(==)
                                listener: handleLiteralInt(0)
                        listener: endBinaryExpression(==)
                    ensureCloseParen(0, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement(return)
                parseStatement())
                  parseStatementX())
                    parseReturnStatement())
                      listener: beginReturnStatement(return)
                      parseExpression(return)
                        parsePrecedenceExpression(return, 1, true)
                          parseUnaryExpression(return, true)
                            parsePrimary(return, expression)
                              parseLiteralInt(return)
                                listener: handleLiteralInt(42)
                      ensureSemicolon(42)
                      listener: endReturnStatement(true, return, ;)
                      inGenerator()
                listener: endThenStatement(;)
                listener: endIfStatement(if, null)
          notEofOrValue(}, return)
          parseStatement(;)
            parseStatementX(;)
              parseReturnStatement(;)
                listener: beginReturnStatement(return)
                parseExpression(return)
                  parsePrecedenceExpression(return, 1, true)
                    parseUnaryExpression(return, true)
                      parsePrimary(return, expression)
                        inPlainSync()
                        parseSend(return, expression)
                          ensureIdentifier(return, expression)
                            reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                              listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {token: finally}], finally, finally)
                            listener: handleIdentifier(finally, expression)
                          listener: handleNoTypeArguments(()
                          parseArgumentsOpt(finally)
                            parseArguments(finally)
                              parseArgumentsRest(()
                                listener: beginArguments(()
                                parseExpression(()
                                  parsePrecedenceExpression((, 1, true)
                                    parseUnaryExpression((, true)
                                      parsePrimary((, expression)
                                        parseSendOrFunctionLiteral((, expression)
                                          parseSend((, expression)
                                            ensureIdentifier((, expression)
                                              listener: handleIdentifier(x, expression)
                                            listener: handleNoTypeArguments(-)
                                            parseArgumentsOpt(x)
                                              listener: handleNoArguments(-)
                                            listener: handleSend(x, -)
                                    listener: beginBinaryExpression(-)
                                    parsePrecedenceExpression(-, 14, true)
                                      parseUnaryExpression(-, true)
                                        parsePrimary(-, expression)
                                          parseLiteralInt(-)
                                            listener: handleLiteralInt(1)
                                    listener: endBinaryExpression(-)
                                listener: endArguments(1, (, ))
                          listener: handleSend(finally, +)
                    listener: beginBinaryExpression(+)