//===-- SemaCoroutine.cpp - Semantic Analysis for Coroutines --------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file implements semantic analysis for C++ Coroutines.

//

//  This file contains references to sections of the Coroutines TS, which

//  can be found at http://wg21.link/coroutines.

//

//===----------------------------------------------------------------------===//

#include "CoroutineStmtBuilder.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/Decl.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/StmtCXX.h"

#include "clang/Basic/Builtins.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/Overload.h"

#include "clang/Sema/ScopeInfo.h"

#include "clang/Sema/SemaInternal.h"

#include "llvm/ADT/SmallSet.h"

using namespace clang;

using namespace sema;

static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,

                                 SourceLocation Loc, bool &Res) {

  DeclarationName DN = S.PP.getIdentifierInfo(Name);

  LookupResult LR(S, DN, Loc, Sema::LookupMemberName);

  // Suppress diagnostics when a private member is selected. The same warnings

  // will be produced again when building the call.

  LR.suppressDiagnostics();

  Res = S.LookupQualifiedName(LR, RD);

  return LR;

}

static bool lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,

                         SourceLocation Loc) {

  bool Res;

  lookupMember(S, Name, RD, Loc, Res);

  return Res;

}

/// Look up the std::coroutine_traits<...>::promise_type for the given

/// function type.

static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,

                                  SourceLocation KwLoc) {

  const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>();

  const SourceLocation FuncLoc = FD->getLocation();

  NamespaceDecl *CoroNamespace = nullptr;

  ClassTemplateDecl *CoroTraits =

      S.lookupCoroutineTraits(KwLoc, FuncLoc, CoroNamespace);

  if (!CoroTraits) {

    return QualType();

  }

  // Form template argument list for coroutine_traits<R, P1, P2, ...> according

  // to [dcl.fct.def.coroutine]3

  TemplateArgumentListInfo Args(KwLoc, KwLoc);

  auto AddArg = [&](QualType T) {

    Args.addArgument(TemplateArgumentLoc(

        TemplateArgument(T), S.Context.getTrivialTypeSourceInfo(T, KwLoc)));

  };

  AddArg(FnType->getReturnType());

  // If the function is a non-static member function, add the type

  // of the implicit object parameter before the formal parameters.

  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {

    if (MD->isInstance()) {

      // [over.match.funcs]4

      // For non-static member functions, the type of the implicit object

      // parameter is

      //  -- "lvalue reference to cv X" for functions declared without a

      //      ref-qualifier or with the & ref-qualifier

      //  -- "rvalue reference to cv X" for functions declared with the &&

      //      ref-qualifier

      QualType T = MD->getThisType()->castAs<PointerType>()->getPointeeType();

      T = FnType->getRefQualifier() == RQ_RValue

              ? 
S.Context.getRValueReferenceType(T)37

              : 
S.Context.getLValueReferenceType(T, /*SpelledAsLValue*/ true)190
;

      AddArg(T);

    }

  }

  for (QualType T : FnType->getParamTypes())

    AddArg(T);

  // Build the template-id.

  QualType CoroTrait =

      S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args);

  if (CoroTrait.isNull())

    return QualType();

  if (S.RequireCompleteType(KwLoc, CoroTrait,

                            diag::err_coroutine_type_missing_specialization))

    return QualType();

  auto *RD = CoroTrait->getAsCXXRecordDecl();

  assert(RD && "specialization of class template is not a class?");

  // Look up the ::promise_type member.

  LookupResult R(S, &S.PP.getIdentifierTable().get("promise_type"), KwLoc,

                 Sema::LookupOrdinaryName);

  S.LookupQualifiedName(R, RD);

  auto *Promise = R.getAsSingle<TypeDecl>();

  if (!Promise) {

    S.Diag(FuncLoc,

           diag::err_implied_std_coroutine_traits_promise_type_not_found)

        << RD;

    return QualType();

  }

  // The promise type is required to be a class type.

  QualType PromiseType = S.Context.getTypeDeclType(Promise);

  auto buildElaboratedType = [&]() {

    auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, CoroNamespace);

    NNS = NestedNameSpecifier::Create(S.Context, NNS, false,

                                      CoroTrait.getTypePtr());

    return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);

  };

  if (!PromiseType->getAsCXXRecordDecl()) {

    S.Diag(FuncLoc,

           diag::err_implied_std_coroutine_traits_promise_type_not_class)

        << buildElaboratedType();

    return QualType();

  }

  if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),

                            diag::err_coroutine_promise_type_incomplete))

    return QualType();

  return PromiseType;

}

/// Look up the std::coroutine_handle<PromiseType>.

