parseUnit(UnmatchedToken({))
  skipErrorTokens(UnmatchedToken({))
  listener: beginCompilationUnit(main)
  syntheticPreviousToken(main)
  parseTopLevelDeclarationImpl(UnmatchedToken({), Instance of 'DirectiveContext')
    parseMetadataStar(UnmatchedToken({))
      listener: beginMetadataStar(main)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(UnmatchedToken({))
      listener: beginTopLevelMember(main)
      isReservedKeyword(()
      parseTopLevelMethod(UnmatchedToken({), null, null, UnmatchedToken({), Instance of 'NoType', null, main, false)
        listener: beginTopLevelMethod(UnmatchedToken({), null, null)
        listener: handleNoType(UnmatchedToken({))
        ensureIdentifierPotentiallyRecovered(UnmatchedToken({), topLevelFunctionDeclaration, false)
          listener: handleIdentifier(main, topLevelFunctionDeclaration)
        parseMethodTypeVar(main)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(main, main, false, MemberKind.TopLevelMethod)
          parseFormalParameters(main, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              listener: endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, int)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                looksLikeLocalFunction(int)
                parseExpressionStatement({)
                  parseExpression({)
                    looksLikeOuterPatternEquals({)
                      skipOuterPattern({)
                        skipObjectPatternRest(int)
                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
                      parseUnaryExpression({, true, ConstantPatternContext.none)
                        parsePrimary({, expression, ConstantPatternContext.none)
                          parseSendOrFunctionLiteral({, expression, ConstantPatternContext.none)
                            parseSend({, expression, ConstantPatternContext.none)
                              isNextIdentifier({)
                              ensureIdentifier({, expression)
                                listener: handleIdentifier(int, expression)
                              listener: handleNoTypeArguments(var)
                              parseArgumentsOpt(int)
                                listener: handleNoArguments(var)
                              listener: handleSend(int, var)
                  ensureSemicolon(int)
                    reportRecoverableError(int, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                      listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], int, int)
                    rewriter()
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, var)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, null)
                skipOuterPattern(var)
                looksLikeLocalFunction(=)
                listener: beginMetadataStar(var)
                listener: endMetadataStar(0)
                listener: handleNoType(var)
                listener: beginVariablesDeclaration(=, null, var)
                parseVariablesDeclarationRest(var, true)
                  parseOptionallyInitializedIdentifier(var)
                    ensureIdentifier(var, localVariableDeclaration)
                      insertSyntheticIdentifier(var, localVariableDeclaration, message: Message[ExpectedIdentifier, Expected an identifier, but got '='., Try inserting an identifier before '='., {lexeme: =}], messageOnToken: null)
                        reportRecoverableError(=, Message[ExpectedIdentifier, Expected an identifier, but got '='., Try inserting an identifier before '='., {lexeme: =}])
                          listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '='., Try inserting an identifier before '='., {lexeme: =}], =, =)
                        rewriter()
                      listener: handleIdentifier(, localVariableDeclaration)
                    listener: beginInitializedIdentifier()
                    parseVariableInitializerOpt()
                      listener: beginVariableInitializer(=)
                      parseExpression(=)
                        looksLikeOuterPatternEquals(=)
                          skipOuterPattern(=)
                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
                          parseUnaryExpression(=, true, ConstantPatternContext.none)
                            parsePrimary(=, expression, ConstantPatternContext.none)
                              parseLiteralInt(=)
                                listener: handleLiteralInt(0)
                      listener: endVariableInitializer(=)
                    listener: endInitializedIdentifier()
                  ensureSemicolon(0)
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(2, {, })
        listener: endTopLevelMethod(main, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(UnmatchedToken({))
    listener: handleErrorToken(UnmatchedToken({))
    listener: handleRecoverableError(Message[UnmatchedToken, Can't find '}' to match '{'., null, {string: }, lexeme: {}], UnmatchedToken({), UnmatchedToken({))
  listener: endCompilationUnit(1, )