contrib/llvm/tools/clang/lib/Sema/SemaCoroutine.cpp

   1 //===--- SemaCoroutines.cpp - Semantic Analysis for Coroutines ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements semantic analysis for C++ Coroutines.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CoroutineStmtBuilder.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/AST/ExprCXX.h"
  17 #include "clang/AST/StmtCXX.h"
  18 #include "clang/Lex/Preprocessor.h"
  19 #include "clang/Sema/Initialization.h"
  20 #include "clang/Sema/Overload.h"
  21 #include "clang/Sema/SemaInternal.h"
  22
  23 using namespace clang;
  24 using namespace sema;
  25
  26 static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
  27                                  SourceLocation Loc, bool &Res) {
  28   DeclarationName DN = S.PP.getIdentifierInfo(Name);
  29   LookupResult LR(S, DN, Loc, Sema::LookupMemberName);
  30   // Suppress diagnostics when a private member is selected. The same warnings
  31   // will be produced again when building the call.
  32   LR.suppressDiagnostics();
  33   Res = S.LookupQualifiedName(LR, RD);
  34   return LR;
  35 }
  36
  37 static bool lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
  38                          SourceLocation Loc) {
  39   bool Res;
  40   lookupMember(S, Name, RD, Loc, Res);
  41   return Res;
  42 }
  43
  44 /// Look up the std::coroutine_traits<...>::promise_type for the given
  45 /// function type.
  46 static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD,
  47                                   SourceLocation KwLoc) {
  48   const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>();
  49   const SourceLocation FuncLoc = FD->getLocation();
  50   // FIXME: Cache std::coroutine_traits once we've found it.
  51   NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
  52   if (!StdExp) {
  53     S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
  54         << "std::experimental::coroutine_traits";
  55     return QualType();
  56   }
  57
  58   LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_traits"),
  59                       FuncLoc, Sema::LookupOrdinaryName);
  60   if (!S.LookupQualifiedName(Result, StdExp)) {
  61     S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
  62         << "std::experimental::coroutine_traits";
  63     return QualType();
  64   }
  65
  66   ClassTemplateDecl *CoroTraits = Result.getAsSingle<ClassTemplateDecl>();
  67   if (!CoroTraits) {
  68     Result.suppressDiagnostics();
  69     // We found something weird. Complain about the first thing we found.
  70     NamedDecl *Found = *Result.begin();
  71     S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits);
  72     return QualType();
  73   }
  74
  75   // Form template argument list for coroutine_traits<R, P1, P2, ...> according
  76   // to [dcl.fct.def.coroutine]3
  77   TemplateArgumentListInfo Args(KwLoc, KwLoc);
  78   auto AddArg = [&](QualType T) {
  79     Args.addArgument(TemplateArgumentLoc(
  80         TemplateArgument(T), S.Context.getTrivialTypeSourceInfo(T, KwLoc)));
  81   };
  82   AddArg(FnType->getReturnType());
  83   // If the function is a non-static member function, add the type
  84   // of the implicit object parameter before the formal parameters.
  85   if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
  86     if (MD->isInstance()) {
  87       // [over.match.funcs]4
  88       // For non-static member functions, the type of the implicit object
  89       // parameter is
  90       //  -- "lvalue reference to cv X" for functions declared without a
  91       //      ref-qualifier or with the & ref-qualifier
  92       //  -- "rvalue reference to cv X" for functions declared with the &&
  93       //      ref-qualifier
  94       QualType T =
  95           MD->getThisType(S.Context)->getAs<PointerType>()->getPointeeType();
  96       T = FnType->getRefQualifier() == RQ_RValue
  97               ? S.Context.getRValueReferenceType(T)
  98               : S.Context.getLValueReferenceType(T, /*SpelledAsLValue*/ true);
  99       AddArg(T);
 100     }
 101   }
 102   for (QualType T : FnType->getParamTypes())
 103     AddArg(T);
 104
 105   // Build the template-id.
 106   QualType CoroTrait =
 107       S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args);
 108   if (CoroTrait.isNull())
 109     return QualType();
 110   if (S.RequireCompleteType(KwLoc, CoroTrait,
 111                             diag::err_coroutine_type_missing_specialization))
 112     return QualType();
 113
 114   auto *RD = CoroTrait->getAsCXXRecordDecl();
 115   assert(RD && "specialization of class template is not a class?");
 116
 117   // Look up the ::promise_type member.
 118   LookupResult R(S, &S.PP.getIdentifierTable().get("promise_type"), KwLoc,
 119                  Sema::LookupOrdinaryName);
 120   S.LookupQualifiedName(R, RD);
 121   auto *Promise = R.getAsSingle<TypeDecl>();
 122   if (!Promise) {
 123     S.Diag(FuncLoc,
 124            diag::err_implied_std_coroutine_traits_promise_type_not_found)
 125         << RD;
 126     return QualType();
 127   }
 128   // The promise type is required to be a class type.
 129   QualType PromiseType = S.Context.getTypeDeclType(Promise);
 130
 131   auto buildElaboratedType = [&]() {
 132     auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, StdExp);
 133     NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
 134                                       CoroTrait.getTypePtr());
 135     return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);
 136   };
 137
 138   if (!PromiseType->getAsCXXRecordDecl()) {
 139     S.Diag(FuncLoc,
 140            diag::err_implied_std_coroutine_traits_promise_type_not_class)
 141         << buildElaboratedType();
 142     return QualType();
 143   }
 144   if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),
 145                             diag::err_coroutine_promise_type_incomplete))
 146     return QualType();
 147
 148   return PromiseType;
 149 }
 150
 151 /// Look up the std::experimental::coroutine_handle<PromiseType>.
 152 static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,
 153                                           SourceLocation Loc) {
 154   if (PromiseType.isNull())
 155     return QualType();
 156
 157   NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
 158   assert(StdExp && "Should already be diagnosed");
 159
 160   LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"),
 161                       Loc, Sema::LookupOrdinaryName);
 162   if (!S.LookupQualifiedName(Result, StdExp)) {
 163     S.Diag(Loc, diag::err_implied_coroutine_type_not_found)
 164         << "std::experimental::coroutine_handle";
 165     return QualType();
 166   }
 167
 168   ClassTemplateDecl *CoroHandle = Result.getAsSingle<ClassTemplateDecl>();
 169   if (!CoroHandle) {
 170     Result.suppressDiagnostics();
 171     // We found something weird. Complain about the first thing we found.
 172     NamedDecl *Found = *Result.begin();
 173     S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_handle);
 174     return QualType();
 175   }
 176
 177   // Form template argument list for coroutine_handle<Promise>.
 178   TemplateArgumentListInfo Args(Loc, Loc);
 179   Args.addArgument(TemplateArgumentLoc(
 180       TemplateArgument(PromiseType),
 181       S.Context.getTrivialTypeSourceInfo(PromiseType, Loc)));
 182
 183   // Build the template-id.
 184   QualType CoroHandleType =
 185       S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args);
 186   if (CoroHandleType.isNull())
 187     return QualType();
 188   if (S.RequireCompleteType(Loc, CoroHandleType,
 189                             diag::err_coroutine_type_missing_specialization))
 190     return QualType();
 191
 192   return CoroHandleType;
 193 }
 194
 195 static bool isValidCoroutineContext(Sema &S, SourceLocation Loc,
 196                                     StringRef Keyword) {
 197   // 'co_await' and 'co_yield' are not permitted in unevaluated operands.
 198   if (S.isUnevaluatedContext()) {
 199     S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword;
 200     return false;
 201   }
 202
 203   // Any other usage must be within a function.
 204   auto *FD = dyn_cast<FunctionDecl>(S.CurContext);
 205   if (!FD) {
 206     S.Diag(Loc, isa<ObjCMethodDecl>(S.CurContext)
 207                     ? diag::err_coroutine_objc_method
 208                     : diag::err_coroutine_outside_function) << Keyword;
 209     return false;
 210   }
 211
 212   // An enumeration for mapping the diagnostic type to the correct diagnostic
 213   // selection index.
 214   enum InvalidFuncDiag {
 215     DiagCtor = 0,
 216     DiagDtor,
 217     DiagCopyAssign,
 218     DiagMoveAssign,
 219     DiagMain,
 220     DiagConstexpr,
 221     DiagAutoRet,
 222     DiagVarargs,
 223   };
 224   bool Diagnosed = false;
 225   auto DiagInvalid = [&](InvalidFuncDiag ID) {
 226     S.Diag(Loc, diag::err_coroutine_invalid_func_context) << ID << Keyword;
 227     Diagnosed = true;
 228     return false;
 229   };
 230
 231   // Diagnose when a constructor, destructor, copy/move assignment operator,
 232   // or the function 'main' are declared as a coroutine.
 233   auto *MD = dyn_cast<CXXMethodDecl>(FD);
 234   if (MD && isa<CXXConstructorDecl>(MD))
 235     return DiagInvalid(DiagCtor);
 236   else if (MD && isa<CXXDestructorDecl>(MD))
 237     return DiagInvalid(DiagDtor);
 238   else if (MD && MD->isCopyAssignmentOperator())
 239     return DiagInvalid(DiagCopyAssign);
 240   else if (MD && MD->isMoveAssignmentOperator())
 241     return DiagInvalid(DiagMoveAssign);
 242   else if (FD->isMain())
 243     return DiagInvalid(DiagMain);
 244
 245   // Emit a diagnostics for each of the following conditions which is not met.
 246   if (FD->isConstexpr())
 247     DiagInvalid(DiagConstexpr);
 248   if (FD->getReturnType()->isUndeducedType())
 249     DiagInvalid(DiagAutoRet);
 250   if (FD->isVariadic())
 251     DiagInvalid(DiagVarargs);
 252
 253   return !Diagnosed;
 254 }
 255
 256 static ExprResult buildOperatorCoawaitLookupExpr(Sema &SemaRef, Scope *S,
 257                                                  SourceLocation Loc) {
 258   DeclarationName OpName =
 259       SemaRef.Context.DeclarationNames.getCXXOperatorName(OO_Coawait);
 260   LookupResult Operators(SemaRef, OpName, SourceLocation(),
 261                          Sema::LookupOperatorName);
 262   SemaRef.LookupName(Operators, S);
 263
 264   assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");
 265   const auto &Functions = Operators.asUnresolvedSet();
 266   bool IsOverloaded =
 267       Functions.size() > 1 ||
 268       (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
 269   Expr *CoawaitOp = UnresolvedLookupExpr::Create(
 270       SemaRef.Context, /*NamingClass*/ nullptr, NestedNameSpecifierLoc(),
 271       DeclarationNameInfo(OpName, Loc), /*RequiresADL*/ true, IsOverloaded,
 272       Functions.begin(), Functions.end());
 273   assert(CoawaitOp);
 274   return CoawaitOp;
 275 }
 276
 277 /// Build a call to 'operator co_await' if there is a suitable operator for
 278 /// the given expression.
 279 static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, SourceLocation Loc,
 280                                            Expr *E,
 281                                            UnresolvedLookupExpr *Lookup) {
 282   UnresolvedSet<16> Functions;
 283   Functions.append(Lookup->decls_begin(), Lookup->decls_end());
 284   return SemaRef.CreateOverloadedUnaryOp(Loc, UO_Coawait, Functions, E);
 285 }
 286
 287 static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, Scope *S,
 288                                            SourceLocation Loc, Expr *E) {
 289   ExprResult R = buildOperatorCoawaitLookupExpr(SemaRef, S, Loc);
 290   if (R.isInvalid())
 291     return ExprError();
 292   return buildOperatorCoawaitCall(SemaRef, Loc, E,
 293                                   cast<UnresolvedLookupExpr>(R.get()));
 294 }
 295
 296 static Expr *buildBuiltinCall(Sema &S, SourceLocation Loc, Builtin::ID Id,
 297                               MultiExprArg CallArgs) {
 298   StringRef Name = S.Context.BuiltinInfo.getName(Id);
 299   LookupResult R(S, &S.Context.Idents.get(Name), Loc, Sema::LookupOrdinaryName);
 300   S.LookupName(R, S.TUScope, /*AllowBuiltinCreation=*/true);
 301
 302   auto *BuiltInDecl = R.getAsSingle<FunctionDecl>();
 303   assert(BuiltInDecl && "failed to find builtin declaration");
 304
 305   ExprResult DeclRef =
 306       S.BuildDeclRefExpr(BuiltInDecl, BuiltInDecl->getType(), VK_LValue, Loc);
 307   assert(DeclRef.isUsable() && "Builtin reference cannot fail");
 308
 309   ExprResult Call =
 310       S.ActOnCallExpr(/*Scope=*/nullptr, DeclRef.get(), Loc, CallArgs, Loc);
 311
 312   assert(!Call.isInvalid() && "Call to builtin cannot fail!");
 313   return Call.get();
 314 }
 315
 316 static ExprResult buildCoroutineHandle(Sema &S, QualType PromiseType,
 317                                        SourceLocation Loc) {
 318   QualType CoroHandleType = lookupCoroutineHandleType(S, PromiseType, Loc);
 319   if (CoroHandleType.isNull())
 320     return ExprError();
 321
 322   DeclContext *LookupCtx = S.computeDeclContext(CoroHandleType);
 323   LookupResult Found(S, &S.PP.getIdentifierTable().get("from_address"), Loc,
 324                      Sema::LookupOrdinaryName);
 325   if (!S.LookupQualifiedName(Found, LookupCtx)) {
 326     S.Diag(Loc, diag::err_coroutine_handle_missing_member)
 327         << "from_address";
 328     return ExprError();
 329   }
 330
 331   Expr *FramePtr =
 332       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
 333
 334   CXXScopeSpec SS;
 335   ExprResult FromAddr =
 336       S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);
 337   if (FromAddr.isInvalid())
 338     return ExprError();
 339
 340   return S.ActOnCallExpr(nullptr, FromAddr.get(), Loc, FramePtr, Loc);
 341 }
 342
 343 struct ReadySuspendResumeResult {
 344   enum AwaitCallType { ACT_Ready, ACT_Suspend, ACT_Resume };
 345   Expr *Results[3];
 346   OpaqueValueExpr *OpaqueValue;
 347   bool IsInvalid;
 348 };
 349
 350 static ExprResult buildMemberCall(Sema &S, Expr *Base, SourceLocation Loc,
 351                                   StringRef Name, MultiExprArg Args) {
 352   DeclarationNameInfo NameInfo(&S.PP.getIdentifierTable().get(Name), Loc);
 353
 354   // FIXME: Fix BuildMemberReferenceExpr to take a const CXXScopeSpec&.
 355   CXXScopeSpec SS;
 356   ExprResult Result = S.BuildMemberReferenceExpr(
 357       Base, Base->getType(), Loc, /*IsPtr=*/false, SS,
 358       SourceLocation(), nullptr, NameInfo, /*TemplateArgs=*/nullptr,
 359       /*Scope=*/nullptr);
 360   if (Result.isInvalid())
 361     return ExprError();
 362
 363   return S.ActOnCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr);
 364 }
 365
 366 // See if return type is coroutine-handle and if so, invoke builtin coro-resume
 367 // on its address. This is to enable experimental support for coroutine-handle
 368 // returning await_suspend that results in a guranteed tail call to the target
 369 // coroutine.
 370 static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
 371                            SourceLocation Loc) {
 372   if (RetType->isReferenceType())
 373     return nullptr;
 374   Type const *T = RetType.getTypePtr();
 375   if (!T->isClassType() && !T->isStructureType())
 376     return nullptr;
 377
 378   // FIXME: Add convertability check to coroutine_handle<>. Possibly via
 379   // EvaluateBinaryTypeTrait(BTT_IsConvertible, ...) which is at the moment
 380   // a private function in SemaExprCXX.cpp
 381
 382   ExprResult AddressExpr = buildMemberCall(S, E, Loc, "address", None);
 383   if (AddressExpr.isInvalid())
 384     return nullptr;
 385
 386   Expr *JustAddress = AddressExpr.get();
 387   // FIXME: Check that the type of AddressExpr is void*
 388   return buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_resume,
 389                           JustAddress);
 390 }
 391
 392 /// Build calls to await_ready, await_suspend, and await_resume for a co_await
 393 /// expression.
 394 static ReadySuspendResumeResult buildCoawaitCalls(Sema &S, VarDecl *CoroPromise,
 395                                                   SourceLocation Loc, Expr *E) {
 396   OpaqueValueExpr *Operand = new (S.Context)
 397       OpaqueValueExpr(Loc, E->getType(), VK_LValue, E->getObjectKind(), E);
 398
 399   // Assume invalid until we see otherwise.
 400   ReadySuspendResumeResult Calls = {{}, Operand, /*IsInvalid=*/true};
 401
 402   ExprResult CoroHandleRes = buildCoroutineHandle(S, CoroPromise->getType(), Loc);
 403   if (CoroHandleRes.isInvalid())
 404     return Calls;
 405   Expr *CoroHandle = CoroHandleRes.get();
 406
 407   const StringRef Funcs[] = {"await_ready", "await_suspend", "await_resume"};
 408   MultiExprArg Args[] = {None, CoroHandle, None};
 409   for (size_t I = 0, N = llvm::array_lengthof(Funcs); I != N; ++I) {
 410     ExprResult Result = buildMemberCall(S, Operand, Loc, Funcs[I], Args[I]);
 411     if (Result.isInvalid())
 412       return Calls;
 413     Calls.Results[I] = Result.get();
 414   }
 415
 416   // Assume the calls are valid; all further checking should make them invalid.
 417   Calls.IsInvalid = false;
 418
 419   using ACT = ReadySuspendResumeResult::AwaitCallType;
 420   CallExpr *AwaitReady = cast<CallExpr>(Calls.Results[ACT::ACT_Ready]);
 421   if (!AwaitReady->getType()->isDependentType()) {
 422     // [expr.await]p3 [...]
 423     // — await-ready is the expression e.await_ready(), contextually converted
 424     // to bool.
 425     ExprResult Conv = S.PerformContextuallyConvertToBool(AwaitReady);
 426     if (Conv.isInvalid()) {
 427       S.Diag(AwaitReady->getDirectCallee()->getLocStart(),
 428              diag::note_await_ready_no_bool_conversion);
 429       S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
 430           << AwaitReady->getDirectCallee() << E->getSourceRange();
 431       Calls.IsInvalid = true;
 432     }
 433     Calls.Results[ACT::ACT_Ready] = Conv.get();
 434   }
 435   CallExpr *AwaitSuspend = cast<CallExpr>(Calls.Results[ACT::ACT_Suspend]);
 436   if (!AwaitSuspend->getType()->isDependentType()) {
 437     // [expr.await]p3 [...]
 438     //   - await-suspend is the expression e.await_suspend(h), which shall be
 439     //     a prvalue of type void or bool.
 440     QualType RetType = AwaitSuspend->getCallReturnType(S.Context);
 441
 442     // Experimental support for coroutine_handle returning await_suspend.
 443     if (Expr *TailCallSuspend = maybeTailCall(S, RetType, AwaitSuspend, Loc))
 444       Calls.Results[ACT::ACT_Suspend] = TailCallSuspend;
 445     else {
 446       // non-class prvalues always have cv-unqualified types
 447       if (RetType->isReferenceType() ||
 448           (!RetType->isBooleanType() && !RetType->isVoidType())) {
 449         S.Diag(AwaitSuspend->getCalleeDecl()->getLocation(),
 450                diag::err_await_suspend_invalid_return_type)
 451             << RetType;
 452         S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
 453             << AwaitSuspend->getDirectCallee();
 454         Calls.IsInvalid = true;
 455       }
 456     }
 457   }
 458
 459   return Calls;
 460 }
 461
 462 static ExprResult buildPromiseCall(Sema &S, VarDecl *Promise,
 463                                    SourceLocation Loc, StringRef Name,
 464                                    MultiExprArg Args) {
 465
 466   // Form a reference to the promise.
 467   ExprResult PromiseRef = S.BuildDeclRefExpr(
 468       Promise, Promise->getType().getNonReferenceType(), VK_LValue, Loc);
 469   if (PromiseRef.isInvalid())
 470     return ExprError();
 471
 472   return buildMemberCall(S, PromiseRef.get(), Loc, Name, Args);
 473 }
 474
 475 VarDecl *Sema::buildCoroutinePromise(SourceLocation Loc) {
 476   assert(isa<FunctionDecl>(CurContext) && "not in a function scope");
 477   auto *FD = cast<FunctionDecl>(CurContext);
 478   bool IsThisDependentType = [&] {
 479     if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD))
 480       return MD->isInstance() && MD->getThisType(Context)->isDependentType();
 481     else
 482       return false;
 483   }();
 484
 485   QualType T = FD->getType()->isDependentType() || IsThisDependentType
 486                    ? Context.DependentTy
 487                    : lookupPromiseType(*this, FD, Loc);
 488   if (T.isNull())
 489     return nullptr;
 490
 491   auto *VD = VarDecl::Create(Context, FD, FD->getLocation(), FD->getLocation(),
 492                              &PP.getIdentifierTable().get("__promise"), T,
 493                              Context.getTrivialTypeSourceInfo(T, Loc), SC_None);
 494   CheckVariableDeclarationType(VD);
 495   if (VD->isInvalidDecl())
 496     return nullptr;
 497   ActOnUninitializedDecl(VD);
 498   FD->addDecl(VD);
 499   assert(!VD->isInvalidDecl());
 500   return VD;
 501 }
 502
 503 /// Check that this is a context in which a coroutine suspension can appear.
 504 static FunctionScopeInfo *checkCoroutineContext(Sema &S, SourceLocation Loc,
 505                                                 StringRef Keyword,
 506                                                 bool IsImplicit = false) {
 507   if (!isValidCoroutineContext(S, Loc, Keyword))
 508     return nullptr;
 509
 510   assert(isa<FunctionDecl>(S.CurContext) && "not in a function scope");
 511
 512   auto *ScopeInfo = S.getCurFunction();
 513   assert(ScopeInfo && "missing function scope for function");
 514
 515   if (ScopeInfo->FirstCoroutineStmtLoc.isInvalid() && !IsImplicit)
 516     ScopeInfo->setFirstCoroutineStmt(Loc, Keyword);
 517
 518   if (ScopeInfo->CoroutinePromise)
 519     return ScopeInfo;
 520
 521   ScopeInfo->CoroutinePromise = S.buildCoroutinePromise(Loc);
 522   if (!ScopeInfo->CoroutinePromise)
 523     return nullptr;
 524
 525   return ScopeInfo;
 526 }
 527
 528 bool Sema::ActOnCoroutineBodyStart(Scope *SC, SourceLocation KWLoc,
 529                                    StringRef Keyword) {
 530   if (!checkCoroutineContext(*this, KWLoc, Keyword))
 531     return false;
 532   auto *ScopeInfo = getCurFunction();
 533   assert(ScopeInfo->CoroutinePromise);
 534
 535   // If we have existing coroutine statements then we have already built
 536   // the initial and final suspend points.
 537   if (!ScopeInfo->NeedsCoroutineSuspends)
 538     return true;
 539
 540   ScopeInfo->setNeedsCoroutineSuspends(false);
 541
 542   auto *Fn = cast<FunctionDecl>(CurContext);
 543   SourceLocation Loc = Fn->getLocation();
 544   // Build the initial suspend point
 545   auto buildSuspends = [&](StringRef Name) mutable -> StmtResult {
 546     ExprResult Suspend =
 547         buildPromiseCall(*this, ScopeInfo->CoroutinePromise, Loc, Name, None);
 548     if (Suspend.isInvalid())
 549       return StmtError();
 550     Suspend = buildOperatorCoawaitCall(*this, SC, Loc, Suspend.get());
 551     if (Suspend.isInvalid())
 552       return StmtError();
 553     Suspend = BuildResolvedCoawaitExpr(Loc, Suspend.get(),
 554                                        /*IsImplicit*/ true);
 555     Suspend = ActOnFinishFullExpr(Suspend.get());
 556     if (Suspend.isInvalid()) {
 557       Diag(Loc, diag::note_coroutine_promise_suspend_implicitly_required)
 558           << ((Name == "initial_suspend") ? 0 : 1);
 559       Diag(KWLoc, diag::note_declared_coroutine_here) << Keyword;
 560       return StmtError();
 561     }
 562     return cast<Stmt>(Suspend.get());
 563   };
 564
 565   StmtResult InitSuspend = buildSuspends("initial_suspend");
 566   if (InitSuspend.isInvalid())
 567     return true;
 568
 569   StmtResult FinalSuspend = buildSuspends("final_suspend");
 570   if (FinalSuspend.isInvalid())
 571     return true;
 572
 573   ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
 574
 575   return true;
 576 }
 577
 578 ExprResult Sema::ActOnCoawaitExpr(Scope *S, SourceLocation Loc, Expr *E) {
 579   if (!ActOnCoroutineBodyStart(S, Loc, "co_await")) {
 580     CorrectDelayedTyposInExpr(E);
 581     return ExprError();
 582   }
 583
 584   if (E->getType()->isPlaceholderType()) {
 585     ExprResult R = CheckPlaceholderExpr(E);
 586     if (R.isInvalid()) return ExprError();
 587     E = R.get();
 588   }
 589   ExprResult Lookup = buildOperatorCoawaitLookupExpr(*this, S, Loc);
 590   if (Lookup.isInvalid())
 591     return ExprError();
 592   return BuildUnresolvedCoawaitExpr(Loc, E,
 593                                    cast<UnresolvedLookupExpr>(Lookup.get()));
 594 }
 595
 596 ExprResult Sema::BuildUnresolvedCoawaitExpr(SourceLocation Loc, Expr *E,
 597                                             UnresolvedLookupExpr *Lookup) {
 598   auto *FSI = checkCoroutineContext(*this, Loc, "co_await");
 599   if (!FSI)
 600     return ExprError();
 601
 602   if (E->getType()->isPlaceholderType()) {
 603     ExprResult R = CheckPlaceholderExpr(E);
 604     if (R.isInvalid())
 605       return ExprError();
 606     E = R.get();
 607   }
 608
 609   auto *Promise = FSI->CoroutinePromise;
 610   if (Promise->getType()->isDependentType()) {
 611     Expr *Res =
 612         new (Context) DependentCoawaitExpr(Loc, Context.DependentTy, E, Lookup);
 613     return Res;
 614   }
 615
 616   auto *RD = Promise->getType()->getAsCXXRecordDecl();
 617   if (lookupMember(*this, "await_transform", RD, Loc)) {
 618     ExprResult R = buildPromiseCall(*this, Promise, Loc, "await_transform", E);
 619     if (R.isInvalid()) {
 620       Diag(Loc,
 621            diag::note_coroutine_promise_implicit_await_transform_required_here)
 622           << E->getSourceRange();
 623       return ExprError();
 624     }
 625     E = R.get();
 626   }
 627   ExprResult Awaitable = buildOperatorCoawaitCall(*this, Loc, E, Lookup);
 628   if (Awaitable.isInvalid())
 629     return ExprError();
 630
 631   return BuildResolvedCoawaitExpr(Loc, Awaitable.get());
 632 }
 633
 634 ExprResult Sema::BuildResolvedCoawaitExpr(SourceLocation Loc, Expr *E,
 635                                   bool IsImplicit) {
 636   auto *Coroutine = checkCoroutineContext(*this, Loc, "co_await", IsImplicit);
 637   if (!Coroutine)
 638     return ExprError();
 639
 640   if (E->getType()->isPlaceholderType()) {
 641     ExprResult R = CheckPlaceholderExpr(E);
 642     if (R.isInvalid()) return ExprError();
 643     E = R.get();
 644   }
 645
 646   if (E->getType()->isDependentType()) {
 647     Expr *Res = new (Context)
 648         CoawaitExpr(Loc, Context.DependentTy, E, IsImplicit);
 649     return Res;
 650   }
 651
 652   // If the expression is a temporary, materialize it as an lvalue so that we
 653   // can use it multiple times.
 654   if (E->getValueKind() == VK_RValue)
 655     E = CreateMaterializeTemporaryExpr(E->getType(), E, true);
 656
 657   // Build the await_ready, await_suspend, await_resume calls.
 658   ReadySuspendResumeResult RSS =
 659       buildCoawaitCalls(*this, Coroutine->CoroutinePromise, Loc, E);
 660   if (RSS.IsInvalid)
 661     return ExprError();
 662
 663   Expr *Res =
 664       new (Context) CoawaitExpr(Loc, E, RSS.Results[0], RSS.Results[1],
 665                                 RSS.Results[2], RSS.OpaqueValue, IsImplicit);
 666
 667   return Res;
 668 }
 669
 670 ExprResult Sema::ActOnCoyieldExpr(Scope *S, SourceLocation Loc, Expr *E) {
 671   if (!ActOnCoroutineBodyStart(S, Loc, "co_yield")) {
 672     CorrectDelayedTyposInExpr(E);
 673     return ExprError();
 674   }
 675
 676   // Build yield_value call.
 677   ExprResult Awaitable = buildPromiseCall(
 678       *this, getCurFunction()->CoroutinePromise, Loc, "yield_value", E);
 679   if (Awaitable.isInvalid())
 680     return ExprError();
 681
 682   // Build 'operator co_await' call.
 683   Awaitable = buildOperatorCoawaitCall(*this, S, Loc, Awaitable.get());
 684   if (Awaitable.isInvalid())
 685     return ExprError();
 686
 687   return BuildCoyieldExpr(Loc, Awaitable.get());
 688 }
 689 ExprResult Sema::BuildCoyieldExpr(SourceLocation Loc, Expr *E) {
 690   auto *Coroutine = checkCoroutineContext(*this, Loc, "co_yield");
 691   if (!Coroutine)
 692     return ExprError();
 693
 694   if (E->getType()->isPlaceholderType()) {
 695     ExprResult R = CheckPlaceholderExpr(E);
 696     if (R.isInvalid()) return ExprError();
 697     E = R.get();
 698   }
 699
 700   if (E->getType()->isDependentType()) {
 701     Expr *Res = new (Context) CoyieldExpr(Loc, Context.DependentTy, E);
 702     return Res;
 703   }
 704
 705   // If the expression is a temporary, materialize it as an lvalue so that we
 706   // can use it multiple times.
 707   if (E->getValueKind() == VK_RValue)
 708     E = CreateMaterializeTemporaryExpr(E->getType(), E, true);
 709
 710   // Build the await_ready, await_suspend, await_resume calls.
 711   ReadySuspendResumeResult RSS =
 712       buildCoawaitCalls(*this, Coroutine->CoroutinePromise, Loc, E);
 713   if (RSS.IsInvalid)
 714     return ExprError();
 715
 716   Expr *Res =
 717       new (Context) CoyieldExpr(Loc, E, RSS.Results[0], RSS.Results[1],
 718                                 RSS.Results[2], RSS.OpaqueValue);
 719
 720   return Res;
 721 }
 722
 723 StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc, Expr *E) {
 724   if (!ActOnCoroutineBodyStart(S, Loc, "co_return")) {
 725     CorrectDelayedTyposInExpr(E);
 726     return StmtError();
 727   }
 728   return BuildCoreturnStmt(Loc, E);
 729 }
 730
 731 StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E,
 732                                    bool IsImplicit) {
 733   auto *FSI = checkCoroutineContext(*this, Loc, "co_return", IsImplicit);
 734   if (!FSI)
 735     return StmtError();
 736
 737   if (E && E->getType()->isPlaceholderType() &&
 738       !E->getType()->isSpecificPlaceholderType(BuiltinType::Overload)) {
 739     ExprResult R = CheckPlaceholderExpr(E);
 740     if (R.isInvalid()) return StmtError();
 741     E = R.get();
 742   }
 743
 744   // FIXME: If the operand is a reference to a variable that's about to go out
 745   // of scope, we should treat the operand as an xvalue for this overload
 746   // resolution.
 747   VarDecl *Promise = FSI->CoroutinePromise;
 748   ExprResult PC;
 749   if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) {
 750     PC = buildPromiseCall(*this, Promise, Loc, "return_value", E);
 751   } else {
 752     E = MakeFullDiscardedValueExpr(E).get();
 753     PC = buildPromiseCall(*this, Promise, Loc, "return_void", None);
 754   }
 755   if (PC.isInvalid())
 756     return StmtError();
 757
 758   Expr *PCE = ActOnFinishFullExpr(PC.get()).get();
 759
 760   Stmt *Res = new (Context) CoreturnStmt(Loc, E, PCE, IsImplicit);
 761   return Res;
 762 }
 763
 764 /// Look up the std::nothrow object.
 765 static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) {
 766   NamespaceDecl *Std = S.getStdNamespace();
 767   assert(Std && "Should already be diagnosed");
 768
 769   LookupResult Result(S, &S.PP.getIdentifierTable().get("nothrow"), Loc,
 770                       Sema::LookupOrdinaryName);
 771   if (!S.LookupQualifiedName(Result, Std)) {
 772     // FIXME: <experimental/coroutine> should have been included already.
 773     // If we require it to include <new> then this diagnostic is no longer
 774     // needed.
 775     S.Diag(Loc, diag::err_implicit_coroutine_std_nothrow_type_not_found);
 776     return nullptr;
 777   }
 778
 779   auto *VD = Result.getAsSingle<VarDecl>();
 780   if (!VD) {
 781     Result.suppressDiagnostics();
 782     // We found something weird. Complain about the first thing we found.
 783     NamedDecl *Found = *Result.begin();
 784     S.Diag(Found->getLocation(), diag::err_malformed_std_nothrow);
 785     return nullptr;
 786   }
 787
 788   ExprResult DR = S.BuildDeclRefExpr(VD, VD->getType(), VK_LValue, Loc);
 789   if (DR.isInvalid())
 790     return nullptr;
 791
 792   return DR.get();
 793 }
 794
 795 // Find an appropriate delete for the promise.
 796 static FunctionDecl *findDeleteForPromise(Sema &S, SourceLocation Loc,
 797                                           QualType PromiseType) {
 798   FunctionDecl *OperatorDelete = nullptr;
 799
 800   DeclarationName DeleteName =
 801       S.Context.DeclarationNames.getCXXOperatorName(OO_Delete);
 802
 803   auto *PointeeRD = PromiseType->getAsCXXRecordDecl();
 804   assert(PointeeRD && "PromiseType must be a CxxRecordDecl type");
 805
 806   if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete))
 807     return nullptr;
 808
 809   if (!OperatorDelete) {
 810     // Look for a global declaration.
 811     const bool CanProvideSize = S.isCompleteType(Loc, PromiseType);
 812     const bool Overaligned = false;
 813     OperatorDelete = S.FindUsualDeallocationFunction(Loc, CanProvideSize,
 814                                                      Overaligned, DeleteName);
 815   }
 816   S.MarkFunctionReferenced(Loc, OperatorDelete);
 817   return OperatorDelete;
 818 }
 819
 820
 821 void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {
 822   FunctionScopeInfo *Fn = getCurFunction();
 823   assert(Fn && Fn->isCoroutine() && "not a coroutine");
 824   if (!Body) {
 825     assert(FD->isInvalidDecl() &&
 826            "a null body is only allowed for invalid declarations");
 827     return;
 828   }
 829   // We have a function that uses coroutine keywords, but we failed to build
 830   // the promise type.
 831   if (!Fn->CoroutinePromise)
 832     return FD->setInvalidDecl();
 833
 834   if (isa<CoroutineBodyStmt>(Body)) {
 835     // Nothing todo. the body is already a transformed coroutine body statement.
 836     return;
 837   }
 838
 839   // Coroutines [stmt.return]p1:
 840   //   A return statement shall not appear in a coroutine.
 841   if (Fn->FirstReturnLoc.isValid()) {
 842     assert(Fn->FirstCoroutineStmtLoc.isValid() &&
 843                    "first coroutine location not set");
 844     Diag(Fn->FirstReturnLoc, diag::err_return_in_coroutine);
 845     Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
 846             << Fn->getFirstCoroutineStmtKeyword();
 847   }
 848   CoroutineStmtBuilder Builder(*this, *FD, *Fn, Body);
 849   if (Builder.isInvalid() || !Builder.buildStatements())
 850     return FD->setInvalidDecl();
 851
 852   // Build body for the coroutine wrapper statement.
 853   Body = CoroutineBodyStmt::Create(Context, Builder);
 854 }
 855
 856 CoroutineStmtBuilder::CoroutineStmtBuilder(Sema &S, FunctionDecl &FD,
 857                                            sema::FunctionScopeInfo &Fn,
 858                                            Stmt *Body)
 859     : S(S), FD(FD), Fn(Fn), Loc(FD.getLocation()),
 860       IsPromiseDependentType(
 861           !Fn.CoroutinePromise ||
 862           Fn.CoroutinePromise->getType()->isDependentType()) {
 863   this->Body = Body;
 864   if (!IsPromiseDependentType) {
 865     PromiseRecordDecl = Fn.CoroutinePromise->getType()->getAsCXXRecordDecl();
 866     assert(PromiseRecordDecl && "Type should have already been checked");
 867   }
 868   this->IsValid = makePromiseStmt() && makeInitialAndFinalSuspend();
 869 }
 870
 871 bool CoroutineStmtBuilder::buildStatements() {
 872   assert(this->IsValid && "coroutine already invalid");
 873   this->IsValid = makeReturnObject() && makeParamMoves();
 874   if (this->IsValid && !IsPromiseDependentType)
 875     buildDependentStatements();
 876   return this->IsValid;
 877 }
 878
 879 bool CoroutineStmtBuilder::buildDependentStatements() {
 880   assert(this->IsValid && "coroutine already invalid");
 881   assert(!this->IsPromiseDependentType &&
 882          "coroutine cannot have a dependent promise type");
 883   this->IsValid = makeOnException() && makeOnFallthrough() &&
 884                   makeGroDeclAndReturnStmt() && makeReturnOnAllocFailure() &&
 885                   makeNewAndDeleteExpr();
 886   return this->IsValid;
 887 }
 888
 889 bool CoroutineStmtBuilder::buildParameterMoves() {
 890   assert(this->IsValid && "coroutine already invalid");
 891   assert(this->ParamMoves.empty() && "param moves already built");
 892   return this->IsValid = makeParamMoves();
 893 }
 894
 895 bool CoroutineStmtBuilder::makePromiseStmt() {
 896   // Form a declaration statement for the promise declaration, so that AST
 897   // visitors can more easily find it.
 898   StmtResult PromiseStmt =
 899       S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(Fn.CoroutinePromise), Loc, Loc);
 900   if (PromiseStmt.isInvalid())
 901     return false;
 902
 903   this->Promise = PromiseStmt.get();
 904   return true;
 905 }
 906
 907 bool CoroutineStmtBuilder::makeInitialAndFinalSuspend() {
 908   if (Fn.hasInvalidCoroutineSuspends())
 909     return false;
 910   this->InitialSuspend = cast<Expr>(Fn.CoroutineSuspends.first);
 911   this->FinalSuspend = cast<Expr>(Fn.CoroutineSuspends.second);
 912   return true;
 913 }
 914
 915 static bool diagReturnOnAllocFailure(Sema &S, Expr *E,
 916                                      CXXRecordDecl *PromiseRecordDecl,
 917                                      FunctionScopeInfo &Fn) {
 918   auto Loc = E->getExprLoc();
 919   if (auto *DeclRef = dyn_cast_or_null<DeclRefExpr>(E)) {
 920     auto *Decl = DeclRef->getDecl();
 921     if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(Decl)) {
 922       if (Method->isStatic())
 923         return true;
 924       else
 925         Loc = Decl->getLocation();
 926     }
 927   }
 928
 929   S.Diag(
 930       Loc,
 931       diag::err_coroutine_promise_get_return_object_on_allocation_failure)
 932       << PromiseRecordDecl;
 933   S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
 934       << Fn.getFirstCoroutineStmtKeyword();
 935   return false;
 936 }
 937
 938 bool CoroutineStmtBuilder::makeReturnOnAllocFailure() {
 939   assert(!IsPromiseDependentType &&
 940          "cannot make statement while the promise type is dependent");
 941
 942   // [dcl.fct.def.coroutine]/8
 943   // The unqualified-id get_return_object_on_allocation_failure is looked up in
 944   // the scope of class P by class member access lookup (3.4.5). ...
 945   // If an allocation function returns nullptr, ... the coroutine return value
 946   // is obtained by a call to ... get_return_object_on_allocation_failure().
 947
 948   DeclarationName DN =
 949       S.PP.getIdentifierInfo("get_return_object_on_allocation_failure");
 950   LookupResult Found(S, DN, Loc, Sema::LookupMemberName);
 951   if (!S.LookupQualifiedName(Found, PromiseRecordDecl))
 952     return true;
 953
 954   CXXScopeSpec SS;
 955   ExprResult DeclNameExpr =
 956       S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);
 957   if (DeclNameExpr.isInvalid())
 958     return false;
 959
 960   if (!diagReturnOnAllocFailure(S, DeclNameExpr.get(), PromiseRecordDecl, Fn))
 961     return false;
 962
 963   ExprResult ReturnObjectOnAllocationFailure =
 964       S.ActOnCallExpr(nullptr, DeclNameExpr.get(), Loc, {}, Loc);
 965   if (ReturnObjectOnAllocationFailure.isInvalid())
 966     return false;
 967
 968   StmtResult ReturnStmt =
 969       S.BuildReturnStmt(Loc, ReturnObjectOnAllocationFailure.get());
 970   if (ReturnStmt.isInvalid()) {
 971     S.Diag(Found.getFoundDecl()->getLocation(), diag::note_member_declared_here)
 972         << DN;
 973     S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
 974         << Fn.getFirstCoroutineStmtKeyword();
 975     return false;
 976   }
 977
 978   this->ReturnStmtOnAllocFailure = ReturnStmt.get();
 979   return true;
 980 }
 981
 982 bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
 983   // Form and check allocation and deallocation calls.
 984   assert(!IsPromiseDependentType &&
 985          "cannot make statement while the promise type is dependent");
 986   QualType PromiseType = Fn.CoroutinePromise->getType();
 987
 988   if (S.RequireCompleteType(Loc, PromiseType, diag::err_incomplete_type))
 989     return false;
 990
 991   const bool RequiresNoThrowAlloc = ReturnStmtOnAllocFailure != nullptr;
 992
 993   // FIXME: Add support for stateful allocators.
 994
 995   FunctionDecl *OperatorNew = nullptr;
 996   FunctionDecl *OperatorDelete = nullptr;
 997   FunctionDecl *UnusedResult = nullptr;
 998   bool PassAlignment = false;
 999   SmallVector<Expr *, 1> PlacementArgs;