static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,

                                          SourceLocation Loc) {

  if (PromiseType.isNull())

    return QualType();

  NamespaceDecl *CoroNamespace = S.getCachedCoroNamespace();

  assert(CoroNamespace && "Should already be diagnosed");

  LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"),

                      Loc, Sema::LookupOrdinaryName);

  if (!S.LookupQualifiedName(Result, CoroNamespace)) {

    S.Diag(Loc, diag::err_implied_coroutine_type_not_found)

        << "std::coroutine_handle";

    return QualType();

  }

  ClassTemplateDecl *CoroHandle = Result.getAsSingle<ClassTemplateDecl>();

  if (!CoroHandle) {

    Result.suppressDiagnostics();

    // We found something weird. Complain about the first thing we found.

    NamedDecl *Found = *Result.begin();

    S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_handle);

    return QualType();

  }

  // Form template argument list for coroutine_handle<Promise>.

  TemplateArgumentListInfo Args(Loc, Loc);

  Args.addArgument(TemplateArgumentLoc(

      TemplateArgument(PromiseType),

      S.Context.getTrivialTypeSourceInfo(PromiseType, Loc)));

  // Build the template-id.

  QualType CoroHandleType =

      S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args);

  if (CoroHandleType.isNull())

    return QualType();

  if (S.RequireCompleteType(Loc, CoroHandleType,

                            diag::err_coroutine_type_missing_specialization))

    return QualType();

  return CoroHandleType;

}

static bool isValidCoroutineContext(Sema &S, SourceLocation Loc,

                                    StringRef Keyword) {

  // [expr.await]p2 dictates that 'co_await' and 'co_yield' must be used within

  // a function body.

  // FIXME: This also covers [expr.await]p2: "An await-expression shall not

  // appear in a default argument." But the diagnostic QoI here could be

  // improved to inform the user that default arguments specifically are not

  // allowed.

  auto *FD = dyn_cast<FunctionDecl>(S.CurContext);

  if (!FD) {

    S.Diag(Loc, isa<ObjCMethodDecl>(S.CurContext)

                    ? 
diag::err_coroutine_objc_method0

                    : diag::err_coroutine_outside_function) << Keyword;

    return false;

  }

  // An enumeration for mapping the diagnostic type to the correct diagnostic

  // selection index.

  enum InvalidFuncDiag {

    DiagCtor = 0,

    DiagDtor,

    DiagMain,

    DiagConstexpr,

    DiagAutoRet,

    DiagVarargs,

    DiagConsteval,

  };

  bool Diagnosed = false;

  auto DiagInvalid = [&](InvalidFuncDiag ID) {

    S.Diag(Loc, diag::err_coroutine_invalid_func_context) << ID << Keyword;

    Diagnosed = true;

    return false;

  };

  // Diagnose when a constructor, destructor

  // or the function 'main' are declared as a coroutine.

  auto *MD = dyn_cast<CXXMethodDecl>(FD);

  // [class.ctor]p11: "A constructor shall not be a coroutine."

  if (MD && 
isa<CXXConstructorDecl>(MD)1.76k
)

    return DiagInvalid(DiagCtor);

  // [class.dtor]p17: "A destructor shall not be a coroutine."

  else if (MD && 
isa<CXXDestructorDecl>(MD)1.75k
)

    return DiagInvalid(DiagDtor);

  // [basic.start.main]p3: "The function main shall not be a coroutine."

  else if (FD->isMain())

    return DiagInvalid(DiagMain);

  // Emit a diagnostics for each of the following conditions which is not met.

  // [expr.const]p2: "An expression e is a core constant expression unless the

  // evaluation of e [...] would evaluate one of the following expressions:

  // [...] an await-expression [...] a yield-expression."

  if (FD->isConstexpr())

    DiagInvalid(FD->isConsteval() ? 
DiagConsteval0
 : DiagConstexpr);

  // [dcl.spec.auto]p15: "A function declared with a return type that uses a

  // placeholder type shall not be a coroutine."

  if (FD->getReturnType()->isUndeducedType())

    DiagInvalid(DiagAutoRet);

  // [dcl.fct.def.coroutine]p1

  // The parameter-declaration-clause of the coroutine shall not terminate with

  // an ellipsis that is not part of a parameter-declaration.

  if (FD->isVariadic())

    DiagInvalid(DiagVarargs);

  return !Diagnosed;

}

/// Build a call to 'operator co_await' if there is a suitable operator for

/// the given expression.

ExprResult Sema::BuildOperatorCoawaitCall(SourceLocation Loc, Expr *E,

                                          UnresolvedLookupExpr *Lookup) {

  UnresolvedSet<16> Functions;

  Functions.append(Lookup->decls_begin(), Lookup->decls_end());

  return CreateOverloadedUnaryOp(Loc, UO_Coawait, Functions, E);

}

static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, Scope *S,

                                           SourceLocation Loc, Expr *E) {

  ExprResult R = SemaRef.BuildOperatorCoawaitLookupExpr(S, Loc);

  if (R.isInvalid())

    return ExprError();

  return SemaRef.BuildOperatorCoawaitCall(Loc, E,

                                          cast<UnresolvedLookupExpr>(R.get()));

}

static ExprResult buildCoroutineHandle(Sema &S, QualType PromiseType,

                                       SourceLocation Loc) {

  QualType CoroHandleType = lookupCoroutineHandleType(S, PromiseType, Loc);

  if (CoroHandleType.isNull())

    return ExprError();

  DeclContext *LookupCtx = S.computeDeclContext(CoroHandleType);

  LookupResult Found(S, &S.PP.getIdentifierTable().get("from_address"), Loc,

                     Sema::LookupOrdinaryName);

  if (!S.LookupQualifiedName(Found, LookupCtx)) {

    S.Diag(Loc, diag::err_coroutine_handle_missing_member)

        << "from_address";

    return ExprError();

  }

  Expr *FramePtr =

      S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_frame, {});

  CXXScopeSpec SS;

  ExprResult FromAddr =

      S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);

  if (FromAddr.isInvalid())

    return ExprError();

  return S.BuildCallExpr(nullptr, FromAddr.get(), Loc, FramePtr, Loc);

}

