parseUnit(class)
  skipErrorTokens(class)
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
      parseClassDeclarationModifiers(, class)
      parseClassOrNamedMixinApplication(null, class)
        listener: beginClassOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Foo, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, Foo)
        parseClass(Foo, class, class, Foo)
          parseClassHeaderOpt(Foo, class, class)
            parseClassExtendsOpt(Foo)
              listener: handleNoType(Foo)
              listener: handleClassExtends(null)
            parseWithClauseOpt(Foo)
              listener: handleClassNoWithClause()
            parseClassOrMixinImplementsOpt(Foo)
              listener: handleClassOrMixinImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
            listener: beginClassOrMixinBody(DeclarationKind.Class, {)
            notEofOrValue(}, String)
            parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Foo)
              parseMetadataStar({)
                listener: beginMetadataStar(String)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields({, null, null, null, null, null, null, {, Instance of 'SimpleNullableType', x, DeclarationKind.Class, Foo, false)
                listener: handleIdentifier(String, typeReference)
                listener: handleNoTypeArguments(?)
                listener: handleType(String, ?)
                ensureIdentifierPotentiallyRecovered(?, fieldDeclaration, false)
                  listener: handleIdentifier(x, fieldDeclaration)
                parseFieldInitializerOpt(x, x, null, null, null, null, DeclarationKind.Class, Foo)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, 1, String, ;)
              listener: endMember()
            notEofOrValue(}, int)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(int)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseFields(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', y, DeclarationKind.Class, Foo, false)
                listener: handleIdentifier(int, typeReference)
                listener: handleNoTypeArguments(y)
                listener: handleType(int, null)
                ensureIdentifierPotentiallyRecovered(int, fieldDeclaration, false)
                  listener: handleIdentifier(y, fieldDeclaration)
                parseFieldInitializerOpt(y, y, null, null, null, null, DeclarationKind.Class, Foo)
                  listener: handleNoFieldInitializer(;)
                listener: endClassFields(null, null, null, null, 1, int, ;)
              listener: endMember()
            notEofOrValue(}, Foo)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(Foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              isReservedKeyword(()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'NoType', null, Foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, Foo)
                listener: handleNoType(;)
                ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
                  listener: handleIdentifier(Foo, methodDeclaration)
                parseQualifiedRestOpt(Foo, methodDeclarationContinuation)
                parseMethodTypeVar(Foo)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(Foo, Foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(Foo, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(Object)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(Object, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(Object, typeReference)
                        listener: handleNoTypeArguments(?)
                        listener: handleType(Object, ?)
                        ensureIdentifier(?, formalParameterDeclaration)
                          listener: handleIdentifier(o, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, o, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  parseInitializers(:)
                    listener: beginInitializers(:)
                    parseInitializer(:)
                      listener: beginInitializer(x)
                      parseInitializerExpressionRest(:)
                        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, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseSendOrFunctionLiteral(=, expression)
                                    parseSend(=, expression)
                                      ensureIdentifier(=, expression)
                                        listener: handleIdentifier(o, expression)
                                      listener: handleNoTypeArguments(!=)
                                      parseArgumentsOpt(o)
                                        listener: handleNoArguments(!=)
                                      listener: handleSend(o, !=)
                              listener: beginBinaryExpression(!=)
                              parsePrecedenceExpression(!=, 8, true)
                                parseUnaryExpression(!=, true)
                                  parsePrimary(!=, expression)
                                    parseLiteralNull(!=)
                                      listener: handleLiteralNull(null)
                              listener: endBinaryExpression(!=)
                              parseConditionalExpressionRest(null)
                                listener: beginConditionalExpression(?)
                                parseExpressionWithoutCascade(?)
                                  parsePrecedenceExpression(?, 1, false)
                                    parseUnaryExpression(?, false)
                                      parsePrimary(?, expression)
                                        parseSendOrFunctionLiteral(?, expression)
                                          parseSend(?, expression)
                                            ensureIdentifier(?, expression)
                                              listener: handleIdentifier(o, expression)
                                            listener: handleNoTypeArguments(as)
                                            parseArgumentsOpt(o)
                                              listener: handleNoArguments(as)
                                            listener: handleSend(o, as)
                                    parseAsOperatorRest(o)
                                      listener: beginAsOperatorType(as)
                                      computeTypeAfterIsOrAs(as)
                                      listener: handleIdentifier(String, typeReference)
                                      listener: handleNoTypeArguments(?)
                                      listener: handleType(String, ?)
                                      listener: endAsOperatorType(as)
                                      listener: handleAsOperator(as)
                                      skipChainedAsIsOperators(?)
                                ensureColon(?)
                                listener: handleConditionalExpressionColon()
                                parseExpressionWithoutCascade(:)
                                  parsePrecedenceExpression(:, 1, false)
                                    parseUnaryExpression(:, false)
                                      parsePrimary(:, expression)
                                        parseLiteralNull(:)
                                          listener: handleLiteralNull(null)
                                listener: endConditionalExpression(?, :)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(,)
                    parseInitializer(,)
                      listener: beginInitializer(y)
                      parseInitializerExpressionRest(,)
                        parseExpression(,)
                          parsePrecedenceExpression(,, 1, true)
                            parseUnaryExpression(,, true)
                              parsePrimary(,, expression)
                                parseSendOrFunctionLiteral(,, expression)
                                  parseSend(,, expression)
                                    ensureIdentifier(,, expression)
                                      listener: handleIdentifier(y, expression)
                                    listener: handleNoTypeArguments(=)
                                    parseArgumentsOpt(y)
                                      listener: handleNoArguments(=)
                                    listener: handleSend(y, =)
                            parsePrecedenceExpression(=, 1, true)
                              parseUnaryExpression(=, true)
                                parsePrimary(=, expression)
                                  parseLiteralInt(=)
                                    listener: handleLiteralInt(0)
                            listener: handleAssignmentExpression(=)
                        listener: endInitializer(;)
                    listener: endInitializers(2, :, ;)
                parseAsyncModifierOpt(0)
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(0, false, true)
                  listener: handleEmptyFunctionBody(;)
                listener: endClassConstructor(null, Foo, (, :, ;)
              listener: endMember()
            notEofOrValue(}, void)
            parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Foo)
              parseMetadataStar(;)
                listener: beginMetadataStar(void)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(;, null, null, null, null, null, null, ;, Instance of 'VoidType', null, foo, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, foo)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(foo, methodDeclaration)
                parseQualifiedRestOpt(foo, methodDeclarationContinuation)
                parseMethodTypeVar(foo)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(foo, foo, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(foo, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(dynamic)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(dynamic, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(dynamic, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(dynamic, null)
                        ensureIdentifier(dynamic, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  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(is)
                                        parseArgumentsOpt(x)
                                          listener: handleNoArguments(is)
                                        listener: handleSend(x, is)
                                parseIsOperatorRest(x)
                                  listener: beginIsOperatorType(is)
                                  computeTypeAfterIsOrAs(is)
                                  listener: handleIdentifier(String, typeReference)
                                  listener: handleNoTypeArguments(?)
                                  listener: handleType(String, ?)
                                  listener: endIsOperatorType(is)
                                  listener: handleIsOperator(is, null)
                                  skipChainedAsIsOperators(?)
                                parseConditionalExpressionRest(?)
                                  listener: beginConditionalExpression(?)
                                  parseExpressionWithoutCascade(?)
                                    parsePrecedenceExpression(?, 1, false)
                                      parseUnaryExpression(?, false)
                                        parsePrimary(?, expression)
                                          parseLiteralInt(?)
                                            listener: handleLiteralInt(4)
                                  ensureColon(4)
                                  listener: handleConditionalExpressionColon()
                                  parseExpressionWithoutCascade(:)
                                    parsePrecedenceExpression(:, 1, false)
                                      parseUnaryExpression(:, false)
                                        parsePrimary(:, expression)
                                          parseLiteralInt(:)
                                            listener: handleLiteralInt(2)
                                      listener: beginBinaryExpression(==)
                                      parsePrecedenceExpression(==, 8, false)
                                        parseUnaryExpression(==, false)
                                          parsePrimary(==, expression)
                                            parseLiteralInt(==)
                                              listener: handleLiteralInt(4)
                                      listener: endBinaryExpression(==)
                                  listener: endConditionalExpression(?, :)
                            ensureCloseParen(4, ()
                          listener: handleParenthesizedCondition(()
                        listener: beginThenStatement({)
                        parseStatement())
                          parseStatementX())
                            parseBlock(), BlockKind(statement))
                              ensureBlock(), null, null)
                              listener: beginBlock({, BlockKind(statement))
                              notEofOrValue(}, print)
                              parseStatement({)
                                parseStatementX({)
                                  parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                                    looksLikeLocalFunction(print)
                                    parseExpressionStatement({)
                                      parseExpression({)
                                        parsePrecedenceExpression({, 1, true)
                                          parseUnaryExpression({, true)
                                            parsePrimary({, expression)
                                              parseSendOrFunctionLiteral({, expression)
                                                looksLikeFunctionBody(;)
                                                parseSend({, expression)
                                                  ensureIdentifier({, expression)
                                                    listener: handleIdentifier(print, expression)
                                                  listener: handleNoTypeArguments(()
                                                  parseArgumentsOpt(print)
                                                    parseArguments(print)
                                                      parseArgumentsRest(()
                                                        listener: beginArguments(()
                                                        parseExpression(()
                                                          parsePrecedenceExpression((, 1, true)
                                                            parseUnaryExpression((, true)
                                                              parsePrimary((, expression)
                                                                parseLiteralString(()
                                                                  parseSingleLiteralString(()
                                                                    listener: beginLiteralString("hello")
                                                                    listener: endLiteralString(0, ))
                                                        listener: endArguments(1, (, ))
                                                  listener: handleSend(print, ;)
                                      ensureSemicolon())
                                      listener: handleExpressionStatement(;)
                              notEofOrValue(}, })
                              listener: endBlock(1, {, }, BlockKind(statement))
                        listener: endThenStatement(})
                        listener: endIfStatement(if, null)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, void, (, null, })
              listener: endMember()
            notEofOrValue(}, void)
            parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Foo)
              parseMetadataStar(})
                listener: beginMetadataStar(void)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod(}, null, null, null, null, null, null, }, Instance of 'VoidType', null, bar, DeclarationKind.Class, Foo, false)
                listener: beginMethod(null, null, null, null, null, bar)
                listener: handleVoidKeyword(void)
                ensureIdentifierPotentiallyRecovered(void, methodDeclaration, false)
                  listener: handleIdentifier(bar, methodDeclaration)
                parseQualifiedRestOpt(bar, methodDeclarationContinuation)
                parseMethodTypeVar(bar)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(bar, bar, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(bar, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(dynamic)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(dynamic, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleIdentifier(dynamic, typeReference)
                        listener: handleNoTypeArguments(x)
                        listener: handleType(dynamic, null)
                        ensureIdentifier(dynamic, formalParameterDeclaration)
                          listener: handleIdentifier(x, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  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(is)
                                        parseArgumentsOpt(x)
                                          listener: handleNoArguments(is)
                                        listener: handleSend(x, is)
                                parseIsOperatorRest(x)
                                  listener: beginIsOperatorType(is)
                                  computeTypeAfterIsOrAs(is)
                                  listener: handleIdentifier(String, typeReference)
                                  listener: handleNoTypeArguments(?)
                                  listener: handleType(String, null)
                                  listener: endIsOperatorType(is)
                                  listener: handleIsOperator(is, null)
                                  skipChainedAsIsOperators(String)
                                parseConditionalExpressionRest(String)
                                  listener: beginConditionalExpression(?)
                                  parseExpressionWithoutCascade(?)
                                    parsePrecedenceExpression(?, 1, false)
                                      parseUnaryExpression(?, false)
                                        parsePrimary(?, expression)
                                          parseLiteralInt(?)
                                            listener: handleLiteralInt(4)
                                  ensureColon(4)
                                  listener: handleConditionalExpressionColon()
                                  parseExpressionWithoutCascade(:)
                                    parsePrecedenceExpression(:, 1, false)
                                      parseUnaryExpression(:, false)
                                        parsePrimary(:, expression)
                                          parseLiteralInt(:)
                                            listener: handleLiteralInt(2)
                                      listener: beginBinaryExpression(==)
                                      parsePrecedenceExpression(==, 8, false)
                                        parseUnaryExpression(==, false)
                                          parsePrimary(==, expression)
                                            parseLiteralInt(==)
                                              listener: handleLiteralInt(4)
                                      listener: endBinaryExpression(==)
                                  listener: endConditionalExpression(?, :)
                            ensureCloseParen(4, ()
                          listener: handleParenthesizedCondition(()
                        listener: beginThenStatement({)
                        parseStatement())
                          parseStatementX())
                            parseBlock(), BlockKind(statement))
                              ensureBlock(), null, null)
                              listener: beginBlock({, BlockKind(statement))
                              notEofOrValue(}, print)
                              parseStatement({)
                                parseStatementX({)
                                  parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                                    looksLikeLocalFunction(print)
                                    parseExpressionStatement({)
                                      parseExpression({)
                                        parsePrecedenceExpression({, 1, true)
                                          parseUnaryExpression({, true)
                                            parsePrimary({, expression)
                                              parseSendOrFunctionLiteral({, expression)
                                                looksLikeFunctionBody(;)
                                                parseSend({, expression)
                                                  ensureIdentifier({, expression)
                                                    listener: handleIdentifier(print, expression)
                                                  listener: handleNoTypeArguments(()
                                                  parseArgumentsOpt(print)
                                                    parseArguments(print)
                                                      parseArgumentsRest(()
                                                        listener: beginArguments(()
                                                        parseExpression(()
                                                          parsePrecedenceExpression((, 1, true)
                                                            parseUnaryExpression((, true)
                                                              parsePrimary((, expression)
                                                                parseLiteralString(()
                                                                  parseSingleLiteralString(()
                                                                    listener: beginLiteralString("hello")
                                                                    listener: endLiteralString(0, ))
                                                        listener: endArguments(1, (, ))
                                                  listener: handleSend(print, ;)
                                      ensureSemicolon())
                                      listener: handleExpressionStatement(;)
                              notEofOrValue(}, })
                              listener: endBlock(1, {, }, BlockKind(statement))
                        listener: endThenStatement(})
                        listener: endIfStatement(if, null)
                  notEofOrValue(}, })
                  listener: endBlockFunctionBody(1, {, })
                listener: endClassMethod(null, void, (, null, })
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinBody(DeclarationKind.Class, 5, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(1, )