Problems reported:

parser/error_recovery/issue_49116:5:3: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture();
  ^^^^^

parser/error_recovery/issue_49116:6:7: 'await' can only be used in 'async' or 'async*' methods.
  if (await returnsFuture()) {}
      ^^^^^

parser/error_recovery/issue_49116:7:13: 'await' can only be used in 'async' or 'async*' methods.
  else if (!await returnsFuture()) {}
            ^^^^^

parser/error_recovery/issue_49116:8:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture());
        ^^^^^

parser/error_recovery/issue_49116:9:7: 'await' can only be used in 'async' or 'async*' methods.
  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
      ^^^^^

parser/error_recovery/issue_49116:9:30: 'await' can only be used in 'async' or 'async*' methods.
  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
                             ^^^^^

parser/error_recovery/issue_49116:9:53: 'await' can only be used in 'async' or 'async*' methods.
  xor(await returnsFuture(), await returnsFuture(), await returnsFuture());
                                                    ^^^^^

parser/error_recovery/issue_49116:10:3: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture() ^ await returnsFuture();
  ^^^^^

parser/error_recovery/issue_49116:10:27: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture() ^ await returnsFuture();
                          ^^^^^

parser/error_recovery/issue_49116:11:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture() ^ await returnsFuture());
        ^^^^^

parser/error_recovery/issue_49116:11:33: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture() ^ await returnsFuture());
                                ^^^^^

parser/error_recovery/issue_49116:12:3: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture() + await returnsFuture();
  ^^^^^

parser/error_recovery/issue_49116:12:27: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture() + await returnsFuture();
                          ^^^^^

parser/error_recovery/issue_49116:13:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture() + await returnsFuture());
        ^^^^^

parser/error_recovery/issue_49116:13:33: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture() + await returnsFuture());
                                ^^^^^

parser/error_recovery/issue_49116:14:3: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture() - await returnsFuture();
  ^^^^^

parser/error_recovery/issue_49116:14:27: 'await' can only be used in 'async' or 'async*' methods.
  await returnsFuture() - await returnsFuture();
                          ^^^^^

parser/error_recovery/issue_49116:15:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture() - await returnsFuture());
        ^^^^^

parser/error_recovery/issue_49116:15:33: 'await' can only be used in 'async' or 'async*' methods.
  print(await returnsFuture() - await returnsFuture());
                                ^^^^^

parser/error_recovery/issue_49116:16:4: 'await' can only be used in 'async' or 'async*' methods.
  !await returnsFuture() ^ !await returnsFuture();
   ^^^^^

parser/error_recovery/issue_49116:16:29: 'await' can only be used in 'async' or 'async*' methods.
  !await returnsFuture() ^ !await returnsFuture();
                            ^^^^^

parser/error_recovery/issue_49116:17:10: 'await' can only be used in 'async' or 'async*' methods.
  print(!await returnsFuture() ^ !await returnsFuture());
         ^^^^^

parser/error_recovery/issue_49116:17:35: 'await' can only be used in 'async' or 'async*' methods.
  print(!await returnsFuture() ^ !await returnsFuture());
                                  ^^^^^

parser/error_recovery/issue_49116:21:7: 'await' can only be used in 'async' or 'async*' methods.
  if (await f) {}
      ^^^^^

parser/error_recovery/issue_49116:22:13: 'await' can only be used in 'async' or 'async*' methods.
  else if (!await f) {}
            ^^^^^

parser/error_recovery/issue_49116:23:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await f);
        ^^^^^

parser/error_recovery/issue_49116:24:7: 'await' can only be used in 'async' or 'async*' methods.
  xor(await f, await f, await f);
      ^^^^^

parser/error_recovery/issue_49116:24:16: 'await' can only be used in 'async' or 'async*' methods.
  xor(await f, await f, await f);
               ^^^^^

parser/error_recovery/issue_49116:24:25: 'await' can only be used in 'async' or 'async*' methods.
  xor(await f, await f, await f);
                        ^^^^^

parser/error_recovery/issue_49116:25:3: 'await' can only be used in 'async' or 'async*' methods.
  await f ^ await f;
  ^^^^^

parser/error_recovery/issue_49116:25:13: 'await' can only be used in 'async' or 'async*' methods.
  await f ^ await f;
            ^^^^^

parser/error_recovery/issue_49116:26:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await f ^ await f);
        ^^^^^