struct ReadySuspendResumeResult {

  enum AwaitCallType { ACT_Ready, ACT_Suspend, ACT_Resume };

  Expr *Results[3];

  OpaqueValueExpr *OpaqueValue;

  bool IsInvalid;

};

static ExprResult buildMemberCall(Sema &S, Expr *Base, SourceLocation Loc,

                                  StringRef Name, MultiExprArg Args) {

  DeclarationNameInfo NameInfo(&S.PP.getIdentifierTable().get(Name), Loc);

  // FIXME: Fix BuildMemberReferenceExpr to take a const CXXScopeSpec&.

  CXXScopeSpec SS;

  ExprResult Result = S.BuildMemberReferenceExpr(

      Base, Base->getType(), Loc, /*IsPtr=*/false, SS,

      SourceLocation(), nullptr, NameInfo, /*TemplateArgs=*/nullptr,

      /*Scope=*/nullptr);

  if (Result.isInvalid())

    return ExprError();

  // We meant exactly what we asked for. No need for typo correction.

  if (auto *TE = dyn_cast<TypoExpr>(Result.get())) {

    S.clearDelayedTypo(TE);

    S.Diag(Loc, diag::err_no_member)

        << NameInfo.getName() << Base->getType()->getAsCXXRecordDecl()

        << Base->getSourceRange();

    return ExprError();

  }

  return S.BuildCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr);

}

// See if return type is coroutine-handle and if so, invoke builtin coro-resume

// on its address. This is to enable experimental support for coroutine-handle

// returning await_suspend that results in a guaranteed tail call to the target

// coroutine.

static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,

                           SourceLocation Loc) {

  if (RetType->isReferenceType())

    return nullptr;

  Type const *T = RetType.getTypePtr();

  if (!T->isClassType() && !T->isStructureType())

    return nullptr;

  // FIXME: Add convertability check to coroutine_handle<>. Possibly via

  // EvaluateBinaryTypeTrait(BTT_IsConvertible, ...) which is at the moment

  // a private function in SemaExprCXX.cpp

  ExprResult AddressExpr = buildMemberCall(S, E, Loc, "address", None);

  if (AddressExpr.isInvalid())

    return nullptr;

  Expr *JustAddress = AddressExpr.get();

  // Check that the type of AddressExpr is void*

  if (!JustAddress->getType().getTypePtr()->isVoidPointerType())

    S.Diag(cast<CallExpr>(JustAddress)->getCalleeDecl()->getLocation(),

           diag::warn_coroutine_handle_address_invalid_return_type)

        << JustAddress->getType();

  // Clean up temporary objects so that they don't live across suspension points

  // unnecessarily. We choose to clean up before the call to

  // __builtin_coro_resume so that the cleanup code are not inserted in-between

  // the resume call and return instruction, which would interfere with the

  // musttail call contract.

  JustAddress = S.MaybeCreateExprWithCleanups(JustAddress);

  return S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_resume,

                                JustAddress);

}

/// Build calls to await_ready, await_suspend, and await_resume for a co_await

/// expression.

/// The generated AST tries to clean up temporary objects as early as

/// possible so that they don't live across suspension points if possible.

/// Having temporary objects living across suspension points unnecessarily can

/// lead to large frame size, and also lead to memory corruptions if the

/// coroutine frame is destroyed after coming back from suspension. This is done

/// by wrapping both the await_ready call and the await_suspend call with

/// ExprWithCleanups. In the end of this function, we also need to explicitly

/// set cleanup state so that the CoawaitExpr is also wrapped with an

/// ExprWithCleanups to clean up the awaiter associated with the co_await

/// expression.

