parseUnit(main)
  skipErrorTokens(main)
  listener: beginCompilationUnit(main)
  syntheticPreviousToken(main)
  parseTopLevelDeclarationImpl(, DirectiveContext(DirectiveState.Unknown))
    parseMetadataStar()
      listener: beginMetadataStar(main)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl()
      listener: beginTopLevelMember(main)
      isReservedKeyword(()
      parseTopLevelMethod(, null, null, , NoType(), null, main, false)
        listener: beginTopLevelMethod(, null, null)
        listener: handleNoType()
        ensureIdentifierPotentiallyRecovered(, 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(}, dynamic)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclaration({, null)
                parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                  looksLikeLocalFunction(foo)
                  listener: beginMetadataStar(dynamic)
                  listener: endMetadataStar(0)
                  listener: handleIdentifier(dynamic, typeReference)
                  listener: handleNoTypeArguments(foo)
                  listener: handleType(dynamic, null)
                  listener: beginVariablesDeclaration(foo, null, null)
                  parseVariablesDeclarationRest(dynamic, true)
                    parseOptionallyInitializedIdentifier(dynamic)
                      ensureIdentifier(dynamic, localVariableDeclaration)
                        listener: handleIdentifier(foo, localVariableDeclaration)
                      listener: beginInitializedIdentifier(foo)
                      parseVariableInitializerOpt(foo)
                        listener: beginVariableInitializer(=)
                        parseExpression(=)
                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
                            parseUnaryExpression(=, true, ConstantPatternContext.none)
                              parsePrimary(=, expression, ConstantPatternContext.none)
                                parseNewExpression(=)
                                  isNextIdentifier(new)
                                  listener: beginNewExpression(new)
                                  parseConstructorReference(new, ConstructorReferenceContext.New, null)
                                    ensureIdentifier(new, constructorReference)
                                      listener: handleIdentifier(X, constructorReference)
                                    listener: beginConstructorReference(X)
                                    parseQualifiedRestOpt(X, constructorReferenceContinuation)
                                    listener: handleNoTypeArguments(()
                                    listener: handleNoConstructorReferenceContinuationAfterTypeArguments(X)
                                    listener: endConstructorReference(X, null, X, ConstructorReferenceContext.New)
                                  parseConstructorInvocationArguments(X)
                                    parseArgumentsRest(()
                                      listener: beginArguments(()
                                      listener: endArguments(0, (, ))
                                  listener: endNewExpression(new)
                        listener: endVariableInitializer(=)
                      listener: endInitializedIdentifier(foo)
                    ensureSemicolon())
                    listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, var)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(var, ;, null, var, null, null)
                looksLikeLocalFunction(bar)
                listener: beginMetadataStar(var)
                listener: endMetadataStar(0)
                listener: handleNoType(var)
                listener: beginVariablesDeclaration(bar, null, var)
                parseVariablesDeclarationRest(var, true)
                  parseOptionallyInitializedIdentifier(var)
                    ensureIdentifier(var, localVariableDeclaration)
                      listener: handleIdentifier(bar, localVariableDeclaration)
                    listener: beginInitializedIdentifier(bar)
                    parseVariableInitializerOpt(bar)
                      listener: beginVariableInitializer(=)
                      parseExpression(=)
                        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(foo, expression)
                                  listener: handleNoTypeArguments(.)
                                  parseArgumentsOpt(foo)
                                    listener: handleNoArguments(.)
                                  listener: handleSend(foo, .)
                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                            inPlainSync()
                            parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
                              parseSend(., expressionContinuation, ConstantPatternContext.none)
                                isNextIdentifier(.)
                                ensureIdentifier(., expressionContinuation)
                                  inPlainSync()
                                  listener: handleIdentifier(required, expressionContinuation)
                                listener: handleNoTypeArguments(;)
                                parseArgumentsOpt(required)
                                  listener: handleNoArguments(;)
                                listener: handleSend(required, ;)
                          listener: handleEndingBinaryExpression(., required)
                      listener: endVariableInitializer(=)
                    listener: endInitializedIdentifier(bar)
                  ensureSemicolon(required)
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, required)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, null)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
                  looksLikeLocalFunction(required)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
                        parseUnaryExpression(;, true, ConstantPatternContext.none)
                          parsePrimary(;, expression, ConstantPatternContext.none)
                            inPlainSync()
                            parseSendOrFunctionLiteral(;, expression, ConstantPatternContext.none)
                              looksLikeFunctionBody(;)
                              parseSend(;, expression, ConstantPatternContext.none)
                                isNextIdentifier(;)
                                ensureIdentifier(;, expression)
                                  inPlainSync()
                                  listener: handleIdentifier(required, expression)
                                listener: handleNoTypeArguments(()
                                parseArgumentsOpt(required)
                                  parseArguments(required)
                                    parseArgumentsRest(()
                                      listener: beginArguments(()
                                      listener: endArguments(0, (, ))
                                listener: handleSend(required, ;)
                    ensureSemicolon())
                    listener: handleExpressionStatement(required, ;)
          notEofOrValue(}, bar)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
                looksLikeLocalFunction(bar)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
                      parseUnaryExpression(;, true, ConstantPatternContext.none)
                        parsePrimary(;, expression, ConstantPatternContext.none)
                          parseSendOrFunctionLiteral(;, expression, ConstantPatternContext.none)
                            looksLikeFunctionBody(;)
                            parseSend(;, expression, ConstantPatternContext.none)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(bar, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(bar)
                                parseArguments(bar)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    listener: endArguments(0, (, ))
                              listener: handleSend(bar, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(bar, ;)
          notEofOrValue(}, new)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, null)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
                  looksLikeLocalFunction(new)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
                        parseUnaryExpression(;, true, ConstantPatternContext.none)
                          parsePrimary(;, expression, ConstantPatternContext.none)
                            parseNewExpression(;)
                              isNextIdentifier(new)
                              listener: beginNewExpression(new)
                              parseConstructorReference(new, ConstructorReferenceContext.New, null)
                                ensureIdentifier(new, constructorReference)
                                  listener: handleIdentifier(X, constructorReference)
                                listener: beginConstructorReference(X)
                                parseQualifiedRestOpt(X, constructorReferenceContinuation)
                                listener: handleNoTypeArguments(()
                                listener: handleNoConstructorReferenceContinuationAfterTypeArguments(X)
                                listener: endConstructorReference(X, null, X, ConstructorReferenceContext.New)
                              parseConstructorInvocationArguments(X)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  listener: endArguments(0, (, ))
                              listener: endNewExpression(new)
                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                          inPlainSync()
                          parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
                            looksLikeFunctionBody(;)
                            parseSend(., expressionContinuation, ConstantPatternContext.none)
                              isNextIdentifier(.)
                              ensureIdentifier(., expressionContinuation)
                                inPlainSync()
                                listener: handleIdentifier(required, expressionContinuation)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(required)
                                parseArguments(required)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    listener: endArguments(0, (, ))
                              listener: handleSend(required, ;)
                        listener: handleEndingBinaryExpression(., ))
                    ensureSemicolon())
                    listener: handleExpressionStatement(new, ;)
          notEofOrValue(}, new)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclaration(;, null)
                parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
                  looksLikeLocalFunction(new)
                  parseExpressionStatement(;)
                    parseExpression(;)
                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
                        parseUnaryExpression(;, true, ConstantPatternContext.none)
                          parsePrimary(;, expression, ConstantPatternContext.none)
                            parseNewExpression(;)
                              isNextIdentifier(new)
                              listener: beginNewExpression(new)
                              parseConstructorReference(new, ConstructorReferenceContext.New, null)
                                ensureIdentifier(new, constructorReference)
                                  listener: handleIdentifier(Y, constructorReference)
                                listener: beginConstructorReference(Y)
                                parseQualifiedRestOpt(Y, constructorReferenceContinuation)
                                listener: handleNoTypeArguments(()
                                listener: handleNoConstructorReferenceContinuationAfterTypeArguments(Y)
                                listener: endConstructorReference(Y, null, Y, ConstructorReferenceContext.New)
                              parseConstructorInvocationArguments(Y)
                                parseArgumentsRest(()
                                  listener: beginArguments(()
                                  listener: endArguments(0, (, ))
                              listener: endNewExpression(new)
                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                          inPlainSync()
                          parseSendOrFunctionLiteral(., expressionContinuation, ConstantPatternContext.none)
                            parseSend(., expressionContinuation, ConstantPatternContext.none)
                              isNextIdentifier(.)
                              ensureIdentifier(., expressionContinuation)
                                inPlainSync()
                                listener: handleIdentifier(required, expressionContinuation)
                              listener: handleNoTypeArguments(;)
                              parseArgumentsOpt(required)
                                listener: handleNoArguments(;)
                              listener: handleSend(required, ;)
                        listener: handleEndingBinaryExpression(., required)
                    ensureSemicolon(required)
                    listener: handleExpressionStatement(new, ;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(6, {, })
        listener: endTopLevelMethod(main, null, })
  listener: endTopLevelDeclaration(})
  parseTopLevelDeclarationImpl(}, DirectiveContext(DirectiveState.Declarations))
    parseMetadataStar(})
      listener: beginMetadataStar(required)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(required)
      isReservedKeyword(()
      parseTopLevelMethod(}, null, null, }, NoType(), null, required, false)
        listener: beginTopLevelMethod(}, null, null)
        listener: handleNoType(})
        ensureIdentifierPotentiallyRecovered(}, topLevelFunctionDeclaration, false)
          listener: handleIdentifier(required, topLevelFunctionDeclaration)
        parseMethodTypeVar(required)
          listener: handleNoTypeVariables(()
        parseGetterOrFormalParameters(required, required, false, MemberKind.TopLevelMethod)
          parseFormalParameters(required, MemberKind.TopLevelMethod)
            parseFormalParametersRest((, MemberKind.TopLevelMethod)
              listener: beginFormalParameters((, MemberKind.TopLevelMethod)
              parseOptionalNamedParameters((, MemberKind.TopLevelMethod)
                listener: beginOptionalFormalParameters({)
                parseFormalParameter({, FormalParameterKind.optionalNamed, MemberKind.TopLevelMethod)
                  parseMetadataStar({)
                    listener: beginMetadataStar(required)
                    listener: endMetadataStar(0)
                  listener: beginFormalParameter(required, MemberKind.TopLevelMethod, required, null, null)
                  listener: handleIdentifier(int, typeReference)
                  listener: handleNoTypeArguments(named)
                  listener: handleType(int, null)
                  ensureIdentifier(int, formalParameterDeclaration)
                    listener: handleIdentifier(named, formalParameterDeclaration)
                  listener: handleFormalParameterWithoutValue(})
                  listener: endFormalParameter(null, null, null, named, null, null, FormalParameterKind.requiredNamed, MemberKind.TopLevelMethod)
                listener: endOptionalFormalParameters(1, {, })
              ensureCloseParen(}, ()
              listener: endFormalParameters(1, (, ), MemberKind.TopLevelMethod)
        parseAsyncModifierOpt())
          listener: handleAsyncModifier(null, null)
          inPlainSync()
        parseFunctionBody(), false, false)
          listener: beginBlockFunctionBody({)
          notEofOrValue(}, print)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                looksLikeLocalFunction(print)
                parseExpressionStatement({)
                  parseExpression({)
                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
                      parseUnaryExpression({, true, ConstantPatternContext.none)
                        parsePrimary({, expression, ConstantPatternContext.none)
                          parseSendOrFunctionLiteral({, expression, ConstantPatternContext.none)
                            looksLikeFunctionBody(;)
                            parseSend({, expression, ConstantPatternContext.none)
                              isNextIdentifier({)
                              ensureIdentifier({, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                          parsePrimary((, expression, ConstantPatternContext.none)
                                            parseLiteralString(()
                                              parseSingleLiteralString(()
                                                listener: beginLiteralString("hello")
                                                listener: endLiteralString(0, ))
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(print, ;)
          notEofOrValue(}, })
          listener: endBlockFunctionBody(1, {, })
        listener: endTopLevelMethod(required, null, })
  listener: endTopLevelDeclaration(})
  parseTopLevelDeclarationImpl(}, DirectiveContext(DirectiveState.Declarations))
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(class, }, class, null, null, null, null, DirectiveContext(DirectiveState.Declarations))
      parseClassOrNamedMixinApplication(class, null, null, null, null, null, null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(X, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, null, null, null, null, null, null, X)
        parseClass(X, class, class, X)
          parseClassHeaderOpt(X, class, class)
            parseClassExtendsOpt(X, DeclarationHeaderKind.Class)
              listener: handleNoType(X)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(X)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(X)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(X, DeclarationKind.Class, X)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, required)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, X)
              parseMetadataStar({)
                listener: beginMetadataStar(required)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod({, null, null, null, null, null, null, null, {, NoType(), null, required, DeclarationKind.Class, X, false)
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, required)
                listener: handleNoType({)
                ensureIdentifierPotentiallyRecovered({, methodDeclaration, false)
                  listener: handleIdentifier(required, methodDeclaration)
                parseQualifiedRestOpt(required, methodDeclarationContinuation)
                parseMethodTypeVar(required)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(required, required, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(required, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  listener: beginBlockFunctionBody({)
                  notEofOrValue(}, print)
                  parseStatement({)
                    parseStatementX({)
                      parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                        looksLikeLocalFunction(print)
                        parseExpressionStatement({)
                          parseExpression({)
                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
                              parseUnaryExpression({, true, ConstantPatternContext.none)
                                parsePrimary({, expression, ConstantPatternContext.none)
                                  parseSendOrFunctionLiteral({, expression, ConstantPatternContext.none)
                                    looksLikeFunctionBody(;)
                                    parseSend({, expression, ConstantPatternContext.none)
                                      isNextIdentifier({)
                                      ensureIdentifier({, expression)
                                        listener: handleIdentifier(print, expression)
                                      listener: handleNoTypeArguments(()
                                      parseArgumentsOpt(print)
                                        parseArguments(print)
                                          parseArgumentsRest(()
                                            listener: beginArguments(()
                                            parseExpression(()
                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
                                                parseUnaryExpression((, true, ConstantPatternContext.none)
                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                    parseLiteralString(()
                                                      parseSingleLiteralString(()
                                                        listener: beginLiteralString("hello")
                                                        listener: endLiteralString(0, ))
                                            listener: endArguments(1, (, ))
                                      listener: handleSend(print, ;)
                          ensureSemicolon())
                          listener: handleExpressionStatement(print, ;)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, required, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(})
  parseTopLevelDeclarationImpl(}, DirectiveContext(DirectiveState.Declarations))
    parseMetadataStar(})
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(class, }, class, null, null, null, null, DirectiveContext(DirectiveState.Declarations))
      parseClassOrNamedMixinApplication(class, null, null, null, null, null, null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Y, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, null, null, null, null, null, null, Y)
        parseClass(Y, class, class, Y)
          parseClassHeaderOpt(Y, class, class)
            parseClassExtendsOpt(Y, DeclarationHeaderKind.Class)
              listener: handleNoType(Y)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(Y)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(Y)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Y, DeclarationKind.Class, Y)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Y)
              parseMetadataStar({)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, null, null, {, SimpleType(), required, DeclarationKind.Class, Y, false)
                listener: beginFields(DeclarationKind.Class, null, null, null, null, null, null, null, {)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(required)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(required, fieldDeclaration)
                parseFieldInitializerOpt(required, required, null, null, null, null, null, DeclarationKind.Class, Y)
                  listener: beginFieldInitializer(=)
                  parseExpression(=)
                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
                      parseUnaryExpression(=, true, ConstantPatternContext.none)
                        parsePrimary(=, expression, ConstantPatternContext.none)
                          parseLiteralInt(=)
                            listener: handleLiteralInt(42)
                  listener: endFieldInitializer(=, 42)
                listener: endClassFields(null, null, null, null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(})
  reportAllErrorTokens(main)
  listener: endCompilationUnit(4, )