1000
1001   S.FindAllocationFunctions(Loc, SourceRange(),
1002                             /*UseGlobal*/ false, PromiseType,
1003                             /*isArray*/ false, PassAlignment, PlacementArgs,
1004                             OperatorNew, UnusedResult);
1005
1006   bool IsGlobalOverload =
1007       OperatorNew && !isa<CXXRecordDecl>(OperatorNew->getDeclContext());
1008   // If we didn't find a class-local new declaration and non-throwing new
1009   // was is required then we need to lookup the non-throwing global operator
1010   // instead.
1011   if (RequiresNoThrowAlloc && (!OperatorNew || IsGlobalOverload)) {
1012     auto *StdNoThrow = buildStdNoThrowDeclRef(S, Loc);
1013     if (!StdNoThrow)
1014       return false;
1015     PlacementArgs = {StdNoThrow};
1016     OperatorNew = nullptr;
1017     S.FindAllocationFunctions(Loc, SourceRange(),
1018                               /*UseGlobal*/ true, PromiseType,
1019                               /*isArray*/ false, PassAlignment, PlacementArgs,
1020                               OperatorNew, UnusedResult);
1021   }
1022
1023   assert(OperatorNew && "expected definition of operator new to be found");
1024
1025   if (RequiresNoThrowAlloc) {
1026     const auto *FT = OperatorNew->getType()->getAs<FunctionProtoType>();
1027     if (!FT->isNothrow(S.Context, /*ResultIfDependent*/ false)) {
1028       S.Diag(OperatorNew->getLocation(),
1029              diag::err_coroutine_promise_new_requires_nothrow)
1030           << OperatorNew;
1031       S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
1032           << OperatorNew;
1033       return false;
1034     }
1035   }
1036
1037   if ((OperatorDelete = findDeleteForPromise(S, Loc, PromiseType)) == nullptr)
1038     return false;
1039
1040   Expr *FramePtr =
1041       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
1042
1043   Expr *FrameSize =
1044       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_size, {});
1045
1046   // Make new call.
1047
1048   ExprResult NewRef =
1049       S.BuildDeclRefExpr(OperatorNew, OperatorNew->getType(), VK_LValue, Loc);
1050   if (NewRef.isInvalid())
1051     return false;
1052
1053   SmallVector<Expr *, 2> NewArgs(1, FrameSize);
1054   for (auto Arg : PlacementArgs)
1055     NewArgs.push_back(Arg);
1056
1057   ExprResult NewExpr =
1058       S.ActOnCallExpr(S.getCurScope(), NewRef.get(), Loc, NewArgs, Loc);
1059   NewExpr = S.ActOnFinishFullExpr(NewExpr.get());
1060   if (NewExpr.isInvalid())
1061     return false;
1062
1063   // Make delete call.
1064
1065   QualType OpDeleteQualType = OperatorDelete->getType();
1066
1067   ExprResult DeleteRef =
1068       S.BuildDeclRefExpr(OperatorDelete, OpDeleteQualType, VK_LValue, Loc);
1069   if (DeleteRef.isInvalid())
1070     return false;
1071
1072   Expr *CoroFree =
1073       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_free, {FramePtr});
1074
1075   SmallVector<Expr *, 2> DeleteArgs{CoroFree};
1076
1077   // Check if we need to pass the size.
1078   const auto *OpDeleteType =
1079       OpDeleteQualType.getTypePtr()->getAs<FunctionProtoType>();
1080   if (OpDeleteType->getNumParams() > 1)
1081     DeleteArgs.push_back(FrameSize);
1082
1083   ExprResult DeleteExpr =
1084       S.ActOnCallExpr(S.getCurScope(), DeleteRef.get(), Loc, DeleteArgs, Loc);
1085   DeleteExpr = S.ActOnFinishFullExpr(DeleteExpr.get());
1086   if (DeleteExpr.isInvalid())
1087     return false;
1088
1089   this->Allocate = NewExpr.get();
1090   this->Deallocate = DeleteExpr.get();
1091
1092   return true;
1093 }
1094
1095 bool CoroutineStmtBuilder::makeOnFallthrough() {
1096   assert(!IsPromiseDependentType &&
1097          "cannot make statement while the promise type is dependent");
1098
1099   // [dcl.fct.def.coroutine]/4
1100   // The unqualified-ids 'return_void' and 'return_value' are looked up in
1101   // the scope of class P. If both are found, the program is ill-formed.
1102   bool HasRVoid, HasRValue;
1103   LookupResult LRVoid =
1104       lookupMember(S, "return_void", PromiseRecordDecl, Loc, HasRVoid);
1105   LookupResult LRValue =
1106       lookupMember(S, "return_value", PromiseRecordDecl, Loc, HasRValue);
1107
1108   StmtResult Fallthrough;
1109   if (HasRVoid && HasRValue) {
1110     // FIXME Improve this diagnostic
1111     S.Diag(FD.getLocation(),
1112            diag::err_coroutine_promise_incompatible_return_functions)
1113         << PromiseRecordDecl;
1114     S.Diag(LRVoid.getRepresentativeDecl()->getLocation(),
1115            diag::note_member_first_declared_here)
1116         << LRVoid.getLookupName();
1117     S.Diag(LRValue.getRepresentativeDecl()->getLocation(),
1118            diag::note_member_first_declared_here)
1119         << LRValue.getLookupName();
1120     return false;
1121   } else if (!HasRVoid && !HasRValue) {
1122     // FIXME: The PDTS currently specifies this case as UB, not ill-formed.
1123     // However we still diagnose this as an error since until the PDTS is fixed.
1124     S.Diag(FD.getLocation(),
1125            diag::err_coroutine_promise_requires_return_function)
1126         << PromiseRecordDecl;
1127     S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here)
1128         << PromiseRecordDecl;
1129     return false;
1130   } else if (HasRVoid) {
1131     // If the unqualified-id return_void is found, flowing off the end of a
1132     // coroutine is equivalent to a co_return with no operand. Otherwise,
1133     // flowing off the end of a coroutine results in undefined behavior.
1134     Fallthrough = S.BuildCoreturnStmt(FD.getLocation(), nullptr,
1135                                       /*IsImplicit*/false);
1136     Fallthrough = S.ActOnFinishFullStmt(Fallthrough.get());
1137     if (Fallthrough.isInvalid())
1138       return false;
1139   }
1140
1141   this->OnFallthrough = Fallthrough.get();
1142   return true;
1143 }
1144
1145 bool CoroutineStmtBuilder::makeOnException() {
1146   // Try to form 'p.unhandled_exception();'
1147   assert(!IsPromiseDependentType &&
1148          "cannot make statement while the promise type is dependent");
1149
1150   const bool RequireUnhandledException = S.getLangOpts().CXXExceptions;
1151
1152   if (!lookupMember(S, "unhandled_exception", PromiseRecordDecl, Loc)) {
1153     auto DiagID =
1154         RequireUnhandledException
1155             ? diag::err_coroutine_promise_unhandled_exception_required
1156             : diag::
1157                   warn_coroutine_promise_unhandled_exception_required_with_exceptions;
1158     S.Diag(Loc, DiagID) << PromiseRecordDecl;
1159     S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here)
1160         << PromiseRecordDecl;
1161     return !RequireUnhandledException;
1162   }
1163
1164   // If exceptions are disabled, don't try to build OnException.
1165   if (!S.getLangOpts().CXXExceptions)
1166     return true;
1167
1168   ExprResult UnhandledException = buildPromiseCall(S, Fn.CoroutinePromise, Loc,
1169                                                    "unhandled_exception", None);
1170   UnhandledException = S.ActOnFinishFullExpr(UnhandledException.get(), Loc);
1171   if (UnhandledException.isInvalid())
1172     return false;
1173
1174   // Since the body of the coroutine will be wrapped in try-catch, it will
1175   // be incompatible with SEH __try if present in a function.
1176   if (!S.getLangOpts().Borland && Fn.FirstSEHTryLoc.isValid()) {
1177     S.Diag(Fn.FirstSEHTryLoc, diag::err_seh_in_a_coroutine_with_cxx_exceptions);
1178     S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
1179         << Fn.getFirstCoroutineStmtKeyword();
1180     return false;
1181   }
1182
1183   this->OnException = UnhandledException.get();
1184   return true;
1185 }
1186
1187 bool CoroutineStmtBuilder::makeReturnObject() {
1188   // Build implicit 'p.get_return_object()' expression and form initialization
1189   // of return type from it.
1190   ExprResult ReturnObject =
1191       buildPromiseCall(S, Fn.CoroutinePromise, Loc, "get_return_object", None);
1192   if (ReturnObject.isInvalid())
1193     return false;
1194
1195   this->ReturnValue = ReturnObject.get();
1196   return true;
1197 }
1198
1199 static void noteMemberDeclaredHere(Sema &S, Expr *E, FunctionScopeInfo &Fn) {
1200   if (auto *MbrRef = dyn_cast<CXXMemberCallExpr>(E)) {
1201     auto *MethodDecl = MbrRef->getMethodDecl();
1202     S.Diag(MethodDecl->getLocation(), diag::note_member_declared_here)
1203         << MethodDecl;
1204   }
1205   S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
1206       << Fn.getFirstCoroutineStmtKeyword();
1207 }
1208
1209 bool CoroutineStmtBuilder::makeGroDeclAndReturnStmt() {
1210   assert(!IsPromiseDependentType &&
1211          "cannot make statement while the promise type is dependent");
1212   assert(this->ReturnValue && "ReturnValue must be already formed");
1213
1214   QualType const GroType = this->ReturnValue->getType();
1215   assert(!GroType->isDependentType() &&
1216          "get_return_object type must no longer be dependent");
1217
1218   QualType const FnRetType = FD.getReturnType();
1219   assert(!FnRetType->isDependentType() &&
1220          "get_return_object type must no longer be dependent");
1221
1222   if (FnRetType->isVoidType()) {
1223     ExprResult Res = S.ActOnFinishFullExpr(this->ReturnValue, Loc);
1224     if (Res.isInvalid())
1225       return false;
1226
1227     this->ResultDecl = Res.get();
1228     return true;
1229   }
1230
1231   if (GroType->isVoidType()) {
1232     // Trigger a nice error message.
1233     InitializedEntity Entity =
1234         InitializedEntity::InitializeResult(Loc, FnRetType, false);
1235     S.PerformMoveOrCopyInitialization(Entity, nullptr, FnRetType, ReturnValue);
1236     noteMemberDeclaredHere(S, ReturnValue, Fn);
1237     return false;
1238   }
1239
1240   auto *GroDecl = VarDecl::Create(
1241       S.Context, &FD, FD.getLocation(), FD.getLocation(),
1242       &S.PP.getIdentifierTable().get("__coro_gro"), GroType,
1243       S.Context.getTrivialTypeSourceInfo(GroType, Loc), SC_None);
1244
1245   S.CheckVariableDeclarationType(GroDecl);
1246   if (GroDecl->isInvalidDecl())
1247     return false;
1248
1249   InitializedEntity Entity = InitializedEntity::InitializeVariable(GroDecl);
1250   ExprResult Res = S.PerformMoveOrCopyInitialization(Entity, nullptr, GroType,
1251                                                      this->ReturnValue);
1252   if (Res.isInvalid())
1253     return false;
1254
1255   Res = S.ActOnFinishFullExpr(Res.get());
1256   if (Res.isInvalid())
1257     return false;
1258
1259   if (GroType == FnRetType) {
1260     GroDecl->setNRVOVariable(true);
1261   }
1262
1263   S.AddInitializerToDecl(GroDecl, Res.get(),
1264                          /*DirectInit=*/false);
1265
1266   S.FinalizeDeclaration(GroDecl);
1267
1268   // Form a declaration statement for the return declaration, so that AST
1269   // visitors can more easily find it.
1270   StmtResult GroDeclStmt =
1271       S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(GroDecl), Loc, Loc);
1272   if (GroDeclStmt.isInvalid())
1273     return false;
1274
1275   this->ResultDecl = GroDeclStmt.get();
1276
1277   ExprResult declRef = S.BuildDeclRefExpr(GroDecl, GroType, VK_LValue, Loc);
1278   if (declRef.isInvalid())
1279     return false;
1280
1281   StmtResult ReturnStmt = S.BuildReturnStmt(Loc, declRef.get());
1282   if (ReturnStmt.isInvalid()) {
1283     noteMemberDeclaredHere(S, ReturnValue, Fn);
1284     return false;
1285   }
1286
1287   this->ReturnStmt = ReturnStmt.get();
1288   return true;
1289 }
1290
1291 // Create a static_cast\<T&&>(expr).
1292 static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) {
1293   if (T.isNull())
1294     T = E->getType();
1295   QualType TargetType = S.BuildReferenceType(
1296       T, /*SpelledAsLValue*/ false, SourceLocation(), DeclarationName());
1297   SourceLocation ExprLoc = E->getLocStart();
1298   TypeSourceInfo *TargetLoc =
1299       S.Context.getTrivialTypeSourceInfo(TargetType, ExprLoc);
1300
1301   return S
1302       .BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
1303                          SourceRange(ExprLoc, ExprLoc), E->getSourceRange())
1304       .get();
1305 }
1306
1307
1308 /// \brief Build a variable declaration for move parameter.
1309 static VarDecl *buildVarDecl(Sema &S, SourceLocation Loc, QualType Type,
1310                              IdentifierInfo *II) {
1311   TypeSourceInfo *TInfo = S.Context.getTrivialTypeSourceInfo(Type, Loc);
1312   VarDecl *Decl =
1313       VarDecl::Create(S.Context, S.CurContext, Loc, Loc, II, Type, TInfo, SC_None);
1314   Decl->setImplicit();
1315   return Decl;
1316 }
1317
1318 bool CoroutineStmtBuilder::makeParamMoves() {
1319   for (auto *paramDecl : FD.parameters()) {
1320     auto Ty = paramDecl->getType();
1321     if (Ty->isDependentType())
1322       continue;
1323
1324     // No need to copy scalars, llvm will take care of them.
1325     if (Ty->getAsCXXRecordDecl()) {
1326       ExprResult ParamRef =
1327           S.BuildDeclRefExpr(paramDecl, paramDecl->getType(),
1328                              ExprValueKind::VK_LValue, Loc); // FIXME: scope?
1329       if (ParamRef.isInvalid())
1330         return false;
1331
1332       Expr *RCast = castForMoving(S, ParamRef.get());
1333
1334       auto D = buildVarDecl(S, Loc, Ty, paramDecl->getIdentifier());
1335       S.AddInitializerToDecl(D, RCast, /*DirectInit=*/true);
1336
1337       // Convert decl to a statement.
1338       StmtResult Stmt = S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(D), Loc, Loc);
1339       if (Stmt.isInvalid())
1340         return false;
1341
1342       ParamMovesVector.push_back(Stmt.get());
1343     }
1344   }
1345
1346   // Convert to ArrayRef in CtorArgs structure that builder inherits from.
1347   ParamMoves = ParamMovesVector;
1348   return true;
1349 }
1350
1351 StmtResult Sema::BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
1352   CoroutineBodyStmt *Res = CoroutineBodyStmt::Create(Context, Args);
1353   if (!Res)
1354     return StmtError();
1355   return Res;
1356 }