static ReadySuspendResumeResult buildCoawaitCalls(Sema &S, VarDecl *CoroPromise,

                                                  SourceLocation Loc, Expr *E) {

  OpaqueValueExpr *Operand = new (S.Context)

      OpaqueValueExpr(Loc, E->getType(), VK_LValue, E->getObjectKind(), E);

  // Assume valid until we see otherwise.

  // Further operations are responsible for setting IsInalid to true.

  ReadySuspendResumeResult Calls = {{}, Operand, /*IsInvalid=*/false};

  using ACT = ReadySuspendResumeResult::AwaitCallType;

  auto BuildSubExpr = [&](ACT CallType, StringRef Func,

                          MultiExprArg Arg) -> Expr * {

    ExprResult Result = buildMemberCall(S, Operand, Loc, Func, Arg);

    if (Result.isInvalid()) {

      Calls.IsInvalid = true;

      return nullptr;

    }

    Calls.Results[CallType] = Result.get();

    return Result.get();

  };

  CallExpr *AwaitReady =

      cast_or_null<CallExpr>(BuildSubExpr(ACT::ACT_Ready, "await_ready", None));

  if (!AwaitReady)

    return Calls;

  if (!AwaitReady->getType()->isDependentType()) {

    // [expr.await]p3 [...]

    // — await-ready is the expression e.await_ready(), contextually converted

    // to bool.

    ExprResult Conv = S.PerformContextuallyConvertToBool(AwaitReady);

    if (Conv.isInvalid()) {

      S.Diag(AwaitReady->getDirectCallee()->getBeginLoc(),

             diag::note_await_ready_no_bool_conversion);

      S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)

          << AwaitReady->getDirectCallee() << E->getSourceRange();

      Calls.IsInvalid = true;

    } else

      Calls.Results[ACT::ACT_Ready] = S.MaybeCreateExprWithCleanups(Conv.get());

  }

  ExprResult CoroHandleRes =

      buildCoroutineHandle(S, CoroPromise->getType(), Loc);

  if (CoroHandleRes.isInvalid()) {

    Calls.IsInvalid = true;

    return Calls;

  }

  Expr *CoroHandle = CoroHandleRes.get();

  CallExpr *AwaitSuspend = cast_or_null<CallExpr>(

      BuildSubExpr(ACT::ACT_Suspend, "await_suspend", CoroHandle));

  if (!AwaitSuspend)

    return Calls;

  if (!AwaitSuspend->getType()->isDependentType()) {

    // [expr.await]p3 [...]

    //   - await-suspend is the expression e.await_suspend(h), which shall be

    //     a prvalue of type void, bool, or std::coroutine_handle<Z> for some

    //     type Z.

    QualType RetType = AwaitSuspend->getCallReturnType(S.Context);

    // Experimental support for coroutine_handle returning await_suspend.

    if (Expr *TailCallSuspend =

            maybeTailCall(S, RetType, AwaitSuspend, Loc))

      // Note that we don't wrap the expression with ExprWithCleanups here

      // because that might interfere with tailcall contract (e.g. inserting

      // clean up instructions in-between tailcall and return). Instead

      // ExprWithCleanups is wrapped within maybeTailCall() prior to the resume

      // call.

      Calls.Results[ACT::ACT_Suspend] = TailCallSuspend;

    else {

      // non-class prvalues always have cv-unqualified types

      if (RetType->isReferenceType() ||

          
(2.23k
!RetType->isBooleanType()2.23k
 && 
!RetType->isVoidType()2.22k
)) {

        S.Diag(AwaitSuspend->getCalleeDecl()->getLocation(),

               diag::err_await_suspend_invalid_return_type)

            << RetType;

        S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)

            << AwaitSuspend->getDirectCallee();

        Calls.IsInvalid = true;

      } else

        Calls.Results[ACT::ACT_Suspend] =

            S.MaybeCreateExprWithCleanups(AwaitSuspend);

    }

  }

  BuildSubExpr(ACT::ACT_Resume, "await_resume", None);

  // Make sure the awaiter object gets a chance to be cleaned up.

  S.Cleanup.setExprNeedsCleanups(true);

  return Calls;

}

static ExprResult buildPromiseCall(Sema &S, VarDecl *Promise,

                                   SourceLocation Loc, StringRef Name,

                                   MultiExprArg Args) {

  // Form a reference to the promise.

  ExprResult PromiseRef = S.BuildDeclRefExpr(

      Promise, Promise->getType().getNonReferenceType(), VK_LValue, Loc);

  if (PromiseRef.isInvalid())

    return ExprError();

  return buildMemberCall(S, PromiseRef.get(), Loc, Name, Args);

}

VarDecl *Sema::buildCoroutinePromise(SourceLocation Loc) {

  assert(isa<FunctionDecl>(CurContext) && "not in a function scope");

  auto *FD = cast<FunctionDecl>(CurContext);

  bool IsThisDependentType = [&] {

    if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD))

      return MD->isInstance() && 
MD->getThisType()->isDependentType()344
;

    else

      return false;

  }();

  QualType T = FD->getType()->isDependentType() || 
IsThisDependentType991

                   ? 
Context.DependentTy228

                   : 