parser/error_recovery/issue_49116:26:19: 'await' can only be used in 'async' or 'async*' methods.
  print(await f ^ await f);
                  ^^^^^

parser/error_recovery/issue_49116:27:3: 'await' can only be used in 'async' or 'async*' methods.
  await f + await f;
  ^^^^^

parser/error_recovery/issue_49116:27:13: 'await' can only be used in 'async' or 'async*' methods.
  await f + await f;
            ^^^^^

parser/error_recovery/issue_49116:28:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await f + await f);
        ^^^^^

parser/error_recovery/issue_49116:28:19: 'await' can only be used in 'async' or 'async*' methods.
  print(await f + await f);
                  ^^^^^

parser/error_recovery/issue_49116:29:3: 'await' can only be used in 'async' or 'async*' methods.
  await f - await f;
  ^^^^^

parser/error_recovery/issue_49116:29:13: 'await' can only be used in 'async' or 'async*' methods.
  await f - await f;
            ^^^^^

parser/error_recovery/issue_49116:30:9: 'await' can only be used in 'async' or 'async*' methods.
  print(await f - await f);
        ^^^^^

parser/error_recovery/issue_49116:30:19: 'await' can only be used in 'async' or 'async*' methods.
  print(await f - await f);
                  ^^^^^

parser/error_recovery/issue_49116:31:4: 'await' can only be used in 'async' or 'async*' methods.
  !await f ^ !await f;
   ^^^^^

parser/error_recovery/issue_49116:31:15: 'await' can only be used in 'async' or 'async*' methods.
  !await f ^ !await f;
              ^^^^^

parser/error_recovery/issue_49116:32:10: 'await' can only be used in 'async' or 'async*' methods.
  print(!await f ^ !await f);
         ^^^^^

parser/error_recovery/issue_49116:32:21: 'await' can only be used in 'async' or 'async*' methods.
  print(!await f ^ !await f);
                    ^^^^^

