parseUnit(class)
  skipErrorTokens(class)
  listener: beginCompilationUnit(class)
  syntheticPreviousToken(class)
  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
    parseMetadataStar()
      listener: beginMetadataStar(class)
      listener: endMetadataStar(0)
    parseTopLevelKeywordDeclaration(, class, null, Instance of 'DirectiveContext')
      parseClassOrNamedMixinApplication(null, null, null, class)
        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
        ensureIdentifier(class, classOrMixinDeclaration)
          listener: handleIdentifier(Foo, classOrMixinDeclaration)
        listener: handleNoTypeVariables({)
        listener: beginClassDeclaration(class, null, null, null, Foo)
        parseClass(Foo, class, class, Foo)
          parseClassHeaderOpt(Foo, class, class)
            parseClassExtendsOpt(Foo)
              listener: handleNoType(Foo)
              listener: handleClassExtends(null, 1)
            parseClassWithClauseOpt(Foo)
              listener: handleClassNoWithClause()
            parseClassOrMixinOrEnumImplementsOpt(Foo)
              listener: handleImplements(null, 0)
            listener: handleClassHeader(class, class, null)
          parseClassOrMixinOrExtensionBody(Foo, DeclarationKind.Class, Foo)
            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
            notEofOrValue(}, Foo)
            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Foo)
              parseMetadataStar({)
                listener: beginMetadataStar(Foo)
                listener: endMetadataStar(0)
              listener: beginMember()
              parseMethod({, null, null, null, null, null, null, null, {, Instance of 'SimpleType', null, operator, DeclarationKind.Class, Foo, false)
                reportRecoverableErrorWithEnd(>>, >, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
                  listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >)
                rewriter()
                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, operator)
                listener: handleIdentifier(Foo, typeReference)
                listener: handleNoTypeArguments(operator)
                listener: handleType(Foo, null)
                parseOperatorName(Foo)
                  listener: handleOperatorName(operator, >>>)
                parseMethodTypeVar(>>>)
                  listener: handleNoTypeVariables(()
                parseGetterOrFormalParameters(>>>, operator, false, MemberKind.NonStaticMethod)
                  parseFormalParameters(>>>, MemberKind.NonStaticMethod)
                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
                      parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
                        parseMetadataStar(()
                          listener: beginMetadataStar(_)
                          listener: endMetadataStar(0)
                        listener: beginFormalParameter(_, MemberKind.NonStaticMethod, null, null, null)
                        listener: handleNoType(()
                        ensureIdentifier((, formalParameterDeclaration)
                          listener: handleIdentifier(_, formalParameterDeclaration)
                        listener: handleFormalParameterWithoutValue())
                        listener: endFormalParameter(null, null, null, _, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
                parseInitializersOpt())
                  listener: handleNoInitializers()
                parseAsyncModifierOpt())
                  listener: handleAsyncModifier(null, null)
                  inPlainSync()
                inPlainSync()
                parseFunctionBody(), false, true)
                  parseExpressionFunctionBody(=>, false)
                    parseExpression(=>)
                      parsePrecedenceExpression(=>, 1, true)
                        parseUnaryExpression(=>, true)
                          parsePrimary(=>, expression)
                            parseThisExpression(=>, expression)
                              listener: handleThisExpression(this, expression)
                    ensureSemicolon(this)
                    listener: handleExpressionFunctionBody(=>, ;)
                    inGenerator()
                listener: endClassMethod(null, Foo, (, null, ;)
              listener: endMember()
            notEofOrValue(}, })
            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
          listener: endClassDeclaration(class, })
  listener: endTopLevelDeclaration(main)
  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
    parseMetadataStar(})
      listener: beginMetadataStar(main)
      listener: endMetadataStar(0)
    parseTopLevelMemberImpl(})
      listener: beginTopLevelMember(main)
      isReservedKeyword(()
      parseTopLevelMethod(}, null, null, }, Instance of '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(}, Foo)
          parseStatement({)
            parseStatementX({)
              parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
                looksLikeLocalFunction(foo)
                listener: beginMetadataStar(Foo)
                listener: endMetadataStar(0)
                listener: handleIdentifier(Foo, typeReference)
                listener: handleNoTypeArguments(foo)
                listener: handleType(Foo, null)
                listener: beginVariablesDeclaration(foo, null, null)
                parseVariablesDeclarationRest(Foo, true)
                  parseOptionallyInitializedIdentifier(Foo)
                    ensureIdentifier(Foo, localVariableDeclaration)
                      listener: handleIdentifier(foo, localVariableDeclaration)
                    listener: beginInitializedIdentifier(foo)
                    parseVariableInitializerOpt(foo)
                      listener: beginVariableInitializer(=)
                      parseExpression(=)
                        parsePrecedenceExpression(=, 1, true)
                          parseUnaryExpression(=, true)
                            parsePrimary(=, expression)
                              parseNewExpression(=)
                                isNextIdentifier(new)
                                listener: beginNewExpression(new)
                                parseConstructorReference(new, ConstructorReferenceContext.New, null)
                                  ensureIdentifier(new, constructorReference)
                                    listener: handleIdentifier(Foo, constructorReference)
                                  listener: beginConstructorReference(Foo)
                                  parseQualifiedRestOpt(Foo, constructorReferenceContinuation)
                                  listener: handleNoTypeArguments(()
                                  listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
                                  listener: endConstructorReference(Foo, null, (, ConstructorReferenceContext.New)
                                parseConstructorInvocationArguments(Foo)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    listener: endArguments(0, (, ))
                                listener: endNewExpression(new)
                      listener: endVariableInitializer(=)
                    listener: endInitializedIdentifier(foo)
                  ensureSemicolon())
                  listener: endVariablesDeclaration(1, ;)
          notEofOrValue(}, foo)
          parseStatement(;)
            parseStatementX(;)
              parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
                looksLikeLocalFunction(foo)
                parseExpressionStatement(;)
                  parseExpression(;)
                    parsePrecedenceExpression(;, 1, true)
                      parseUnaryExpression(;, true)
                        parsePrimary(;, expression)
                          parseSendOrFunctionLiteral(;, expression)
                            parseSend(;, expression)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(foo, expression)
                              listener: handleNoTypeArguments(>>)
                              parseArgumentsOpt(foo)
                                listener: handleNoArguments(>>)
                              listener: handleSend(foo, >>)
                      reportRecoverableErrorWithEnd(>>, >, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
                        listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >)
                      rewriter()
                      listener: beginBinaryExpression(>>>)
                      parsePrecedenceExpression(>>>, 13, true)
                        parseUnaryExpression(>>>, true)
                          parsePrimary(>>>, expression)
                            parseLiteralInt(>>>)
                              listener: handleLiteralInt(42)
                      listener: endBinaryExpression(>>>)
                  ensureSemicolon(42)
                  listener: handleExpressionStatement(;)
          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)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(foo, expression)
                                                listener: handleNoTypeArguments(>>)
                                                parseArgumentsOpt(foo)
                                                  listener: handleNoArguments(>>)
                                                listener: handleSend(foo, >>)
                                        reportRecoverableErrorWithEnd(>>, >, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
                                          listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >)
                                        rewriter()
                                        listener: beginBinaryExpression(>>>)
                                        parsePrecedenceExpression(>>>, 13, true)
                                          parseUnaryExpression(>>>, true)
                                            parsePrimary(>>>, expression)
                                              parseLiteralInt(>>>)
                                                listener: handleLiteralInt(42)
                                        listener: endBinaryExpression(>>>)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          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)
                              isNextIdentifier(;)
                              ensureIdentifier(;, expression)
                                listener: handleIdentifier(print, expression)
                              listener: handleNoTypeArguments(()
                              parseArgumentsOpt(print)
                                parseArguments(print)
                                  parseArgumentsRest(()
                                    listener: beginArguments(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(foo, expression)
                                                listener: handleNoTypeArguments(>>)
                                                parseArgumentsOpt(foo)
                                                  listener: handleNoArguments(>>)
                                                listener: handleSend(foo, >>)
                                        reportRecoverableErrorWithEnd(>>, >=, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
                                          listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >=)
                                        rewriter()
                                        parsePrecedenceExpression(>>>=, 1, true)
                                          parseUnaryExpression(>>>=, true)
                                            parsePrimary(>>>=, expression)
                                              parseLiteralInt(>>>=)
                                                listener: handleLiteralInt(42)
                                        listener: handleAssignmentExpression(>>>=)
                                    listener: endArguments(1, (, ))
                              listener: handleSend(print, ;)
                  ensureSemicolon())
                  listener: handleExpressionStatement(;)
          notEofOrValue(}, if)
          parseStatement(;)
            parseStatementX(;)
              parseIfStatement(;)
                listener: beginIfStatement(if)
                ensureParenthesizedCondition(if)
                  parseExpressionInParenthesisRest(()
                    parseExpression(()
                      parsePrecedenceExpression((, 1, true)
                        parseUnaryExpression((, true)
                          parsePrimary((, expression)
                            parseParenthesizedExpressionOrFunctionLiteral(()
                              parseParenthesizedExpression(()
                                parseExpressionInParenthesis(()
                                  parseExpressionInParenthesisRest(()
                                    parseExpression(()
                                      parsePrecedenceExpression((, 1, true)
                                        parseUnaryExpression((, true)
                                          parsePrimary((, expression)
                                            parseSendOrFunctionLiteral((, expression)
                                              parseSend((, expression)
                                                isNextIdentifier(()
                                                ensureIdentifier((, expression)
                                                  listener: handleIdentifier(foo, expression)
                                                listener: handleNoTypeArguments(>>)
                                                parseArgumentsOpt(foo)
                                                  listener: handleNoArguments(>>)
                                                listener: handleSend(foo, >>)
                                        reportRecoverableErrorWithEnd(>>, >=, Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}])
                                          listener: handleRecoverableError(Message[ExperimentNotEnabled, This requires the 'triple-shift' language feature to be enabled., Try updating your pubspec.yaml to set the minimum SDK constraint to 2.14 or higher, and running 'pub get'., {string: triple-shift, string2: 2.14}], >>, >=)
                                        rewriter()
                                        parsePrecedenceExpression(>>>=, 1, true)
                                          parseUnaryExpression(>>>=, true)
                                            parsePrimary(>>>=, expression)
                                              parseLiteralInt(>>>=)
                                                listener: handleLiteralInt(42)
                                        listener: handleAssignmentExpression(>>>=)
                                    ensureCloseParen(42, ()
                                listener: handleParenthesizedExpression(()
                        listener: beginBinaryExpression(==)
                        parsePrecedenceExpression(==, 8, true)
                          parseUnaryExpression(==, true)
                            parsePrimary(==, expression)
                              parseSendOrFunctionLiteral(==, expression)
                                parseSend(==, expression)
                                  isNextIdentifier(==)
                                  ensureIdentifier(==, expression)
                                    listener: handleIdentifier(foo, expression)
                                  listener: handleNoTypeArguments())
                                  parseArgumentsOpt(foo)
                                    listener: handleNoArguments())
                                  listener: handleSend(foo, ))
                        listener: endBinaryExpression(==)
                    ensureCloseParen(foo, ()
                  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)
                                          isNextIdentifier({)
                                          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("same")
                                                            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(5, {, })
        listener: endTopLevelMethod(main, null, })
  listener: endTopLevelDeclaration()
  reportAllErrorTokens(class)
  listener: endCompilationUnit(2, )