lookupPromiseType(*this, FD, Loc)929
;

  if (T.isNull())

    return nullptr;

  auto *VD = VarDecl::Create(Context, FD, FD->getLocation(), FD->getLocation(),

                             &PP.getIdentifierTable().get("__promise"), T,

                             Context.getTrivialTypeSourceInfo(T, Loc), SC_None);

  VD->setImplicit();

  CheckVariableDeclarationType(VD);

  if (VD->isInvalidDecl())

    return nullptr;

  auto *ScopeInfo = getCurFunction();

  // Build a list of arguments, based on the coroutine function's arguments,

  // that if present will be passed to the promise type's constructor.

  llvm::SmallVector<Expr *, 4> CtorArgExprs;

  // Add implicit object parameter.

  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {

    if (MD->isInstance() && 
!isLambdaCallOperator(MD)334
) {

      ExprResult ThisExpr = ActOnCXXThis(Loc);

      if (ThisExpr.isInvalid())

        return nullptr;

      ThisExpr = CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get());

      if (ThisExpr.isInvalid())

        return nullptr;

      CtorArgExprs.push_back(ThisExpr.get());

    }

  }

  // Add the coroutine function's parameters.

  auto &Moves = ScopeInfo->CoroutineParameterMoves;

  for (auto *PD : FD->parameters()) {

    if (PD->getType()->isDependentType())

      continue;

    auto RefExpr = ExprEmpty();

    auto Move = Moves.find(PD);

    assert(Move != Moves.end() &&

           "Coroutine function parameter not inserted into move map");

    // If a reference to the function parameter exists in the coroutine

    // frame, use that reference.

    auto *MoveDecl =

        cast<VarDecl>(cast<DeclStmt>(Move->second)->getSingleDecl());

    RefExpr =

        BuildDeclRefExpr(MoveDecl, MoveDecl->getType().getNonReferenceType(),

                         ExprValueKind::VK_LValue, FD->getLocation());

    if (RefExpr.isInvalid())

      return nullptr;

    CtorArgExprs.push_back(RefExpr.get());

  }

  // If we have a non-zero number of constructor arguments, try to use them.

  // Otherwise, fall back to the promise type's default constructor.

  if (!CtorArgExprs.empty()) {

    // Create an initialization sequence for the promise type using the

    // constructor arguments, wrapped in a parenthesized list expression.

    Expr *PLE = ParenListExpr::Create(Context, FD->getLocation(),

                                      CtorArgExprs, FD->getLocation());

    InitializedEntity Entity = InitializedEntity::InitializeVariable(VD);

    InitializationKind Kind = InitializationKind::CreateForInit(

        VD->getLocation(), /*DirectInit=*/true, PLE);

    InitializationSequence InitSeq(*this, Entity, Kind, CtorArgExprs,

                                   /*TopLevelOfInitList=*/false,

                                   /*TreatUnavailableAsInvalid=*/false);

    // [dcl.fct.def.coroutine]5.7

    // promise-constructor-arguments is determined as follows: overload

    // resolution is performed on a promise constructor call created by

    // assembling an argument list  q_1 ... q_n . If a viable constructor is

    // found ([over.match.viable]), then promise-constructor-arguments is ( q_1

    // , ...,  q_n ), otherwise promise-constructor-arguments is empty.

    if (InitSeq) {

      ExprResult Result = InitSeq.Perform(*this, Entity, Kind, CtorArgExprs);

      if (Result.isInvalid()) {

        VD->setInvalidDecl();

      } else if (Result.get()) {

        VD->setInit(MaybeCreateExprWithCleanups(Result.get()));

        VD->setInitStyle(VarDecl::CallInit);

        CheckCompleteVariableDeclaration(VD);

      }

    } else

      ActOnUninitializedDecl(VD);

  } else

    ActOnUninitializedDecl(VD);

  FD->addDecl(VD);

  return VD;

}

/// Check that this is a context in which a coroutine suspension can appear.

static FunctionScopeInfo *checkCoroutineContext(Sema &S, SourceLocation Loc,

                                                StringRef Keyword,

                                                bool IsImplicit = false) {

  if (!isValidCoroutineContext(S, Loc, Keyword))

    return nullptr;

  assert(isa<FunctionDecl>(S.CurContext) && "not in a function scope");

  auto *ScopeInfo = S.getCurFunction();

  assert(ScopeInfo && "missing function scope for function");

  if (ScopeInfo->FirstCoroutineStmtLoc.isInvalid() && 
!IsImplicit1.63k
)

    ScopeInfo->setFirstCoroutineStmt(Loc, Keyword);

  if (ScopeInfo->CoroutinePromise)

    return ScopeInfo;

  if (!S.buildCoroutineParameterMoves(Loc))

    return nullptr;

  ScopeInfo->CoroutinePromise = S.buildCoroutinePromise(Loc);

  if (!ScopeInfo->CoroutinePromise)

    return nullptr;

  return ScopeInfo;

}

/// Recursively check \p E and all its children to see if any call target

/// (including constructor call) is declared noexcept. Also any value returned

/// from the call has a noexcept destructor.

static void checkNoThrow(Sema &S, const Stmt *E,

                         llvm::SmallPtrSetImpl<const Decl *> &ThrowingDecls) {

  auto checkDeclNoexcept = [&](const Decl *D, bool IsDtor = false) {

    // In the case of dtor, the call to dtor is implicit and hence we should

    // pass nullptr to canCalleeThrow.

    if (Sema::canCalleeThrow(S, IsDtor ? 
nullptr16
 : 
cast<Expr>(E)4.09k
, D)) {

      if (const auto *FD = dyn_cast<FunctionDecl>(D)) {

        // co_await promise.final_suspend() could end up calling

        // __builtin_coro_resume for symmetric transfer if await_suspend()

        // returns a handle. In that case, even __builtin_coro_resume is not

        // declared as noexcept and may throw, it does not throw _into_ the

        // coroutine that just suspended, but rather throws back out from

        // whoever called coroutine_handle::resume(), hence we claim that

        // logically it does not throw.

        if (FD->getBuiltinID() == Builtin::BI__builtin_coro_resume)

          return;

      }

      if (ThrowingDecls.empty()) {

        // [dcl.fct.def.coroutine]p15

        //   The expression co_await promise.final_suspend() shall not be

        //   potentially-throwing ([except.spec]).

        //

        // First time seeing an error, emit the error message.

        S.Diag(cast<FunctionDecl>(S.CurContext)->getLocation(),

               diag::err_coroutine_promise_final_suspend_requires_nothrow);

      }

      ThrowingDecls.insert(D);

    }

  };

  if (auto *CE = dyn_cast<CXXConstructExpr>(E)) {

    CXXConstructorDecl *Ctor = CE->getConstructor();

    checkDeclNoexcept(Ctor);

    // Check the corresponding destructor of the constructor.

    checkDeclNoexcept(Ctor->getParent()->getDestructor(), /*IsDtor=*/true);

  } else if (auto *CE = dyn_cast<CallExpr>(E)) {

    if (CE->isTypeDependent())

      return;

    checkDeclNoexcept(CE->getCalleeDecl());

    QualType ReturnType = CE->getCallReturnType(S.getASTContext());

    // Check the destructor of the call return type, if any.

    if (ReturnType.isDestructedType() ==

        QualType::DestructionKind::DK_cxx_destructor) {

      const auto *T =

          cast<RecordType>(ReturnType.getCanonicalType().getTypePtr());

      checkDeclNoexcept(cast<CXXRecordDecl>(T->getDecl())->getDestructor(),

                        /*IsDtor=*/true);

    }

  } else

    
for (const auto *Child : E->children())3.94k
 {

      if (!Child)

        continue;

      checkNoThrow(S, Child, ThrowingDecls);

    }

}