beginCompilationUnit(Future)
  beginMetadataStar(Future)
  endMetadataStar(0)
  beginTopLevelMember(Future)
    beginTopLevelMethod(, null, null)
      handleIdentifier(Future, typeReference)
      beginTypeArguments(<)
        handleIdentifier(bool, typeReference)
        handleNoTypeArguments(>)
        handleType(bool, null)
      endTypeArguments(1, <, >)
      handleType(Future, null)
      handleIdentifier(returnsFuture, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
      handleAsyncModifier(null, null)
      beginNewExpression(new)
        handleIdentifier(Future, constructorReference)
        beginConstructorReference(Future)
          handleIdentifier(value, constructorReferenceContinuation)
          handleQualified(.)
          handleNoTypeArguments(()
          handleNoConstructorReferenceContinuationAfterTypeArguments(()
        endConstructorReference(Future, null, (, ConstructorReferenceContext.New)
        beginArguments(()
          handleLiteralBool(true)
        endArguments(1, (, ))
      endNewExpression(new)
      handleExpressionFunctionBody(=>, ;)
    endTopLevelMethod(Future, null, ;)
  endTopLevelDeclaration(void)
  beginMetadataStar(void)
  endMetadataStar(0)
  beginTopLevelMember(void)
    beginTopLevelMethod(;, null, null)
      handleVoidKeyword(void)
      handleIdentifier(foo, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
      handleAsyncModifier(null, null)
      beginBlockFunctionBody({)
        beginAwaitExpression(await)
          handleIdentifier(returnsFuture, expression)
          handleNoTypeArguments(()
          beginArguments(()
          endArguments(0, (, ))
          handleSend(returnsFuture, ;)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        handleExpressionStatement(;)
        beginIfStatement(if)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ))
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ), AwaitNotAsync)
          handleParenthesizedCondition(()
          beginThenStatement({)
            beginBlock({, BlockKind(statement))
            endBlock(0, {, }, BlockKind(statement))
          endThenStatement(})
          beginElseStatement(else)
            beginIfStatement(if)
              beginAwaitExpression(await)
                handleIdentifier(returnsFuture, expression)
                handleNoTypeArguments(()
                beginArguments(()
                endArguments(0, (, ))
                handleSend(returnsFuture, ))
                handleRecoverableError(AwaitNotAsync, await, await)
              endInvalidAwaitExpression(await, ), AwaitNotAsync)
              handleUnaryPrefixExpression(!)
              handleParenthesizedCondition(()
              beginThenStatement({)
                beginBlock({, BlockKind(statement))
                endBlock(0, {, }, BlockKind(statement))
              endThenStatement(})
            endIfStatement(if, null)
          endElseStatement(else)
        endIfStatement(if, else)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ))
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ), AwaitNotAsync)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        handleIdentifier(xor, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ,)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ,)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ))
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ), AwaitNotAsync)
        endArguments(3, (, ))
        handleSend(xor, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(returnsFuture, expression)
          handleNoTypeArguments(()
          beginArguments(()
          endArguments(0, (, ))
          handleSend(returnsFuture, ^)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
        beginBinaryExpression(^)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        endBinaryExpression(^)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ^)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
          beginBinaryExpression(^)
            beginAwaitExpression(await)
              handleIdentifier(returnsFuture, expression)
              handleNoTypeArguments(()
              beginArguments(()
              endArguments(0, (, ))
              handleSend(returnsFuture, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
          endBinaryExpression(^)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(returnsFuture, expression)
          handleNoTypeArguments(()
          beginArguments(()
          endArguments(0, (, ))
          handleSend(returnsFuture, +)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, +, AwaitNotAsync)
        beginBinaryExpression(+)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        endBinaryExpression(+)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, +)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, +, AwaitNotAsync)
          beginBinaryExpression(+)
            beginAwaitExpression(await)
              handleIdentifier(returnsFuture, expression)
              handleNoTypeArguments(()
              beginArguments(()
              endArguments(0, (, ))
              handleSend(returnsFuture, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
          endBinaryExpression(+)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(returnsFuture, expression)
          handleNoTypeArguments(()
          beginArguments(()
          endArguments(0, (, ))
          handleSend(returnsFuture, -)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, -, AwaitNotAsync)
        beginBinaryExpression(-)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        endBinaryExpression(-)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, -)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, -, AwaitNotAsync)
          beginBinaryExpression(-)
            beginAwaitExpression(await)
              handleIdentifier(returnsFuture, expression)
              handleNoTypeArguments(()
              beginArguments(()
              endArguments(0, (, ))
              handleSend(returnsFuture, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
          endBinaryExpression(-)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(returnsFuture, expression)
          handleNoTypeArguments(()
          beginArguments(()
          endArguments(0, (, ))
          handleSend(returnsFuture, ^)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
        handleUnaryPrefixExpression(!)
        beginBinaryExpression(^)
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
          handleUnaryPrefixExpression(!)
        endBinaryExpression(^)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(returnsFuture, expression)
            handleNoTypeArguments(()
            beginArguments(()
            endArguments(0, (, ))
            handleSend(returnsFuture, ^)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
          handleUnaryPrefixExpression(!)
          beginBinaryExpression(^)
            beginAwaitExpression(await)
              handleIdentifier(returnsFuture, expression)
              handleNoTypeArguments(()
              beginArguments(()
              endArguments(0, (, ))
              handleSend(returnsFuture, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
            handleUnaryPrefixExpression(!)
          endBinaryExpression(^)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginMetadataStar(var)
        endMetadataStar(0)
        handleNoType(var)
        beginVariablesDeclaration(f, null, var)
          handleIdentifier(f, localVariableDeclaration)
          beginInitializedIdentifier(f)
            beginVariableInitializer(=)
              handleIdentifier(returnsFuture, expression)
              handleNoTypeArguments(()
              beginArguments(()
              endArguments(0, (, ))
              handleSend(returnsFuture, ;)
            endVariableInitializer(=)
          endInitializedIdentifier(f)
        endVariablesDeclaration(1, ;)
        beginMetadataStar(await)
        endMetadataStar(0)
        handleIdentifier(await, typeReference)
        handleNoTypeArguments(f)
        handleType(await, null)
        beginVariablesDeclaration(f, null, null)
          handleIdentifier(f, localVariableDeclaration)
          beginInitializedIdentifier(f)
            handleNoVariableInitializer(f)
          endInitializedIdentifier(f)
        endVariablesDeclaration(1, ;)
        beginIfStatement(if)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments())
            handleNoArguments())
            handleSend(f, ))
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ), AwaitNotAsync)
          handleParenthesizedCondition(()
          beginThenStatement({)
            beginBlock({, BlockKind(statement))
            endBlock(0, {, }, BlockKind(statement))
          endThenStatement(})
          beginElseStatement(else)
            beginIfStatement(if)
              beginAwaitExpression(await)
                handleIdentifier(f, expression)
                handleNoTypeArguments())
                handleNoArguments())
                handleSend(f, ))
                handleRecoverableError(AwaitNotAsync, await, await)
              endInvalidAwaitExpression(await, ), AwaitNotAsync)
              handleUnaryPrefixExpression(!)
              handleParenthesizedCondition(()
              beginThenStatement({)
                beginBlock({, BlockKind(statement))
                endBlock(0, {, }, BlockKind(statement))
              endThenStatement(})
            endIfStatement(if, null)
          endElseStatement(else)
        endIfStatement(if, else)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments())
            handleNoArguments())
            handleSend(f, ))
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ), AwaitNotAsync)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        handleIdentifier(xor, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(,)
            handleNoArguments(,)
            handleSend(f, ,)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(,)
            handleNoArguments(,)
            handleSend(f, ,)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ,, AwaitNotAsync)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments())
            handleNoArguments())
            handleSend(f, ))
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ), AwaitNotAsync)
        endArguments(3, (, ))
        handleSend(xor, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(f, expression)
          handleNoTypeArguments(^)
          handleNoArguments(^)
          handleSend(f, ^)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
        beginBinaryExpression(^)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(;)
            handleNoArguments(;)
            handleSend(f, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        endBinaryExpression(^)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(^)
            handleNoArguments(^)
            handleSend(f, ^)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
          beginBinaryExpression(^)
            beginAwaitExpression(await)
              handleIdentifier(f, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(f, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
          endBinaryExpression(^)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(f, expression)
          handleNoTypeArguments(+)
          handleNoArguments(+)
          handleSend(f, +)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, +, AwaitNotAsync)
        beginBinaryExpression(+)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(;)
            handleNoArguments(;)
            handleSend(f, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        endBinaryExpression(+)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(+)
            handleNoArguments(+)
            handleSend(f, +)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, +, AwaitNotAsync)
          beginBinaryExpression(+)
            beginAwaitExpression(await)
              handleIdentifier(f, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(f, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
          endBinaryExpression(+)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(f, expression)
          handleNoTypeArguments(-)
          handleNoArguments(-)
          handleSend(f, -)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, -, AwaitNotAsync)
        beginBinaryExpression(-)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(;)
            handleNoArguments(;)
            handleSend(f, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
        endBinaryExpression(-)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(-)
            handleNoArguments(-)
            handleSend(f, -)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, -, AwaitNotAsync)
          beginBinaryExpression(-)
            beginAwaitExpression(await)
              handleIdentifier(f, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(f, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
          endBinaryExpression(-)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginAwaitExpression(await)
          handleIdentifier(f, expression)
          handleNoTypeArguments(^)
          handleNoArguments(^)
          handleSend(f, ^)
          handleRecoverableError(AwaitNotAsync, await, await)
        endInvalidAwaitExpression(await, ^, AwaitNotAsync)
        handleUnaryPrefixExpression(!)
        beginBinaryExpression(^)
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(;)
            handleNoArguments(;)
            handleSend(f, ;)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ;, AwaitNotAsync)
          handleUnaryPrefixExpression(!)
        endBinaryExpression(^)
        handleExpressionStatement(;)
        handleIdentifier(print, expression)
        handleNoTypeArguments(()
        beginArguments(()
          beginAwaitExpression(await)
            handleIdentifier(f, expression)
            handleNoTypeArguments(^)
            handleNoArguments(^)
            handleSend(f, ^)
            handleRecoverableError(AwaitNotAsync, await, await)
          endInvalidAwaitExpression(await, ^, AwaitNotAsync)
          handleUnaryPrefixExpression(!)
          beginBinaryExpression(^)
            beginAwaitExpression(await)
              handleIdentifier(f, expression)
              handleNoTypeArguments())
              handleNoArguments())
              handleSend(f, ))
              handleRecoverableError(AwaitNotAsync, await, await)
            endInvalidAwaitExpression(await, ), AwaitNotAsync)
            handleUnaryPrefixExpression(!)
          endBinaryExpression(^)
        endArguments(1, (, ))
        handleSend(print, ;)
        handleExpressionStatement(;)
        beginMetadataStar(await)
        endMetadataStar(0)
        handleIdentifier(await, typeReference)
        handleNoTypeArguments(x)
        handleType(await, null)
        beginVariablesDeclaration(x, null, null)
          handleIdentifier(x, localVariableDeclaration)
          beginInitializedIdentifier(x)
            handleNoVariableInitializer(x)
          endInitializedIdentifier(x)
        endVariablesDeclaration(1, ;)
        beginMetadataStar(await)
        endMetadataStar(0)
        handleIdentifier(await, typeReference)
        handleNoTypeArguments(y)
        handleType(await, null)
        beginVariablesDeclaration(y, null, null)
          handleIdentifier(y, localVariableDeclaration)
          beginInitializedIdentifier(y)
            handleNoVariableInitializer(y)
          endInitializedIdentifier(y)
          handleIdentifier(z, localVariableDeclaration)
          beginInitializedIdentifier(z)
            handleNoVariableInitializer(z)
          endInitializedIdentifier(z)
        endVariablesDeclaration(2, ;)
        beginMetadataStar(await)
        endMetadataStar(0)
        handleIdentifier(await, typeReference)
        handleNoTypeArguments(x2)
        handleType(await, null)
        beginVariablesDeclaration(x2, null, null)
          handleIdentifier(x2, localVariableDeclaration)
          beginInitializedIdentifier(x2)
            beginVariableInitializer(=)
              handleIdentifier(await, expression)
              handleNoTypeArguments(;)
              handleNoArguments(;)
              handleSend(await, ;)
            endVariableInitializer(=)
          endInitializedIdentifier(x2)
        endVariablesDeclaration(1, ;)
        beginMetadataStar(await)
        endMetadataStar(0)
        handleIdentifier(await, typeReference)
        handleNoTypeArguments(y2)
        handleType(await, null)
        beginVariablesDeclaration(y2, null, null)
          handleIdentifier(y2, localVariableDeclaration)
          beginInitializedIdentifier(y2)
            beginVariableInitializer(=)
              handleIdentifier(await, expression)
              handleNoTypeArguments(,)
              handleNoArguments(,)
              handleSend(await, ,)
            endVariableInitializer(=)
          endInitializedIdentifier(y2)
          handleIdentifier(z2, localVariableDeclaration)
          beginInitializedIdentifier(z2)
            beginVariableInitializer(=)
              handleIdentifier(await, expression)
              handleNoTypeArguments(;)
              handleNoArguments(;)
              handleSend(await, ;)
            endVariableInitializer(=)
          endInitializedIdentifier(z2)
        endVariablesDeclaration(2, ;)
        beginMetadataStar(await)
        endMetadataStar(0)
        handleNoTypeVariables(()
        beginLocalFunctionDeclaration(await)
          handleIdentifier(await, typeReference)
          handleNoTypeArguments(foo)
          handleType(await, null)
          beginFunctionName(foo)
            handleIdentifier(foo, localFunctionDeclaration)
          endFunctionName(await, ()
          beginFormalParameters((, MemberKind.Local)
            beginMetadataStar(int)
            endMetadataStar(0)
            beginFormalParameter(int, MemberKind.Local, null, null, null)
              handleIdentifier(int, typeReference)
              handleNoTypeArguments(bar)
              handleType(int, null)
              handleIdentifier(bar, formalParameterDeclaration)
              handleFormalParameterWithoutValue())
            endFormalParameter(null, null, null, bar, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
          endFormalParameters(1, (, ), MemberKind.Local)
          handleNoInitializers()
          handleAsyncModifier(null, null)
          beginBlockFunctionBody({)
            beginReturnStatement(return)
              beginNewExpression(new)
                handleIdentifier(await, constructorReference)
                beginConstructorReference(await)
                  handleNoTypeArguments(()
                  handleNoConstructorReferenceContinuationAfterTypeArguments(()
                endConstructorReference(await, null, (, ConstructorReferenceContext.New)
                beginArguments(()
                endArguments(0, (, ))
              endNewExpression(new)
            endReturnStatement(true, return, ;)
          endBlockFunctionBody(1, {, })
        endLocalFunctionDeclaration(})
        beginMetadataStar(await)
        endMetadataStar(0)
        handleNoTypeVariables(()
        beginLocalFunctionDeclaration(await)
          handleIdentifier(await, typeReference)
          handleNoTypeArguments(bar)
          handleType(await, null)
          beginFunctionName(bar)
            handleIdentifier(bar, localFunctionDeclaration)
          endFunctionName(await, ()
          beginFormalParameters((, MemberKind.Local)
            beginMetadataStar(await)
            endMetadataStar(0)
            beginFormalParameter(await, MemberKind.Local, null, null, null)
              handleIdentifier(await, typeReference)
              handleNoTypeArguments(baz)
              handleType(await, null)
              handleIdentifier(baz, formalParameterDeclaration)
              handleFormalParameterWithoutValue(,)
            endFormalParameter(null, null, null, baz, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
            beginMetadataStar(await)
            endMetadataStar(0)
            beginFormalParameter(await, MemberKind.Local, null, null, null)
              handleIdentifier(await, typeReference)
              handleNoTypeArguments(baz2)
              handleType(await, null)
              handleIdentifier(baz2, formalParameterDeclaration)
              handleFormalParameterWithoutValue(,)
            endFormalParameter(null, null, null, baz2, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
            beginMetadataStar(await)
            endMetadataStar(0)
            beginFormalParameter(await, MemberKind.Local, null, null, null)
              handleIdentifier(await, typeReference)
              handleNoTypeArguments(baz3)
              handleType(await, null)
              handleIdentifier(baz3, formalParameterDeclaration)
              handleFormalParameterWithoutValue())
            endFormalParameter(null, null, null, baz3, null, null, FormalParameterKind.requiredPositional, MemberKind.Local)
          endFormalParameters(3, (, ), MemberKind.Local)
          handleNoInitializers()
          handleAsyncModifier(null, null)
          beginBlockFunctionBody({)
            beginReturnStatement(return)
              handleIdentifier(baz, expression)
              handleNoTypeArguments(;)
              handleNoArguments(;)
              handleSend(baz, ;)
            endReturnStatement(true, return, ;)
          endBlockFunctionBody(1, {, })
        endLocalFunctionDeclaration(})
      endBlockFunctionBody(31, {, })
    endTopLevelMethod(void, null, })
  endTopLevelDeclaration(bool)
  beginMetadataStar(bool)
  endMetadataStar(0)
  beginTopLevelMember(bool)
    beginTopLevelMethod(}, null, null)
      handleIdentifier(bool, typeReference)
      handleNoTypeArguments(xor)
      handleType(bool, null)
      handleIdentifier(xor, topLevelFunctionDeclaration)
      handleNoTypeVariables(()
      beginFormalParameters((, MemberKind.TopLevelMethod)
        beginMetadataStar(bool)
        endMetadataStar(0)
        beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(bool, typeReference)
          handleNoTypeArguments(a)
          handleType(bool, null)
          handleIdentifier(a, formalParameterDeclaration)
          handleFormalParameterWithoutValue(,)
        endFormalParameter(null, null, null, a, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
        beginMetadataStar(bool)
        endMetadataStar(0)
        beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(bool, typeReference)
          handleNoTypeArguments(b)
          handleType(bool, null)
          handleIdentifier(b, formalParameterDeclaration)
          handleFormalParameterWithoutValue(,)
        endFormalParameter(null, null, null, b, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
        beginMetadataStar(bool)
        endMetadataStar(0)
        beginFormalParameter(bool, MemberKind.TopLevelMethod, null, null, null)
          handleIdentifier(bool, typeReference)
          handleNoTypeArguments(c)
          handleType(bool, null)
          handleIdentifier(c, formalParameterDeclaration)
          handleFormalParameterWithoutValue())
        endFormalParameter(null, null, null, c, null, null, FormalParameterKind.requiredPositional, MemberKind.TopLevelMethod)
      endFormalParameters(3, (, ), MemberKind.TopLevelMethod)
      handleAsyncModifier(null, null)
      beginBlockFunctionBody({)
        beginReturnStatement(return)
          handleIdentifier(b, expression)
          handleNoTypeArguments(^)
          handleNoArguments(^)
          handleSend(b, ^)
          beginBinaryExpression(^)
            handleIdentifier(b, expression)
            handleNoTypeArguments(^)
            handleNoArguments(^)
            handleSend(b, ^)
          endBinaryExpression(^)
          beginBinaryExpression(^)
            handleIdentifier(c, expression)
            handleNoTypeArguments(;)
            handleNoArguments(;)
            handleSend(c, ;)
          endBinaryExpression(^)
        endReturnStatement(true, return, ;)
      endBlockFunctionBody(1, {, })
    endTopLevelMethod(bool, null, })
  endTopLevelDeclaration(class)
  beginMetadataStar(class)
  endMetadataStar(0)
  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
    handleIdentifier(await, classOrMixinDeclaration)
    handleNoTypeVariables({)
    beginClassDeclaration(class, null, null, null, await)
      handleNoType(await)
      handleClassExtends(null, 1)
      handleClassNoWithClause()
      handleImplements(null, 0)
      handleClassHeader(class, class, null)
      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 0, {, })
    endClassDeclaration(class, })
  endTopLevelDeclaration()
endCompilationUnit(4, )