parseUnit(foo)
  skipErrorTokens(foo)
  listener: beginCompilationUnit(foo)
  syntheticPreviousToken(foo)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(foo)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(foo)
      isReservedKeyword(()
      parseTopLevelMethod(, null, , Instance of 'NoType', null, foo, false)
        listener: beginTopLevelMethod(, null)
        listener: handleNoType()
        ensureIdentifierPotentiallyRecovered(, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(foo, topLevelFunctionDeclaration)
        parseMethodTypeVar(foo)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(foo, foo, false, MemberKind.TopLevelMethod)
          parseFormalParameters(foo, 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(a)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(a, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue(,)
                listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.mandatory, 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(b)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(b, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, null, b, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(2, (, ), 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)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(a, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(a)
                                  listener: handleNoArguments(==)
                                listener: handleSend(a, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralNull(==)
                                listener: handleLiteralNull(null)
                          rewriter()
                          parsePrecedenceExpression(|, 10, true)
                            parseUnaryExpression(|, true)
                              parsePrimary(|, expression)
                                parseSendOrFunctionLiteral(|, expression)
                                  parseSend(|, expression)
                                    isNextIdentifier(|)
                                    ensureIdentifier(|, expression)
                                    parseArgumentsOpt(b)
                          rewriter()
                        listener: endBinaryExpression(==)
                        rewriter()
                        parsePrecedenceExpression(||, 6, true)
                          parseUnaryExpression(||, true)
                            parsePrimary(||, expression)
                              parseSendOrFunctionLiteral(||, expression)
                                parseSend(||, expression)
                                  isNextIdentifier(||)
                                  ensureIdentifier(||, expression)
                                  parseArgumentsOpt(b)
                          parsePrecedenceExpression(==, 8, true)
                            parseUnaryExpression(==, true)
                              parsePrimary(==, expression)
                                parseLiteralNull(==)
                        reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}])
                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}], or, or)
                        rewriter()
                        listener: beginBinaryExpression(||)
                        parsePrecedenceExpression(||, 6, true)
                          parseUnaryExpression(||, true)
                            parsePrimary(||, expression)
                              parseSendOrFunctionLiteral(||, expression)
                                parseSend(||, expression)
                                  isNextIdentifier(||)
                                  ensureIdentifier(||, expression)
                                    listener: handleIdentifier(b, expression)
                                  listener: handleNoTypeArguments(==)
                                  parseArgumentsOpt(b)
                                    listener: handleNoArguments(==)
                                  listener: handleSend(b, ==)
                          listener: beginBinaryExpression(==)
                          parsePrecedenceExpression(==, 8, true)
                            parseUnaryExpression(==, true)
                              parsePrimary(==, expression)
                                parseLiteralNull(==)
                                  listener: handleLiteralNull(null)
                          listener: endBinaryExpression(==)
                        listener: endBinaryExpression(||)
                    ensureCloseParen(null, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement({)
                parseStatement())
                  parseStatementX())
                    parseBlock(), BlockKind(statement))
                      ensureBlock(), null, null)
                      listener: beginBlock({, BlockKind(statement))
                      notEofOrValue(}, return)
                      parseStatement({)
                        parseStatementX({)
                          parseReturnStatement({)
                            listener: beginReturnStatement(return)
                            parseExpression(return)
                              parsePrecedenceExpression(return, 1, true)
                                parseUnaryExpression(return, true)
                                  parsePrimary(return, expression)
                                    parseLiteralNull(return)
                                      listener: handleLiteralNull(null)
                            ensureSemicolon(null)
                              reportRecoverableError(null, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], null, null)
                              rewriter()
                            listener: endReturnStatement(true, return, ;)
                            inGenerator()
                      notEofOrValue(}, })
                      listener: endBlock(1, {, }, BlockKind(statement))
                listener: endThenStatement(})
                listener: endIfStatement(if, null)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(foo, null, })
  listener: endTopLevelDeclaration(bar)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(bar)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(bar)
      isReservedKeyword(()
      parseTopLevelMethod(}, null, }, Instance of 'NoType', null, bar, false)
        listener: beginTopLevelMethod(}, null)
        listener: handleNoType(})
        ensureIdentifierPotentiallyRecovered(}, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(bar, topLevelFunctionDeclaration)
        parseMethodTypeVar(bar)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(bar, bar, false, MemberKind.TopLevelMethod)
          parseFormalParameters(bar, 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(a)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(a, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue(,)
                listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.mandatory, 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(b)
                listener: handleType(int, null)
                ensureIdentifier(int, formalParameterDeclaration)
                  listener: handleIdentifier(b, formalParameterDeclaration)
                listener: handleFormalParameterWithoutValue())
                listener: endFormalParameter(null, null, null, b, null, null, FormalParameterKind.mandatory, MemberKind.TopLevelMethod)
              listener: endFormalParameters(2, (, ), 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)
                                isNextIdentifier(()
                                ensureIdentifier((, expression)
                                  listener: handleIdentifier(a, expression)
                                listener: handleNoTypeArguments(==)
                                parseArgumentsOpt(a)
                                  listener: handleNoArguments(==)
                                listener: handleSend(a, ==)
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseLiteralNull(==)
                                listener: handleLiteralNull(null)
                          rewriter()
                          parsePrecedenceExpression(&, 12, true)
                            parseUnaryExpression(&, true)
                              parsePrimary(&, expression)
                                parseSendOrFunctionLiteral(&, expression)
                                  parseSend(&, expression)
                                    isNextIdentifier(&)
                                    ensureIdentifier(&, expression)
                                    parseArgumentsOpt(b)
                          rewriter()
                        listener: endBinaryExpression(==)
                        rewriter()
                        parsePrecedenceExpression(&&, 7, true)
                          parseUnaryExpression(&&, true)
                            parsePrimary(&&, expression)
                              parseSendOrFunctionLiteral(&&, expression)
                                parseSend(&&, expression)
                                  isNextIdentifier(&&)
                                  ensureIdentifier(&&, expression)
                                  parseArgumentsOpt(b)
                          parsePrecedenceExpression(==, 8, true)
                            parseUnaryExpression(==, true)
                              parsePrimary(==, expression)
                                parseLiteralNull(==)
                        reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}])
                          listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}], and, and)
                        rewriter()
                        listener: beginBinaryExpression(&&)
                        parsePrecedenceExpression(&&, 7, true)
                          parseUnaryExpression(&&, true)
                            parsePrimary(&&, expression)
                              parseSendOrFunctionLiteral(&&, expression)
                                parseSend(&&, expression)
                                  isNextIdentifier(&&)
                                  ensureIdentifier(&&, expression)
                                    listener: handleIdentifier(b, expression)
                                  listener: handleNoTypeArguments(==)
                                  parseArgumentsOpt(b)
                                    listener: handleNoArguments(==)
                                  listener: handleSend(b, ==)
                          listener: beginBinaryExpression(==)
                          parsePrecedenceExpression(==, 8, true)
                            parseUnaryExpression(==, true)
                              parsePrimary(==, expression)
                                parseLiteralNull(==)
                                  listener: handleLiteralNull(null)
                          listener: endBinaryExpression(==)
                        listener: endBinaryExpression(&&)
                    ensureCloseParen(null, ()
                  listener: handleParenthesizedCondition(()
                listener: beginThenStatement({)
                parseStatement())
                  parseStatementX())
                    parseBlock(), BlockKind(statement))
                      ensureBlock(), null, null)
                      listener: beginBlock({, BlockKind(statement))
                      notEofOrValue(}, return)
                      parseStatement({)
                        parseStatementX({)
                          parseReturnStatement({)
                            listener: beginReturnStatement(return)
                            parseExpression(return)
                              parsePrecedenceExpression(return, 1, true)
                                parseUnaryExpression(return, true)
                                  parsePrimary(return, expression)
                                    parseLiteralNull(return)
                                      listener: handleLiteralNull(null)
                            ensureSemicolon(null)
                              reportRecoverableError(null, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
                                listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], null, null)
                              rewriter()
                            listener: endReturnStatement(true, return, ;)
                            inGenerator()
                      notEofOrValue(}, })
                      listener: endBlock(1, {, }, BlockKind(statement))
                listener: endThenStatement(})
                listener: endIfStatement(if, null)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(bar, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(foo)
  listener: endCompilationUnit(2, )