bool Sema::checkFinalSuspendNoThrow(const Stmt *FinalSuspend) {

  llvm::SmallPtrSet<const Decl *, 4> ThrowingDecls;

  // We first collect all declarations that should not throw but not declared

  // with noexcept. We then sort them based on the location before printing.

  // This is to avoid emitting the same note multiple times on the same

  // declaration, and also provide a deterministic order for the messages.

  checkNoThrow(*this, FinalSuspend, ThrowingDecls);

  auto SortedDecls = llvm::SmallVector<const Decl *, 4>{ThrowingDecls.begin(),

                                                        ThrowingDecls.end()};

  sort(SortedDecls, [](const Decl *A, const Decl *B) {

    return A->getEndLoc() < B->getEndLoc();

  });

  for (const auto *D : SortedDecls) {

    Diag(D->getEndLoc(), diag::note_coroutine_function_declare_noexcept);

  }

  return ThrowingDecls.empty();

}

bool Sema::ActOnCoroutineBodyStart(Scope *SC, SourceLocation KWLoc,

                                   StringRef Keyword) {

  if (!checkCoroutineContext(*this, KWLoc, Keyword))

    return false;

  auto *ScopeInfo = getCurFunction();

  assert(ScopeInfo->CoroutinePromise);

  // If we have existing coroutine statements then we have already built

  // the initial and final suspend points.

  if (!ScopeInfo->NeedsCoroutineSuspends)

    return true;

  ScopeInfo->setNeedsCoroutineSuspends(false);

  auto *Fn = cast<FunctionDecl>(CurContext);

  SourceLocation Loc = Fn->getLocation();

  // Build the initial suspend point

  auto buildSuspends = [&](StringRef Name) mutable -> StmtResult {

    ExprResult Operand =

        buildPromiseCall(*this, ScopeInfo->CoroutinePromise, Loc, Name, None);

    if (Operand.isInvalid())

      return StmtError();

    ExprResult Suspend =

        buildOperatorCoawaitCall(*this, SC, Loc, Operand.get());

    if (Suspend.isInvalid())

      return StmtError();

    Suspend = BuildResolvedCoawaitExpr(Loc, Operand.get(), Suspend.get(),

                                       /*IsImplicit*/ true);

    Suspend = ActOnFinishFullExpr(Suspend.get(), /*DiscardedValue*/ false);

    if (Suspend.isInvalid()) {

      Diag(Loc, diag::note_coroutine_promise_suspend_implicitly_required)

          << ((Name == "initial_suspend") ? 
025
 : 
15
);

      Diag(KWLoc, diag::note_declared_coroutine_here) << Keyword;

      return StmtError();

    }

    return cast<Stmt>(Suspend.get());

  };

  StmtResult InitSuspend = buildSuspends("initial_suspend");

  if (InitSuspend.isInvalid())

    return true;

  StmtResult FinalSuspend = buildSuspends("final_suspend");

  if (FinalSuspend.isInvalid() || 
!checkFinalSuspendNoThrow(FinalSuspend.get())806
)

    return true;

  ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());

  return true;

}

// Recursively walks up the scope hierarchy until either a 'catch' or a function

// scope is found, whichever comes first.

static bool isWithinCatchScope(Scope *S) {

  // 'co_await' and 'co_yield' keywords are disallowed within catch blocks, but

  // lambdas that use 'co_await' are allowed. The loop below ends when a

  // function scope is found in order to ensure the following behavior:

  //

  // void foo() {      // <- function scope

  //   try {           //

  //     co_await x;   // <- 'co_await' is OK within a function scope

  //   } catch {       // <- catch scope

  //     co_await x;   // <- 'co_await' is not OK within a catch scope

  //     []() {        // <- function scope

  //       co_await x; // <- 'co_await' is OK within a function scope

  //     }();

  //   }

  // }

  while (S && 
!S->isFunctionScope()807
) {

    if (S->isCatchScope())

      return true;

    S = S->getParent();

  }

  return false;

}

// [expr.await]p2, emphasis added: "An await-expression shall appear only in

// a *potentially evaluated* expression within the compound-statement of a

// function-body *outside of a handler* [...] A context within a function

// where an await-expression can appear is called a suspension context of the

// function."

static void checkSuspensionContext(Sema &S, SourceLocation Loc,

                                   StringRef Keyword) {

  // First emphasis of [expr.await]p2: must be a potentially evaluated context.

  // That is, 'co_await' and 'co_yield' cannot appear in subexpressions of

  // \c sizeof.

  if (S.isUnevaluatedContext())

    S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword;

  // Second emphasis of [expr.await]p2: must be outside of an exception handler.

  if (isWithinCatchScope(S.getCurScope()))

    S.Diag(Loc, diag::err_coroutine_within_handler) << Keyword;

}

ExprResult Sema::ActOnCoawaitExpr(Scope *S, SourceLocation Loc, Expr *E) {

  if (!ActOnCoroutineBodyStart(S, Loc, "co_await")) {

    CorrectDelayedTyposInExpr(E);

    return ExprError();

  }

  checkSuspensionContext(*this, Loc, "co_await");

  if (E->hasPlaceholderType()) {

    ExprResult R = CheckPlaceholderExpr(E);

    if (R.isInvalid()) 
return ExprError()0
;

    E = R.get();

  }

  ExprResult Lookup = BuildOperatorCoawaitLookupExpr(S, Loc);

  if (Lookup.isInvalid())

    return ExprError();

  return BuildUnresolvedCoawaitExpr(Loc, E,

                                   cast<UnresolvedLookupExpr>(Lookup.get()));

}

ExprResult Sema::BuildOperatorCoawaitLookupExpr(Scope *S, SourceLocation Loc) {

  DeclarationName OpName =

      Context.DeclarationNames.getCXXOperatorName(OO_Coawait);

  LookupResult Operators(*this, OpName, SourceLocation(),

                         Sema::LookupOperatorName);

  LookupName(Operators, S);

  assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");

  const auto &Functions = Operators.asUnresolvedSet();

  bool IsOverloaded =

      Functions.size() > 1 ||

      
(2.66k
Functions.size() == 12.66k
 && 
isa<FunctionTemplateDecl>(*Functions.begin())135
);

  Expr *CoawaitOp = UnresolvedLookupExpr::Create(

      Context, /*NamingClass*/ nullptr, NestedNameSpecifierLoc(),

      DeclarationNameInfo(OpName, Loc), /*RequiresADL*/ true, IsOverloaded,

      Functions.begin(), Functions.end());

  assert(CoawaitOp);

  return CoawaitOp;

}

// Attempts to resolve and build a CoawaitExpr from "raw" inputs, bailing out to

// DependentCoawaitExpr if needed.

ExprResult Sema::BuildUnresolvedCoawaitExpr(SourceLocation Loc, Expr *Operand,

                                            UnresolvedLookupExpr *Lookup) {

  auto *FSI = checkCoroutineContext(*this, Loc, "co_await");

  if (!FSI)

    return ExprError();

  if (Operand->hasPlaceholderType()) {

    ExprResult R = CheckPlaceholderExpr(Operand);

    if (R.isInvalid())

      return ExprError();

    Operand = R.get();

  }

  auto *Promise = FSI->CoroutinePromise;

  if (Promise->getType()->isDependentType()) {

    Expr *Res = new (Context)

        DependentCoawaitExpr(Loc, Context.DependentTy, Operand, Lookup);

    return Res;

  }

  auto *RD = Promise->getType()->getAsCXXRecordDecl();

  auto *Transformed = Operand;

  if (lookupMember(*this, "await_transform", RD, Loc)) {

    ExprResult R =

        buildPromiseCall(*this, Promise, Loc, "await_transform", Operand);

    if (R.isInvalid()) {

      Diag(Loc,

           diag::note_coroutine_promise_implicit_await_transform_required_here)

          << Operand->getSourceRange();

      return ExprError();

    }

    Transformed = R.get();

  }

  ExprResult Awaiter = BuildOperatorCoawaitCall(Loc, Transformed, Lookup);

  if (Awaiter.isInvalid())

    return ExprError();

  return BuildResolvedCoawaitExpr(Loc, Operand, Awaiter.get());

}

ExprResult Sema::BuildResolvedCoawaitExpr(SourceLocation Loc, Expr *Operand,

                                          Expr *Awaiter, bool IsImplicit) {

  auto *Coroutine = checkCoroutineContext(*this, Loc, "co_await", IsImplicit);

  if (!Coroutine)

    return ExprError();

  if (Awaiter->hasPlaceholderType()) {

    ExprResult R = CheckPlaceholderExpr(Awaiter);

    if (R.isInvalid()) return ExprError();

    Awaiter = R.get();

  }

  if (Awaiter->getType()->isDependentType()) {

    Expr *Res = new (Context)

        CoawaitExpr(Loc, Context.DependentTy, Operand, Awaiter, IsImplicit);

    return Res;

  }

  // If the expression is a temporary, materialize it as an lvalue so that we

  // can use it multiple times.

  if (Awaiter->isPRValue())

    Awaiter = CreateMaterializeTemporaryExpr(Awaiter->getType(), Awaiter, true);

  // The location of the `co_await` token cannot be used when constructing

  // the member call expressions since it's before the location of `Expr`, which

  // is used as the start of the member call expression.

  SourceLocation CallLoc = Awaiter->getExprLoc();

  // Build the await_ready, await_suspend, await_resume calls.

  ReadySuspendResumeResult RSS =

      buildCoawaitCalls(*this, Coroutine->CoroutinePromise, CallLoc, Awaiter);

  if (RSS.IsInvalid)

    return ExprError();

  Expr *Res = new (Context)

      CoawaitExpr(Loc, Operand, Awaiter, RSS.Results[0], RSS.Results[1],

                  RSS.Results[2], RSS.OpaqueValue, IsImplicit);

  return Res;

}

ExprResult Sema::ActOnCoyieldExpr(Scope *S, SourceLocation Loc, Expr *E) {

  if (!ActOnCoroutineBodyStart(S, Loc, "co_yield")) {

    CorrectDelayedTyposInExpr(E);

    return ExprError();

  }

  checkSuspensionContext(*this, Loc, "co_yield");

  // Build yield_value call.

  ExprResult Awaitable = buildPromiseCall(

      *this, getCurFunction()->CoroutinePromise, Loc, "yield_value", E);

  if (Awaitable.isInvalid())

    return ExprError();

  // Build 'operator co_await' call.

  Awaitable = buildOperatorCoawaitCall(*this, S, Loc, Awaitable.get());

  if (Awaitable.isInvalid())

    return ExprError();

  return BuildCoyieldExpr(Loc, Awaitable.get());

}

ExprResult Sema::BuildCoyieldExpr(SourceLocation Loc, Expr *E) {

  auto *Coroutine = checkCoroutineContext(*this, Loc, "co_yield");

  if (!Coroutine)

    return ExprError();

  if (E->hasPlaceholderType()) {

    ExprResult R = CheckPlaceholderExpr(E);

    if (R.isInvalid()) return ExprError();

    E = R.get();

  }

  Expr *Operand = E;

  if (E->getType()->isDependentType()) {

    Expr *Res = new (Context) CoyieldExpr(Loc, Context.DependentTy, Operand, E);

    return Res;

  }

  // If the expression is a temporary, materialize it as an lvalue so that we

  // can use it multiple times.

  if (E->isPRValue())

    E = CreateMaterializeTemporaryExpr(E->getType(), E, true);

  // Build the await_ready, await_suspend, await_resume calls.

  ReadySuspendResumeResult RSS = buildCoawaitCalls(

      *this, Coroutine->CoroutinePromise, Loc, E);

  if (RSS.IsInvalid)

    return ExprError();

  Expr *Res =

      new (Context) CoyieldExpr(Loc, Operand, E, RSS.Results[0], RSS.Results[1],

                                RSS.Results[2], RSS.OpaqueValue);

  return Res;

}

StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc, Expr *E) {

  if (!ActOnCoroutineBodyStart(S, Loc, "co_return")) {

    CorrectDelayedTyposInExpr(E);

    return StmtError();

  }

  return BuildCoreturnStmt(Loc, E);

}

StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E,

                                   bool IsImplicit) {

  auto *FSI = checkCoroutineContext(*this, Loc, "co_return", IsImplicit);

  if (!FSI)

    return StmtError();

  if (E && 
E->hasPlaceholderType()136
 &&

      
!E->hasPlaceholderType(BuiltinType::Overload)10
) {

    ExprResult R = CheckPlaceholderExpr(E);

    if (R.isInvalid()) return StmtError();

    E = R.get();

  }

  VarDecl *Promise = FSI->CoroutinePromise;

  ExprResult PC;

  if (E && 
(136
isa<InitListExpr>(E)136
 || 
!E->getType()->isVoidType()124
)) {

    getNamedReturnInfo(E, SimplerImplicitMoveMode::ForceOn);

    PC = buildPromiseCall(*this, Promise, Loc, "return_value", E);

  } else {

    E = MakeFullDiscardedValueExpr(E).get();

    PC = buildPromiseCall(*this, Promise, Loc, "return_void", None);

  }

  if (PC.isInvalid())

    return StmtError();

  Expr *PCE = ActOnFinishFullExpr(PC.get(), /*DiscardedValue*/ false).get();

  Stmt *Res = new (Context) CoreturnStmt(Loc, E, PCE, IsImplicit);

  return Res;

}

/// Look up the std::nothrow object.

static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) {

  NamespaceDecl *Std = S.getStdNamespace();

  assert(Std && "Should already be diagnosed");

  LookupResult Result(S, &S.PP.getIdentifierTable().get("nothrow"), Loc,

                      Sema::LookupOrdinaryName);

  if (!S.LookupQualifiedName(Result, Std)) {

    // <coroutine> is not requred to include <new>, so we couldn't omit

    // the check here.

    S.Diag(Loc, diag::err_implicit_coroutine_std_nothrow_type_not_found);

    return nullptr;

  }

  auto *VD = Result.getAsSingle<VarDecl>();

  if (!VD) {

    Result.suppressDiagnostics();

    // We found something weird. Complain about the first thing we found.

    NamedDecl *Found = *Result.begin();

    S.Diag(Found->getLocation(), diag::err_malformed_std_nothrow);

    return nullptr;

  }