clang  7.0.0svn
SemaCoroutine.cpp
Go to the documentation of this file.
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 // This file contains references to sections of the Coroutines TS, which
13 // can be found at http://wg21.link/coroutines.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "CoroutineStmtBuilder.h"
18 #include "clang/AST/ASTLambda.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/StmtCXX.h"
22 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Sema/Overload.h"
25 #include "clang/Sema/ScopeInfo.h"
27 
28 using namespace clang;
29 using namespace sema;
30 
31 static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
32  SourceLocation Loc, bool &Res) {
34  LookupResult LR(S, DN, Loc, Sema::LookupMemberName);
35  // Suppress diagnostics when a private member is selected. The same warnings
36  // will be produced again when building the call.
38  Res = S.LookupQualifiedName(LR, RD);
39  return LR;
40 }
41 
42 static bool lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
43  SourceLocation Loc) {
44  bool Res;
45  lookupMember(S, Name, RD, Loc, Res);
46  return Res;
47 }
48 
49 /// Look up the std::coroutine_traits<...>::promise_type for the given
50 /// function type.
52  SourceLocation KwLoc) {
53  const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>();
54  const SourceLocation FuncLoc = FD->getLocation();
55  // FIXME: Cache std::coroutine_traits once we've found it.
57  if (!StdExp) {
58  S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
59  << "std::experimental::coroutine_traits";
60  return QualType();
61  }
62 
63  LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_traits"),
64  FuncLoc, Sema::LookupOrdinaryName);
65  if (!S.LookupQualifiedName(Result, StdExp)) {
66  S.Diag(KwLoc, diag::err_implied_coroutine_type_not_found)
67  << "std::experimental::coroutine_traits";
68  return QualType();
69  }
70 
71  ClassTemplateDecl *CoroTraits = Result.getAsSingle<ClassTemplateDecl>();
72  if (!CoroTraits) {
73  Result.suppressDiagnostics();
74  // We found something weird. Complain about the first thing we found.
75  NamedDecl *Found = *Result.begin();
76  S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits);
77  return QualType();
78  }
79 
80  // Form template argument list for coroutine_traits<R, P1, P2, ...> according
81  // to [dcl.fct.def.coroutine]3
82  TemplateArgumentListInfo Args(KwLoc, KwLoc);
83  auto AddArg = [&](QualType T) {
86  };
87  AddArg(FnType->getReturnType());
88  // If the function is a non-static member function, add the type
89  // of the implicit object parameter before the formal parameters.
90  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
91  if (MD->isInstance()) {
92  // [over.match.funcs]4
93  // For non-static member functions, the type of the implicit object
94  // parameter is
95  // -- "lvalue reference to cv X" for functions declared without a
96  // ref-qualifier or with the & ref-qualifier
97  // -- "rvalue reference to cv X" for functions declared with the &&
98  // ref-qualifier
99  QualType T =
100  MD->getThisType(S.Context)->getAs<PointerType>()->getPointeeType();
101  T = FnType->getRefQualifier() == RQ_RValue
103  : S.Context.getLValueReferenceType(T, /*SpelledAsLValue*/ true);
104  AddArg(T);
105  }
106  }
107  for (QualType T : FnType->getParamTypes())
108  AddArg(T);
109 
110  // Build the template-id.
111  QualType CoroTrait =
112  S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args);
113  if (CoroTrait.isNull())
114  return QualType();
115  if (S.RequireCompleteType(KwLoc, CoroTrait,
116  diag::err_coroutine_type_missing_specialization))
117  return QualType();
118 
119  auto *RD = CoroTrait->getAsCXXRecordDecl();
120  assert(RD && "specialization of class template is not a class?");
121 
122  // Look up the ::promise_type member.
123  LookupResult R(S, &S.PP.getIdentifierTable().get("promise_type"), KwLoc,
125  S.LookupQualifiedName(R, RD);
126  auto *Promise = R.getAsSingle<TypeDecl>();
127  if (!Promise) {
128  S.Diag(FuncLoc,
129  diag::err_implied_std_coroutine_traits_promise_type_not_found)
130  << RD;
131  return QualType();
132  }
133  // The promise type is required to be a class type.
134  QualType PromiseType = S.Context.getTypeDeclType(Promise);
135 
136  auto buildElaboratedType = [&]() {
137  auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, StdExp);
138  NNS = NestedNameSpecifier::Create(S.Context, NNS, false,
139  CoroTrait.getTypePtr());
140  return S.Context.getElaboratedType(ETK_None, NNS, PromiseType);
141  };
142 
143  if (!PromiseType->getAsCXXRecordDecl()) {
144  S.Diag(FuncLoc,
145  diag::err_implied_std_coroutine_traits_promise_type_not_class)
146  << buildElaboratedType();
147  return QualType();
148  }
149  if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),
150  diag::err_coroutine_promise_type_incomplete))
151  return QualType();
152 
153  return PromiseType;
154 }
155 
156 /// Look up the std::experimental::coroutine_handle<PromiseType>.
158  SourceLocation Loc) {
159  if (PromiseType.isNull())
160  return QualType();
161 
163  assert(StdExp && "Should already be diagnosed");
164 
165  LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"),
167  if (!S.LookupQualifiedName(Result, StdExp)) {
168  S.Diag(Loc, diag::err_implied_coroutine_type_not_found)
169  << "std::experimental::coroutine_handle";
170  return QualType();
171  }
172 
173  ClassTemplateDecl *CoroHandle = Result.getAsSingle<ClassTemplateDecl>();
174  if (!CoroHandle) {
175  Result.suppressDiagnostics();
176  // We found something weird. Complain about the first thing we found.
177  NamedDecl *Found = *Result.begin();
178  S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_handle);
179  return QualType();
180  }
181 
182  // Form template argument list for coroutine_handle<Promise>.
183  TemplateArgumentListInfo Args(Loc, Loc);
185  TemplateArgument(PromiseType),
186  S.Context.getTrivialTypeSourceInfo(PromiseType, Loc)));
187 
188  // Build the template-id.
189  QualType CoroHandleType =
190  S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args);
191  if (CoroHandleType.isNull())
192  return QualType();
193  if (S.RequireCompleteType(Loc, CoroHandleType,
194  diag::err_coroutine_type_missing_specialization))
195  return QualType();
196 
197  return CoroHandleType;
198 }
199 
201  StringRef Keyword) {
202  // 'co_await' and 'co_yield' are not permitted in unevaluated operands,
203  // such as subexpressions of \c sizeof.
204  //
205  // [expr.await]p2, emphasis added: "An await-expression shall appear only in
206  // a *potentially evaluated* expression within the compound-statement of a
207  // function-body outside of a handler [...] A context within a function where
208  // an await-expression can appear is called a suspension context of the
209  // function." And per [expr.yield]p1: "A yield-expression shall appear only
210  // within a suspension context of a function."
211  if (S.isUnevaluatedContext()) {
212  S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword;
213  return false;
214  }
215 
216  // Per [expr.await]p2, any other usage must be within a function.
217  // FIXME: This also covers [expr.await]p2: "An await-expression shall not
218  // appear in a default argument." But the diagnostic QoI here could be
219  // improved to inform the user that default arguments specifically are not
220  // allowed.
221  auto *FD = dyn_cast<FunctionDecl>(S.CurContext);
222  if (!FD) {
223  S.Diag(Loc, isa<ObjCMethodDecl>(S.CurContext)
224  ? diag::err_coroutine_objc_method
225  : diag::err_coroutine_outside_function) << Keyword;
226  return false;
227  }
228 
229  // An enumeration for mapping the diagnostic type to the correct diagnostic
230  // selection index.
231  enum InvalidFuncDiag {
232  DiagCtor = 0,
233  DiagDtor,
234  DiagCopyAssign,
235  DiagMoveAssign,
236  DiagMain,
237  DiagConstexpr,
238  DiagAutoRet,
239  DiagVarargs,
240  };
241  bool Diagnosed = false;
242  auto DiagInvalid = [&](InvalidFuncDiag ID) {
243  S.Diag(Loc, diag::err_coroutine_invalid_func_context) << ID << Keyword;
244  Diagnosed = true;
245  return false;
246  };
247 
248  // Diagnose when a constructor, destructor, copy/move assignment operator,
249  // or the function 'main' are declared as a coroutine.
250  auto *MD = dyn_cast<CXXMethodDecl>(FD);
251  // [class.ctor]p6: "A constructor shall not be a coroutine."
252  if (MD && isa<CXXConstructorDecl>(MD))
253  return DiagInvalid(DiagCtor);
254  // [class.dtor]p17: "A destructor shall not be a coroutine."
255  else if (MD && isa<CXXDestructorDecl>(MD))
256  return DiagInvalid(DiagDtor);
257  // N4499 [special]p6: "A special member function shall not be a coroutine."
258  // Per C++ [special]p1, special member functions are the "default constructor,
259  // copy constructor and copy assignment operator, move constructor and move
260  // assignment operator, and destructor."
261  else if (MD && MD->isCopyAssignmentOperator())
262  return DiagInvalid(DiagCopyAssign);
263  else if (MD && MD->isMoveAssignmentOperator())
264  return DiagInvalid(DiagMoveAssign);
265  // [basic.start.main]p3: "The function main shall not be a coroutine."
266  else if (FD->isMain())
267  return DiagInvalid(DiagMain);
268 
269  // Emit a diagnostics for each of the following conditions which is not met.
270  // [expr.const]p2: "An expression e is a core constant expression unless the
271  // evaluation of e [...] would evaluate one of the following expressions:
272  // [...] an await-expression [...] a yield-expression."
273  if (FD->isConstexpr())
274  DiagInvalid(DiagConstexpr);
275  // [dcl.spec.auto]p15: "A function declared with a return type that uses a
276  // placeholder type shall not be a coroutine."
277  if (FD->getReturnType()->isUndeducedType())
278  DiagInvalid(DiagAutoRet);
279  // [dcl.fct.def.coroutine]p1: "The parameter-declaration-clause of the
280  // coroutine shall not terminate with an ellipsis that is not part of a
281  // parameter-declaration."
282  if (FD->isVariadic())
283  DiagInvalid(DiagVarargs);
284 
285  return !Diagnosed;
286 }
287 
289  SourceLocation Loc) {
290  DeclarationName OpName =
291  SemaRef.Context.DeclarationNames.getCXXOperatorName(OO_Coawait);
292  LookupResult Operators(SemaRef, OpName, SourceLocation(),
294  SemaRef.LookupName(Operators, S);
295 
296  assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous");
297  const auto &Functions = Operators.asUnresolvedSet();
298  bool IsOverloaded =
299  Functions.size() > 1 ||
300  (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin()));
301  Expr *CoawaitOp = UnresolvedLookupExpr::Create(
302  SemaRef.Context, /*NamingClass*/ nullptr, NestedNameSpecifierLoc(),
303  DeclarationNameInfo(OpName, Loc), /*RequiresADL*/ true, IsOverloaded,
304  Functions.begin(), Functions.end());
305  assert(CoawaitOp);
306  return CoawaitOp;
307 }
308 
309 /// Build a call to 'operator co_await' if there is a suitable operator for
310 /// the given expression.
312  Expr *E,
313  UnresolvedLookupExpr *Lookup) {
314  UnresolvedSet<16> Functions;
315  Functions.append(Lookup->decls_begin(), Lookup->decls_end());
316  return SemaRef.CreateOverloadedUnaryOp(Loc, UO_Coawait, Functions, E);
317 }
318 
320  SourceLocation Loc, Expr *E) {
321  ExprResult R = buildOperatorCoawaitLookupExpr(SemaRef, S, Loc);
322  if (R.isInvalid())
323  return ExprError();
324  return buildOperatorCoawaitCall(SemaRef, Loc, E,
325  cast<UnresolvedLookupExpr>(R.get()));
326 }
327 
329  MultiExprArg CallArgs) {
330  StringRef Name = S.Context.BuiltinInfo.getName(Id);
332  S.LookupName(R, S.TUScope, /*AllowBuiltinCreation=*/true);
333 
334  auto *BuiltInDecl = R.getAsSingle<FunctionDecl>();
335  assert(BuiltInDecl && "failed to find builtin declaration");
336 
337  ExprResult DeclRef =
338  S.BuildDeclRefExpr(BuiltInDecl, BuiltInDecl->getType(), VK_LValue, Loc);
339  assert(DeclRef.isUsable() && "Builtin reference cannot fail");
340 
341  ExprResult Call =
342  S.ActOnCallExpr(/*Scope=*/nullptr, DeclRef.get(), Loc, CallArgs, Loc);
343 
344  assert(!Call.isInvalid() && "Call to builtin cannot fail!");
345  return Call.get();
346 }
347 
349  SourceLocation Loc) {
350  QualType CoroHandleType = lookupCoroutineHandleType(S, PromiseType, Loc);
351  if (CoroHandleType.isNull())
352  return ExprError();
353 
354  DeclContext *LookupCtx = S.computeDeclContext(CoroHandleType);
355  LookupResult Found(S, &S.PP.getIdentifierTable().get("from_address"), Loc,
357  if (!S.LookupQualifiedName(Found, LookupCtx)) {
358  S.Diag(Loc, diag::err_coroutine_handle_missing_member)
359  << "from_address";
360  return ExprError();
361  }
362 
363  Expr *FramePtr =
364  buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
365 
366  CXXScopeSpec SS;
367  ExprResult FromAddr =
368  S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);
369  if (FromAddr.isInvalid())
370  return ExprError();
371 
372  return S.ActOnCallExpr(nullptr, FromAddr.get(), Loc, FramePtr, Loc);
373 }
374 
376  enum AwaitCallType { ACT_Ready, ACT_Suspend, ACT_Resume };
377  Expr *Results[3];
379  bool IsInvalid;
380 };
381 
383  StringRef Name, MultiExprArg Args) {
384  DeclarationNameInfo NameInfo(&S.PP.getIdentifierTable().get(Name), Loc);
385 
386  // FIXME: Fix BuildMemberReferenceExpr to take a const CXXScopeSpec&.
387  CXXScopeSpec SS;
389  Base, Base->getType(), Loc, /*IsPtr=*/false, SS,
390  SourceLocation(), nullptr, NameInfo, /*TemplateArgs=*/nullptr,
391  /*Scope=*/nullptr);
392  if (Result.isInvalid())
393  return ExprError();
394 
395  // We meant exactly what we asked for. No need for typo correction.
396  if (auto *TE = dyn_cast<TypoExpr>(Result.get())) {
397  S.clearDelayedTypo(TE);
398  S.Diag(Loc, diag::err_no_member)
399  << NameInfo.getName() << Base->getType()->getAsCXXRecordDecl()
400  << Base->getSourceRange();
401  return ExprError();
402  }
403 
404  return S.ActOnCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr);
405 }
406 
407 // See if return type is coroutine-handle and if so, invoke builtin coro-resume
408 // on its address. This is to enable experimental support for coroutine-handle
409 // returning await_suspend that results in a guaranteed tail call to the target
410 // coroutine.
411 static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
412  SourceLocation Loc) {
413  if (RetType->isReferenceType())
414  return nullptr;
415  Type const *T = RetType.getTypePtr();
416  if (!T->isClassType() && !T->isStructureType())
417  return nullptr;
418 
419  // FIXME: Add convertability check to coroutine_handle<>. Possibly via
420  // EvaluateBinaryTypeTrait(BTT_IsConvertible, ...) which is at the moment
421  // a private function in SemaExprCXX.cpp
422 
423  ExprResult AddressExpr = buildMemberCall(S, E, Loc, "address", None);
424  if (AddressExpr.isInvalid())
425  return nullptr;
426 
427  Expr *JustAddress = AddressExpr.get();
428  // FIXME: Check that the type of AddressExpr is void*
429  return buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_resume,
430  JustAddress);
431 }
432 
433 /// Build calls to await_ready, await_suspend, and await_resume for a co_await
434 /// expression.
436  SourceLocation Loc, Expr *E) {
437  OpaqueValueExpr *Operand = new (S.Context)
438  OpaqueValueExpr(Loc, E->getType(), VK_LValue, E->getObjectKind(), E);
439 
440  // Assume invalid until we see otherwise.
441  ReadySuspendResumeResult Calls = {{}, Operand, /*IsInvalid=*/true};
442 
443  ExprResult CoroHandleRes = buildCoroutineHandle(S, CoroPromise->getType(), Loc);
444  if (CoroHandleRes.isInvalid())
445  return Calls;
446  Expr *CoroHandle = CoroHandleRes.get();
447 
448  const StringRef Funcs[] = {"await_ready", "await_suspend", "await_resume"};
449  MultiExprArg Args[] = {None, CoroHandle, None};
450  for (size_t I = 0, N = llvm::array_lengthof(Funcs); I != N; ++I) {
451  ExprResult Result = buildMemberCall(S, Operand, Loc, Funcs[I], Args[I]);
452  if (Result.isInvalid())
453  return Calls;
454  Calls.Results[I] = Result.get();
455  }
456 
457  // Assume the calls are valid; all further checking should make them invalid.
458  Calls.IsInvalid = false;
459 
461  CallExpr *AwaitReady = cast<CallExpr>(Calls.Results[ACT::ACT_Ready]);
462  if (!AwaitReady->getType()->isDependentType()) {
463  // [expr.await]p3 [...]
464  // — await-ready is the expression e.await_ready(), contextually converted
465  // to bool.
466  ExprResult Conv = S.PerformContextuallyConvertToBool(AwaitReady);
467  if (Conv.isInvalid()) {
468  S.Diag(AwaitReady->getDirectCallee()->getLocStart(),
469  diag::note_await_ready_no_bool_conversion);
470  S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
471  << AwaitReady->getDirectCallee() << E->getSourceRange();
472  Calls.IsInvalid = true;
473  }
474  Calls.Results[ACT::ACT_Ready] = Conv.get();
475  }
476  CallExpr *AwaitSuspend = cast<CallExpr>(Calls.Results[ACT::ACT_Suspend]);
477  if (!AwaitSuspend->getType()->isDependentType()) {
478  // [expr.await]p3 [...]
479  // - await-suspend is the expression e.await_suspend(h), which shall be
480  // a prvalue of type void or bool.
481  QualType RetType = AwaitSuspend->getCallReturnType(S.Context);
482 
483  // Experimental support for coroutine_handle returning await_suspend.
484  if (Expr *TailCallSuspend = maybeTailCall(S, RetType, AwaitSuspend, Loc))
485  Calls.Results[ACT::ACT_Suspend] = TailCallSuspend;
486  else {
487  // non-class prvalues always have cv-unqualified types
488  if (RetType->isReferenceType() ||
489  (!RetType->isBooleanType() && !RetType->isVoidType())) {
490  S.Diag(AwaitSuspend->getCalleeDecl()->getLocation(),
491  diag::err_await_suspend_invalid_return_type)
492  << RetType;
493  S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
494  << AwaitSuspend->getDirectCallee();
495  Calls.IsInvalid = true;
496  }
497  }
498  }
499 
500  return Calls;
501 }
502 
504  SourceLocation Loc, StringRef Name,
505  MultiExprArg Args) {
506 
507  // Form a reference to the promise.
508  ExprResult PromiseRef = S.BuildDeclRefExpr(
509  Promise, Promise->getType().getNonReferenceType(), VK_LValue, Loc);
510  if (PromiseRef.isInvalid())
511  return ExprError();
512 
513  return buildMemberCall(S, PromiseRef.get(), Loc, Name, Args);
514 }
515 
517  assert(isa<FunctionDecl>(CurContext) && "not in a function scope");
518  auto *FD = cast<FunctionDecl>(CurContext);
519  bool IsThisDependentType = [&] {
520  if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD))
521  return MD->isInstance() && MD->getThisType(Context)->isDependentType();
522  else
523  return false;
524  }();
525 
526  QualType T = FD->getType()->isDependentType() || IsThisDependentType
527  ? Context.DependentTy
528  : lookupPromiseType(*this, FD, Loc);
529  if (T.isNull())
530  return nullptr;
531 
532  auto *VD = VarDecl::Create(Context, FD, FD->getLocation(), FD->getLocation(),
533  &PP.getIdentifierTable().get("__promise"), T,
534  Context.getTrivialTypeSourceInfo(T, Loc), SC_None);
535  CheckVariableDeclarationType(VD);
536  if (VD->isInvalidDecl())
537  return nullptr;
538 
539  auto *ScopeInfo = getCurFunction();
540  // Build a list of arguments, based on the coroutine functions arguments,
541  // that will be passed to the promise type's constructor.
542  llvm::SmallVector<Expr *, 4> CtorArgExprs;
543 
544  // Add implicit object parameter.
545  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
546  if (MD->isInstance() && !isLambdaCallOperator(MD)) {
547  ExprResult ThisExpr = ActOnCXXThis(Loc);
548  if (ThisExpr.isInvalid())
549  return nullptr;
550  ThisExpr = CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get());
551  if (ThisExpr.isInvalid())
552  return nullptr;
553  CtorArgExprs.push_back(ThisExpr.get());
554  }
555  }
556 
557  auto &Moves = ScopeInfo->CoroutineParameterMoves;
558  for (auto *PD : FD->parameters()) {
559  if (PD->getType()->isDependentType())
560  continue;
561 
562  auto RefExpr = ExprEmpty();
563  auto Move = Moves.find(PD);
564  assert(Move != Moves.end() &&
565  "Coroutine function parameter not inserted into move map");
566  // If a reference to the function parameter exists in the coroutine
567  // frame, use that reference.
568  auto *MoveDecl =
569  cast<VarDecl>(cast<DeclStmt>(Move->second)->getSingleDecl());
570  RefExpr =
571  BuildDeclRefExpr(MoveDecl, MoveDecl->getType().getNonReferenceType(),
572  ExprValueKind::VK_LValue, FD->getLocation());
573  if (RefExpr.isInvalid())
574  return nullptr;
575  CtorArgExprs.push_back(RefExpr.get());
576  }
577 
578  // Create an initialization sequence for the promise type using the
579  // constructor arguments, wrapped in a parenthesized list expression.
580  Expr *PLE = new (Context) ParenListExpr(Context, FD->getLocation(),
581  CtorArgExprs, FD->getLocation());
584  VD->getLocation(), /*DirectInit=*/true, PLE);
585  InitializationSequence InitSeq(*this, Entity, Kind, CtorArgExprs,
586  /*TopLevelOfInitList=*/false,
587  /*TreatUnavailableAsInvalid=*/false);
588 
589  // Attempt to initialize the promise type with the arguments.
590  // If that fails, fall back to the promise type's default constructor.
591  if (InitSeq) {
592  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, CtorArgExprs);
593  if (Result.isInvalid()) {
594  VD->setInvalidDecl();
595  } else if (Result.get()) {
596  VD->setInit(MaybeCreateExprWithCleanups(Result.get()));
597  VD->setInitStyle(VarDecl::CallInit);
598  CheckCompleteVariableDeclaration(VD);
599  }
600  } else
601  ActOnUninitializedDecl(VD);
602 
603  FD->addDecl(VD);
604  return VD;
605 }
606 
607 /// Check that this is a context in which a coroutine suspension can appear.
609  StringRef Keyword,
610  bool IsImplicit = false) {
611  if (!isValidCoroutineContext(S, Loc, Keyword))
612  return nullptr;
613 
614  assert(isa<FunctionDecl>(S.CurContext) && "not in a function scope");
615 
616  auto *ScopeInfo = S.getCurFunction();
617  assert(ScopeInfo && "missing function scope for function");
618 
619  if (ScopeInfo->FirstCoroutineStmtLoc.isInvalid() && !IsImplicit)
620  ScopeInfo->setFirstCoroutineStmt(Loc, Keyword);
621 
622  if (ScopeInfo->CoroutinePromise)
623  return ScopeInfo;
624 
625  if (!S.buildCoroutineParameterMoves(Loc))
626  return nullptr;
627 
628  ScopeInfo->CoroutinePromise = S.buildCoroutinePromise(Loc);
629  if (!ScopeInfo->CoroutinePromise)
630  return nullptr;
631 
632  return ScopeInfo;
633 }
634 
636  StringRef Keyword) {
637  if (!checkCoroutineContext(*this, KWLoc, Keyword))
638  return false;
639  auto *ScopeInfo = getCurFunction();
640  assert(ScopeInfo->CoroutinePromise);
641 
642  // If we have existing coroutine statements then we have already built
643  // the initial and final suspend points.
644  if (!ScopeInfo->NeedsCoroutineSuspends)
645  return true;
646 
647  ScopeInfo->setNeedsCoroutineSuspends(false);
648 
649  auto *Fn = cast<FunctionDecl>(CurContext);
650  SourceLocation Loc = Fn->getLocation();
651  // Build the initial suspend point
652  auto buildSuspends = [&](StringRef Name) mutable -> StmtResult {
653  ExprResult Suspend =
654  buildPromiseCall(*this, ScopeInfo->CoroutinePromise, Loc, Name, None);
655  if (Suspend.isInvalid())
656  return StmtError();
657  Suspend = buildOperatorCoawaitCall(*this, SC, Loc, Suspend.get());
658  if (Suspend.isInvalid())
659  return StmtError();
660  Suspend = BuildResolvedCoawaitExpr(Loc, Suspend.get(),
661  /*IsImplicit*/ true);
662  Suspend = ActOnFinishFullExpr(Suspend.get());
663  if (Suspend.isInvalid()) {
664  Diag(Loc, diag::note_coroutine_promise_suspend_implicitly_required)
665  << ((Name == "initial_suspend") ? 0 : 1);
666  Diag(KWLoc, diag::note_declared_coroutine_here) << Keyword;
667  return StmtError();
668  }
669  return cast<Stmt>(Suspend.get());
670  };
671 
672  StmtResult InitSuspend = buildSuspends("initial_suspend");
673  if (InitSuspend.isInvalid())
674  return true;
675 
676  StmtResult FinalSuspend = buildSuspends("final_suspend");
677  if (FinalSuspend.isInvalid())
678  return true;
679 
680  ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
681 
682  return true;
683 }
684 
686  if (!ActOnCoroutineBodyStart(S, Loc, "co_await")) {
687  CorrectDelayedTyposInExpr(E);
688  return ExprError();
689  }
690 
691  if (E->getType()->isPlaceholderType()) {
692  ExprResult R = CheckPlaceholderExpr(E);
693  if (R.isInvalid()) return ExprError();
694  E = R.get();
695  }
696  ExprResult Lookup = buildOperatorCoawaitLookupExpr(*this, S, Loc);
697  if (Lookup.isInvalid())
698  return ExprError();
699  return BuildUnresolvedCoawaitExpr(Loc, E,
700  cast<UnresolvedLookupExpr>(Lookup.get()));
701 }
702 
704  UnresolvedLookupExpr *Lookup) {
705  auto *FSI = checkCoroutineContext(*this, Loc, "co_await");
706  if (!FSI)
707  return ExprError();
708 
709  if (E->getType()->isPlaceholderType()) {
710  ExprResult R = CheckPlaceholderExpr(E);
711  if (R.isInvalid())
712  return ExprError();
713  E = R.get();
714  }
715 
716  auto *Promise = FSI->CoroutinePromise;
717  if (Promise->getType()->isDependentType()) {
718  Expr *Res =
719  new (Context) DependentCoawaitExpr(Loc, Context.DependentTy, E, Lookup);
720  return Res;
721  }
722 
723  auto *RD = Promise->getType()->getAsCXXRecordDecl();
724  if (lookupMember(*this, "await_transform", RD, Loc)) {
725  ExprResult R = buildPromiseCall(*this, Promise, Loc, "await_transform", E);
726  if (R.isInvalid()) {
727  Diag(Loc,
728  diag::note_coroutine_promise_implicit_await_transform_required_here)
729  << E->getSourceRange();
730  return ExprError();
731  }
732  E = R.get();
733  }
734  ExprResult Awaitable = buildOperatorCoawaitCall(*this, Loc, E, Lookup);
735  if (Awaitable.isInvalid())
736  return ExprError();
737 
738  return BuildResolvedCoawaitExpr(Loc, Awaitable.get());
739 }
740 
742  bool IsImplicit) {
743  auto *Coroutine = checkCoroutineContext(*this, Loc, "co_await", IsImplicit);
744  if (!Coroutine)
745  return ExprError();
746 
747  if (E->getType()->isPlaceholderType()) {
748  ExprResult R = CheckPlaceholderExpr(E);
749  if (R.isInvalid()) return ExprError();
750  E = R.get();
751  }
752 
753  if (E->getType()->isDependentType()) {
754  Expr *Res = new (Context)
755  CoawaitExpr(Loc, Context.DependentTy, E, IsImplicit);
756  return Res;
757  }
758 
759  // If the expression is a temporary, materialize it as an lvalue so that we
760  // can use it multiple times.
761  if (E->getValueKind() == VK_RValue)
762  E = CreateMaterializeTemporaryExpr(E->getType(), E, true);
763 
764  // The location of the `co_await` token cannot be used when constructing
765  // the member call expressions since it's before the location of `Expr`, which
766  // is used as the start of the member call expression.
767  SourceLocation CallLoc = E->getExprLoc();
768 
769  // Build the await_ready, await_suspend, await_resume calls.
771  buildCoawaitCalls(*this, Coroutine->CoroutinePromise, CallLoc, E);
772  if (RSS.IsInvalid)
773  return ExprError();
774 
775  Expr *Res =
776  new (Context) CoawaitExpr(Loc, E, RSS.Results[0], RSS.Results[1],
777  RSS.Results[2], RSS.OpaqueValue, IsImplicit);
778 
779  return Res;
780 }
781 
783  if (!ActOnCoroutineBodyStart(S, Loc, "co_yield")) {
784  CorrectDelayedTyposInExpr(E);
785  return ExprError();
786  }
787 
788  // Build yield_value call.
789  ExprResult Awaitable = buildPromiseCall(
790  *this, getCurFunction()->CoroutinePromise, Loc, "yield_value", E);
791  if (Awaitable.isInvalid())
792  return ExprError();
793 
794  // Build 'operator co_await' call.
795  Awaitable = buildOperatorCoawaitCall(*this, S, Loc, Awaitable.get());
796  if (Awaitable.isInvalid())
797  return ExprError();
798 
799  return BuildCoyieldExpr(Loc, Awaitable.get());
800 }
802  auto *Coroutine = checkCoroutineContext(*this, Loc, "co_yield");
803  if (!Coroutine)
804  return ExprError();
805 
806  if (E->getType()->isPlaceholderType()) {
807  ExprResult R = CheckPlaceholderExpr(E);
808  if (R.isInvalid()) return ExprError();
809  E = R.get();
810  }
811 
812  if (E->getType()->isDependentType()) {
813  Expr *Res = new (Context) CoyieldExpr(Loc, Context.DependentTy, E);
814  return Res;
815  }
816 
817  // If the expression is a temporary, materialize it as an lvalue so that we
818  // can use it multiple times.
819  if (E->getValueKind() == VK_RValue)
820  E = CreateMaterializeTemporaryExpr(E->getType(), E, true);
821 
822  // Build the await_ready, await_suspend, await_resume calls.
824  buildCoawaitCalls(*this, Coroutine->CoroutinePromise, Loc, E);
825  if (RSS.IsInvalid)
826  return ExprError();
827 
828  Expr *Res =
829  new (Context) CoyieldExpr(Loc, E, RSS.Results[0], RSS.Results[1],
830  RSS.Results[2], RSS.OpaqueValue);
831 
832  return Res;
833 }
834 
836  if (!ActOnCoroutineBodyStart(S, Loc, "co_return")) {
837  CorrectDelayedTyposInExpr(E);
838  return StmtError();
839  }
840  return BuildCoreturnStmt(Loc, E);
841 }
842 
844  bool IsImplicit) {
845  auto *FSI = checkCoroutineContext(*this, Loc, "co_return", IsImplicit);
846  if (!FSI)
847  return StmtError();
848 
849  if (E && E->getType()->isPlaceholderType() &&
850  !E->getType()->isSpecificPlaceholderType(BuiltinType::Overload)) {
851  ExprResult R = CheckPlaceholderExpr(E);
852  if (R.isInvalid()) return StmtError();
853  E = R.get();
854  }
855 
856  // FIXME: If the operand is a reference to a variable that's about to go out
857  // of scope, we should treat the operand as an xvalue for this overload
858  // resolution.
859  VarDecl *Promise = FSI->CoroutinePromise;
860  ExprResult PC;
861  if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) {
862  PC = buildPromiseCall(*this, Promise, Loc, "return_value", E);
863  } else {
864  E = MakeFullDiscardedValueExpr(E).get();
865  PC = buildPromiseCall(*this, Promise, Loc, "return_void", None);
866  }
867  if (PC.isInvalid())
868  return StmtError();
869 
870  Expr *PCE = ActOnFinishFullExpr(PC.get()).get();
871 
872  Stmt *Res = new (Context) CoreturnStmt(Loc, E, PCE, IsImplicit);
873  return Res;
874 }
875 
876 /// Look up the std::nothrow object.
879  assert(Std && "Should already be diagnosed");
880 
881  LookupResult Result(S, &S.PP.getIdentifierTable().get("nothrow"), Loc,
883  if (!S.LookupQualifiedName(Result, Std)) {
884  // FIXME: <experimental/coroutine> should have been included already.
885  // If we require it to include <new> then this diagnostic is no longer
886  // needed.
887  S.Diag(Loc, diag::err_implicit_coroutine_std_nothrow_type_not_found);
888  return nullptr;
889  }
890 
891  auto *VD = Result.getAsSingle<VarDecl>();
892  if (!VD) {
893  Result.suppressDiagnostics();
894  // We found something weird. Complain about the first thing we found.
895  NamedDecl *Found = *Result.begin();
896  S.Diag(Found->getLocation(), diag::err_malformed_std_nothrow);
897  return nullptr;
898  }
899 
900  ExprResult DR = S.BuildDeclRefExpr(VD, VD->getType(), VK_LValue, Loc);
901  if (DR.isInvalid())
902  return nullptr;
903 
904  return DR.get();
905 }
906 
907 // Find an appropriate delete for the promise.
909  QualType PromiseType) {
910  FunctionDecl *OperatorDelete = nullptr;
911 
912  DeclarationName DeleteName =
914 
915  auto *PointeeRD = PromiseType->getAsCXXRecordDecl();
916  assert(PointeeRD && "PromiseType must be a CxxRecordDecl type");
917 
918  if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete))
919  return nullptr;
920 
921  if (!OperatorDelete) {
922  // Look for a global declaration.
923  const bool CanProvideSize = S.isCompleteType(Loc, PromiseType);
924  const bool Overaligned = false;
925  OperatorDelete = S.FindUsualDeallocationFunction(Loc, CanProvideSize,
926  Overaligned, DeleteName);
927  }
928  S.MarkFunctionReferenced(Loc, OperatorDelete);
929  return OperatorDelete;
930 }
931 
932 
934  FunctionScopeInfo *Fn = getCurFunction();
935  assert(Fn && Fn->isCoroutine() && "not a coroutine");
936  if (!Body) {
937  assert(FD->isInvalidDecl() &&
938  "a null body is only allowed for invalid declarations");
939  return;
940  }
941  // We have a function that uses coroutine keywords, but we failed to build
942  // the promise type.
943  if (!Fn->CoroutinePromise)
944  return FD->setInvalidDecl();
945 
946  if (isa<CoroutineBodyStmt>(Body)) {
947  // Nothing todo. the body is already a transformed coroutine body statement.
948  return;
949  }
950 
951  // Coroutines [stmt.return]p1:
952  // A return statement shall not appear in a coroutine.
953  if (Fn->FirstReturnLoc.isValid()) {
954  assert(Fn->FirstCoroutineStmtLoc.isValid() &&
955  "first coroutine location not set");
956  Diag(Fn->FirstReturnLoc, diag::err_return_in_coroutine);
957  Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
959  }
960  CoroutineStmtBuilder Builder(*this, *FD, *Fn, Body);
961  if (Builder.isInvalid() || !Builder.buildStatements())
962  return FD->setInvalidDecl();
963 
964  // Build body for the coroutine wrapper statement.
965  Body = CoroutineBodyStmt::Create(Context, Builder);
966 }
967 
970  Stmt *Body)
971  : S(S), FD(FD), Fn(Fn), Loc(FD.getLocation()),
972  IsPromiseDependentType(
973  !Fn.CoroutinePromise ||
974  Fn.CoroutinePromise->getType()->isDependentType()) {
975  this->Body = Body;
976 
977  for (auto KV : Fn.CoroutineParameterMoves)
978  this->ParamMovesVector.push_back(KV.second);
979  this->ParamMoves = this->ParamMovesVector;
980 
981  if (!IsPromiseDependentType) {
982  PromiseRecordDecl = Fn.CoroutinePromise->getType()->getAsCXXRecordDecl();
983  assert(PromiseRecordDecl && "Type should have already been checked");
984  }
985  this->IsValid = makePromiseStmt() && makeInitialAndFinalSuspend();
986 }
987 
989  assert(this->IsValid && "coroutine already invalid");
990  this->IsValid = makeReturnObject();
991  if (this->IsValid && !IsPromiseDependentType)
993  return this->IsValid;
994 }
995 
997  assert(this->IsValid && "coroutine already invalid");
998  assert(!this->IsPromiseDependentType &&
999  "coroutine cannot have a dependent promise type");
1000  this->IsValid = makeOnException() && makeOnFallthrough() &&
1001  makeGroDeclAndReturnStmt() && makeReturnOnAllocFailure() &&
1002  makeNewAndDeleteExpr();
1003  return this->IsValid;
1004 }
1005 
1006 bool CoroutineStmtBuilder::makePromiseStmt() {
1007  // Form a declaration statement for the promise declaration, so that AST
1008  // visitors can more easily find it.
1009  StmtResult PromiseStmt =
1011  if (PromiseStmt.isInvalid())
1012  return false;
1013 
1014  this->Promise = PromiseStmt.get();
1015  return true;
1016 }
1017 
1018 bool CoroutineStmtBuilder::makeInitialAndFinalSuspend() {
1019  if (Fn.hasInvalidCoroutineSuspends())
1020  return false;
1021  this->InitialSuspend = cast<Expr>(Fn.CoroutineSuspends.first);
1022  this->FinalSuspend = cast<Expr>(Fn.CoroutineSuspends.second);
1023  return true;
1024 }
1025 
1027  CXXRecordDecl *PromiseRecordDecl,
1028  FunctionScopeInfo &Fn) {
1029  auto Loc = E->getExprLoc();
1030  if (auto *DeclRef = dyn_cast_or_null<DeclRefExpr>(E)) {
1031  auto *Decl = DeclRef->getDecl();
1032  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(Decl)) {
1033  if (Method->isStatic())
1034  return true;
1035  else
1036  Loc = Decl->getLocation();
1037  }
1038  }
1039 
1040  S.Diag(
1041  Loc,
1042  diag::err_coroutine_promise_get_return_object_on_allocation_failure)
1043  << PromiseRecordDecl;
1044  S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
1046  return false;
1047 }
1048 
1049 bool CoroutineStmtBuilder::makeReturnOnAllocFailure() {
1050  assert(!IsPromiseDependentType &&
1051  "cannot make statement while the promise type is dependent");
1052 
1053  // [dcl.fct.def.coroutine]/8
1054  // The unqualified-id get_return_object_on_allocation_failure is looked up in
1055  // the scope of class P by class member access lookup (3.4.5). ...
1056  // If an allocation function returns nullptr, ... the coroutine return value
1057  // is obtained by a call to ... get_return_object_on_allocation_failure().
1058 
1059  DeclarationName DN =
1060  S.PP.getIdentifierInfo("get_return_object_on_allocation_failure");
1061  LookupResult Found(S, DN, Loc, Sema::LookupMemberName);
1062  if (!S.LookupQualifiedName(Found, PromiseRecordDecl))
1063  return true;
1064 
1065  CXXScopeSpec SS;
1066  ExprResult DeclNameExpr =
1067  S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);
1068  if (DeclNameExpr.isInvalid())
1069  return false;
1070 
1071  if (!diagReturnOnAllocFailure(S, DeclNameExpr.get(), PromiseRecordDecl, Fn))
1072  return false;
1073 
1074  ExprResult ReturnObjectOnAllocationFailure =
1075  S.ActOnCallExpr(nullptr, DeclNameExpr.get(), Loc, {}, Loc);
1076  if (ReturnObjectOnAllocationFailure.isInvalid())
1077  return false;
1078 
1080  S.BuildReturnStmt(Loc, ReturnObjectOnAllocationFailure.get());
1081  if (ReturnStmt.isInvalid()) {
1082  S.Diag(Found.getFoundDecl()->getLocation(), diag::note_member_declared_here)
1083  << DN;
1084  S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
1086  return false;
1087  }
1088 
1089  this->ReturnStmtOnAllocFailure = ReturnStmt.get();
1090  return true;
1091 }
1092 
1093 bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
1094  // Form and check allocation and deallocation calls.
1095  assert(!IsPromiseDependentType &&
1096  "cannot make statement while the promise type is dependent");
1097  QualType PromiseType = Fn.CoroutinePromise->getType();
1098 
1099  if (S.RequireCompleteType(Loc, PromiseType, diag::err_incomplete_type))
1100  return false;
1101 
1102  const bool RequiresNoThrowAlloc = ReturnStmtOnAllocFailure != nullptr;
1103 
1104  // [dcl.fct.def.coroutine]/7
1105  // Lookup allocation functions using a parameter list composed of the
1106  // requested size of the coroutine state being allocated, followed by
1107  // the coroutine function's arguments. If a matching allocation function
1108  // exists, use it. Otherwise, use an allocation function that just takes
1109  // the requested size.
1110 
1111  FunctionDecl *OperatorNew = nullptr;
1112  FunctionDecl *OperatorDelete = nullptr;
1113  FunctionDecl *UnusedResult = nullptr;
1114  bool PassAlignment = false;
1115  SmallVector<Expr *, 1> PlacementArgs;
1116 
1117  // [dcl.fct.def.coroutine]/7
1118  // "The allocation function’s name is looked up in the scope of P.
1119  // [...] If the lookup finds an allocation function in the scope of P,
1120  // overload resolution is performed on a function call created by assembling
1121  // an argument list. The first argument is the amount of space requested,
1122  // and has type std::size_t. The lvalues p1 ... pn are the succeeding
1123  // arguments."
1124  //
1125  // ...where "p1 ... pn" are defined earlier as:
1126  //
1127  // [dcl.fct.def.coroutine]/3
1128  // "For a coroutine f that is a non-static member function, let P1 denote the
1129  // type of the implicit object parameter (13.3.1) and P2 ... Pn be the types
1130  // of the function parameters; otherwise let P1 ... Pn be the types of the
1131  // function parameters. Let p1 ... pn be lvalues denoting those objects."
1132  if (auto *MD = dyn_cast<CXXMethodDecl>(&FD)) {
1133  if (MD->isInstance() && !isLambdaCallOperator(MD)) {
1134  ExprResult ThisExpr = S.ActOnCXXThis(Loc);
1135  if (ThisExpr.isInvalid())
1136  return false;
1137  ThisExpr = S.CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get());
1138  if (ThisExpr.isInvalid())
1139  return false;
1140  PlacementArgs.push_back(ThisExpr.get());
1141  }
1142  }
1143  for (auto *PD : FD.parameters()) {
1144  if (PD->getType()->isDependentType())
1145  continue;
1146 
1147  // Build a reference to the parameter.
1148  auto PDLoc = PD->getLocation();
1149  ExprResult PDRefExpr =
1150  S.BuildDeclRefExpr(PD, PD->getOriginalType().getNonReferenceType(),
1151  ExprValueKind::VK_LValue, PDLoc);
1152  if (PDRefExpr.isInvalid())
1153  return false;
1154 
1155  PlacementArgs.push_back(PDRefExpr.get());
1156  }
1157  S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class,
1158  /*DeleteScope*/ Sema::AFS_Both, PromiseType,
1159  /*isArray*/ false, PassAlignment, PlacementArgs,
1160  OperatorNew, UnusedResult, /*Diagnose*/ false);
1161 
1162  // [dcl.fct.def.coroutine]/7
1163  // "If no matching function is found, overload resolution is performed again
1164  // on a function call created by passing just the amount of space required as
1165  // an argument of type std::size_t."
1166  if (!OperatorNew && !PlacementArgs.empty()) {
1167  PlacementArgs.clear();
1168  S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class,
1169  /*DeleteScope*/ Sema::AFS_Both, PromiseType,
1170  /*isArray*/ false, PassAlignment, PlacementArgs,
1171  OperatorNew, UnusedResult, /*Diagnose*/ false);
1172  }
1173 
1174  // [dcl.fct.def.coroutine]/7
1175  // "The allocation function’s name is looked up in the scope of P. If this
1176  // lookup fails, the allocation function’s name is looked up in the global
1177  // scope."
1178  if (!OperatorNew) {
1179  S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Global,
1180  /*DeleteScope*/ Sema::AFS_Both, PromiseType,
1181  /*isArray*/ false, PassAlignment, PlacementArgs,
1182  OperatorNew, UnusedResult);
1183  }
1184 
1185  bool IsGlobalOverload =
1186  OperatorNew && !isa<CXXRecordDecl>(OperatorNew->getDeclContext());
1187  // If we didn't find a class-local new declaration and non-throwing new
1188  // was is required then we need to lookup the non-throwing global operator
1189  // instead.
1190  if (RequiresNoThrowAlloc && (!OperatorNew || IsGlobalOverload)) {
1191  auto *StdNoThrow = buildStdNoThrowDeclRef(S, Loc);
1192  if (!StdNoThrow)
1193  return false;
1194  PlacementArgs = {StdNoThrow};
1195  OperatorNew = nullptr;
1196  S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Both,
1197  /*DeleteScope*/ Sema::AFS_Both, PromiseType,
1198  /*isArray*/ false, PassAlignment, PlacementArgs,
1199  OperatorNew, UnusedResult);
1200  }
1201 
1202  if (!OperatorNew)
1203  return false;
1204 
1205  if (RequiresNoThrowAlloc) {
1206  const auto *FT = OperatorNew->getType()->getAs<FunctionProtoType>();
1207  if (!FT->isNothrow(/*ResultIfDependent*/ false)) {
1208  S.Diag(OperatorNew->getLocation(),
1209  diag::err_coroutine_promise_new_requires_nothrow)
1210  << OperatorNew;
1211  S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
1212  << OperatorNew;
1213  return false;
1214  }
1215  }
1216 
1217  if ((OperatorDelete = findDeleteForPromise(S, Loc, PromiseType)) == nullptr)
1218  return false;
1219 
1220  Expr *FramePtr =
1221  buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
1222 
1223  Expr *FrameSize =
1224  buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_size, {});
1225 
1226  // Make new call.
1227 
1228  ExprResult NewRef =
1229  S.BuildDeclRefExpr(OperatorNew, OperatorNew->getType(), VK_LValue, Loc);
1230  if (NewRef.isInvalid())
1231  return false;
1232 
1233  SmallVector<Expr *, 2> NewArgs(1, FrameSize);
1234  for (auto Arg : PlacementArgs)
1235  NewArgs.push_back(Arg);
1236 
1237  ExprResult NewExpr =
1238  S.ActOnCallExpr(S.getCurScope(), NewRef.get(), Loc, NewArgs, Loc);
1239  NewExpr = S.ActOnFinishFullExpr(NewExpr.get());
1240  if (NewExpr.isInvalid())
1241  return false;
1242 
1243  // Make delete call.
1244 
1245  QualType OpDeleteQualType = OperatorDelete->getType();
1246 
1247  ExprResult DeleteRef =
1248  S.BuildDeclRefExpr(OperatorDelete, OpDeleteQualType, VK_LValue, Loc);
1249  if (DeleteRef.isInvalid())
1250  return false;
1251 
1252  Expr *CoroFree =
1253  buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_free, {FramePtr});
1254 
1255  SmallVector<Expr *, 2> DeleteArgs{CoroFree};
1256 
1257  // Check if we need to pass the size.
1258  const auto *OpDeleteType =
1259  OpDeleteQualType.getTypePtr()->getAs<FunctionProtoType>();
1260  if (OpDeleteType->getNumParams() > 1)
1261  DeleteArgs.push_back(FrameSize);
1262 
1263  ExprResult DeleteExpr =
1264  S.ActOnCallExpr(S.getCurScope(), DeleteRef.get(), Loc, DeleteArgs, Loc);
1265  DeleteExpr = S.ActOnFinishFullExpr(DeleteExpr.get());
1266  if (DeleteExpr.isInvalid())
1267  return false;
1268 
1269  this->Allocate = NewExpr.get();
1270  this->Deallocate = DeleteExpr.get();
1271 
1272  return true;
1273 }
1274 
1275 bool CoroutineStmtBuilder::makeOnFallthrough() {
1276  assert(!IsPromiseDependentType &&
1277  "cannot make statement while the promise type is dependent");
1278 
1279  // [dcl.fct.def.coroutine]/4
1280  // The unqualified-ids 'return_void' and 'return_value' are looked up in
1281  // the scope of class P. If both are found, the program is ill-formed.
1282  bool HasRVoid, HasRValue;
1283  LookupResult LRVoid =
1284  lookupMember(S, "return_void", PromiseRecordDecl, Loc, HasRVoid);
1285  LookupResult LRValue =
1286  lookupMember(S, "return_value", PromiseRecordDecl, Loc, HasRValue);
1287 
1288  StmtResult Fallthrough;
1289  if (HasRVoid && HasRValue) {
1290  // FIXME Improve this diagnostic
1291  S.Diag(FD.getLocation(),
1292  diag::err_coroutine_promise_incompatible_return_functions)
1293  << PromiseRecordDecl;
1294  S.Diag(LRVoid.getRepresentativeDecl()->getLocation(),
1295  diag::note_member_first_declared_here)
1296  << LRVoid.getLookupName();
1297  S.Diag(LRValue.getRepresentativeDecl()->getLocation(),
1298  diag::note_member_first_declared_here)
1299  << LRValue.getLookupName();
1300  return false;
1301  } else if (!HasRVoid && !HasRValue) {
1302  // FIXME: The PDTS currently specifies this case as UB, not ill-formed.
1303  // However we still diagnose this as an error since until the PDTS is fixed.
1304  S.Diag(FD.getLocation(),
1305  diag::err_coroutine_promise_requires_return_function)
1306  << PromiseRecordDecl;
1307  S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here)
1308  << PromiseRecordDecl;
1309  return false;
1310  } else if (HasRVoid) {
1311  // If the unqualified-id return_void is found, flowing off the end of a
1312  // coroutine is equivalent to a co_return with no operand. Otherwise,
1313  // flowing off the end of a coroutine results in undefined behavior.
1314  Fallthrough = S.BuildCoreturnStmt(FD.getLocation(), nullptr,
1315  /*IsImplicit*/false);
1316  Fallthrough = S.ActOnFinishFullStmt(Fallthrough.get());
1317  if (Fallthrough.isInvalid())
1318  return false;
1319  }
1320 
1321  this->OnFallthrough = Fallthrough.get();
1322  return true;
1323 }
1324 
1325 bool CoroutineStmtBuilder::makeOnException() {
1326  // Try to form 'p.unhandled_exception();'
1327  assert(!IsPromiseDependentType &&
1328  "cannot make statement while the promise type is dependent");
1329 
1330  const bool RequireUnhandledException = S.getLangOpts().CXXExceptions;
1331 
1332  if (!lookupMember(S, "unhandled_exception", PromiseRecordDecl, Loc)) {
1333  auto DiagID =
1334  RequireUnhandledException
1335  ? diag::err_coroutine_promise_unhandled_exception_required
1336  : diag::
1337  warn_coroutine_promise_unhandled_exception_required_with_exceptions;
1338  S.Diag(Loc, DiagID) << PromiseRecordDecl;
1339  S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here)
1340  << PromiseRecordDecl;
1341  return !RequireUnhandledException;
1342  }
1343 
1344  // If exceptions are disabled, don't try to build OnException.
1345  if (!S.getLangOpts().CXXExceptions)
1346  return true;
1347 
1348  ExprResult UnhandledException = buildPromiseCall(S, Fn.CoroutinePromise, Loc,
1349  "unhandled_exception", None);
1350  UnhandledException = S.ActOnFinishFullExpr(UnhandledException.get(), Loc);
1351  if (UnhandledException.isInvalid())
1352  return false;
1353 
1354  // Since the body of the coroutine will be wrapped in try-catch, it will
1355  // be incompatible with SEH __try if present in a function.
1356  if (!S.getLangOpts().Borland && Fn.FirstSEHTryLoc.isValid()) {
1357  S.Diag(Fn.FirstSEHTryLoc, diag::err_seh_in_a_coroutine_with_cxx_exceptions);
1358  S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
1360  return false;
1361  }
1362 
1363  this->OnException = UnhandledException.get();
1364  return true;
1365 }
1366 
1367 bool CoroutineStmtBuilder::makeReturnObject() {
1368  // Build implicit 'p.get_return_object()' expression and form initialization
1369  // of return type from it.
1370  ExprResult ReturnObject =
1371  buildPromiseCall(S, Fn.CoroutinePromise, Loc, "get_return_object", None);
1372  if (ReturnObject.isInvalid())
1373  return false;
1374 
1375  this->ReturnValue = ReturnObject.get();
1376  return true;
1377 }
1378 
1380  if (auto *MbrRef = dyn_cast<CXXMemberCallExpr>(E)) {
1381  auto *MethodDecl = MbrRef->getMethodDecl();
1382  S.Diag(MethodDecl->getLocation(), diag::note_member_declared_here)
1383  << MethodDecl;
1384  }
1385  S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
1387 }
1388 
1389 bool CoroutineStmtBuilder::makeGroDeclAndReturnStmt() {
1390  assert(!IsPromiseDependentType &&
1391  "cannot make statement while the promise type is dependent");
1392  assert(this->ReturnValue && "ReturnValue must be already formed");
1393 
1394  QualType const GroType = this->ReturnValue->getType();
1395  assert(!GroType->isDependentType() &&
1396  "get_return_object type must no longer be dependent");
1397 
1398  QualType const FnRetType = FD.getReturnType();
1399  assert(!FnRetType->isDependentType() &&
1400  "get_return_object type must no longer be dependent");
1401 
1402  if (FnRetType->isVoidType()) {
1403  ExprResult Res = S.ActOnFinishFullExpr(this->ReturnValue, Loc);
1404  if (Res.isInvalid())
1405  return false;
1406 
1407  this->ResultDecl = Res.get();
1408  return true;
1409  }
1410 
1411  if (GroType->isVoidType()) {
1412  // Trigger a nice error message.
1413  InitializedEntity Entity =
1414  InitializedEntity::InitializeResult(Loc, FnRetType, false);
1415  S.PerformMoveOrCopyInitialization(Entity, nullptr, FnRetType, ReturnValue);
1417  return false;
1418  }
1419 
1420  auto *GroDecl = VarDecl::Create(
1421  S.Context, &FD, FD.getLocation(), FD.getLocation(),
1422  &S.PP.getIdentifierTable().get("__coro_gro"), GroType,
1423  S.Context.getTrivialTypeSourceInfo(GroType, Loc), SC_None);
1424 
1425  S.CheckVariableDeclarationType(GroDecl);
1426  if (GroDecl->isInvalidDecl())
1427  return false;
1428 
1430  ExprResult Res = S.PerformMoveOrCopyInitialization(Entity, nullptr, GroType,
1431  this->ReturnValue);
1432  if (Res.isInvalid())
1433  return false;
1434 
1435  Res = S.ActOnFinishFullExpr(Res.get());
1436  if (Res.isInvalid())
1437  return false;
1438 
1439  S.AddInitializerToDecl(GroDecl, Res.get(),
1440  /*DirectInit=*/false);
1441 
1442  S.FinalizeDeclaration(GroDecl);
1443 
1444  // Form a declaration statement for the return declaration, so that AST
1445  // visitors can more easily find it.
1446  StmtResult GroDeclStmt =
1447  S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(GroDecl), Loc, Loc);
1448  if (GroDeclStmt.isInvalid())
1449  return false;
1450 
1451  this->ResultDecl = GroDeclStmt.get();
1452 
1453  ExprResult declRef = S.BuildDeclRefExpr(GroDecl, GroType, VK_LValue, Loc);
1454  if (declRef.isInvalid())
1455  return false;
1456 
1457  StmtResult ReturnStmt = S.BuildReturnStmt(Loc, declRef.get());
1458  if (ReturnStmt.isInvalid()) {
1460  return false;
1461  }
1462  if (cast<clang::ReturnStmt>(ReturnStmt.get())->getNRVOCandidate() == GroDecl)
1463  GroDecl->setNRVOVariable(true);
1464 
1465  this->ReturnStmt = ReturnStmt.get();
1466  return true;
1467 }
1468 
1469 // Create a static_cast<T&&>(expr).
1471  if (T.isNull())
1472  T = E->getType();
1473  QualType TargetType = S.BuildReferenceType(
1474  T, /*SpelledAsLValue*/ false, SourceLocation(), DeclarationName());
1475  SourceLocation ExprLoc = E->getLocStart();
1476  TypeSourceInfo *TargetLoc =
1477  S.Context.getTrivialTypeSourceInfo(TargetType, ExprLoc);
1478 
1479  return S
1480  .BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
1481  SourceRange(ExprLoc, ExprLoc), E->getSourceRange())
1482  .get();
1483 }
1484 
1485 /// Build a variable declaration for move parameter.
1487  IdentifierInfo *II) {
1488  TypeSourceInfo *TInfo = S.Context.getTrivialTypeSourceInfo(Type, Loc);
1489  VarDecl *Decl = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, II, Type,
1490  TInfo, SC_None);
1491  Decl->setImplicit();
1492  return Decl;
1493 }
1494 
1495 // Build statements that move coroutine function parameters to the coroutine
1496 // frame, and store them on the function scope info.
1498  assert(isa<FunctionDecl>(CurContext) && "not in a function scope");
1499  auto *FD = cast<FunctionDecl>(CurContext);
1500 
1501  auto *ScopeInfo = getCurFunction();
1502  assert(ScopeInfo->CoroutineParameterMoves.empty() &&
1503  "Should not build parameter moves twice");
1504 
1505  for (auto *PD : FD->parameters()) {
1506  if (PD->getType()->isDependentType())
1507  continue;
1508 
1509  ExprResult PDRefExpr =
1510  BuildDeclRefExpr(PD, PD->getType().getNonReferenceType(),
1511  ExprValueKind::VK_LValue, Loc); // FIXME: scope?
1512  if (PDRefExpr.isInvalid())
1513  return false;
1514 
1515  Expr *CExpr = nullptr;
1516  if (PD->getType()->getAsCXXRecordDecl() ||
1517  PD->getType()->isRValueReferenceType())
1518  CExpr = castForMoving(*this, PDRefExpr.get());
1519  else
1520  CExpr = PDRefExpr.get();
1521 
1522  auto D = buildVarDecl(*this, Loc, PD->getType(), PD->getIdentifier());
1523  AddInitializerToDecl(D, CExpr, /*DirectInit=*/true);
1524 
1525  // Convert decl to a statement.
1526  StmtResult Stmt = ActOnDeclStmt(ConvertDeclToDeclGroup(D), Loc, Loc);
1527  if (Stmt.isInvalid())
1528  return false;
1529 
1530  ScopeInfo->CoroutineParameterMoves.insert(std::make_pair(PD, Stmt.get()));
1531  }
1532  return true;
1533 }
1534 
1536  CoroutineBodyStmt *Res = CoroutineBodyStmt::Create(Context, Args);
1537  if (!Res)
1538  return StmtError();
1539  return Res;
1540 }
NamespaceDecl * lookupStdExperimentalNamespace()
static Expr * buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc)
Look up the std::nothrow object.
static ExprResult buildMemberCall(Sema &S, Expr *Base, SourceLocation Loc, StringRef Name, MultiExprArg Args)
void setImplicit(bool I=true)
Definition: DeclBase.h:553
Represents a function declaration or definition.
Definition: Decl.h:1714
Represents a &#39;co_await&#39; expression while the type of the promise is dependent.
Definition: ExprCXX.h:4344
bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose=true)
NamespaceDecl * getStdNamespace() const
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:3726
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2375
A (possibly-)qualified type.
Definition: Type.h:655
static Expr * maybeTailCall(Sema &S, QualType RetType, Expr *E, SourceLocation Loc)
static VarDecl * buildVarDecl(Sema &S, SourceLocation Loc, QualType Type, IdentifierInfo *II)
Build a variable declaration for move parameter.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2993
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
static Expr * castForMoving(Sema &S, Expr *E, QualType T=QualType())
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2784
Represents a &#39;co_return&#39; statement in the C++ Coroutines TS.
Definition: StmtCXX.h:432
Stmt - This represents one statement.
Definition: Stmt.h:66
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:6263
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2739
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:805
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5998
The base class of the type hierarchy.
Definition: Type.h:1421
OpaqueValueExpr * OpaqueValue
StringRef getFirstCoroutineStmtKeyword() const
Definition: ScopeInfo.h:437
Represent a C++ namespace.
Definition: Decl.h:514
A container of type source information.
Definition: Decl.h:86
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:14243
std::pair< Stmt *, Stmt * > CoroutineSuspends
The initial and final coroutine suspend points.
Definition: ScopeInfo.h:195
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:96
This file provides some common utility functions for processing Lambda related AST Constructs...
Represents a variable declaration or definition.
Definition: Decl.h:812
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:268
bool isStructureType() const
Definition: Type.cpp:404
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:241
QualType getReturnType() const
Definition: Decl.h:2262
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6456
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E, bool IsImplicit=false)
bool isAmbiguous() const
Definition: Lookup.h:290
bool isInvalidDecl() const
Definition: DeclBase.h:547
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type, bool NRVO)
Create the initialization entity for the result of a function.
static bool diagReturnOnAllocFailure(Sema &S, Expr *E, CXXRecordDecl *PromiseRecordDecl, FunctionScopeInfo &Fn)
Defines the clang::Expr interface and subclasses for C++ expressions.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5282
llvm::SmallMapVector< ParmVarDecl *, Stmt *, 4 > CoroutineParameterMoves
A mapping between the coroutine function parameters that were moved to the coroutine frame...
Definition: ScopeInfo.h:192
bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose=true)
Finds the overloads of operator new and delete that are appropriate for the allocation.
One of these records is kept for each identifier that is lexed.
static ReadySuspendResumeResult buildCoawaitCalls(Sema &S, VarDecl *CoroPromise, SourceLocation Loc, Expr *E)
Build calls to await_ready, await_suspend, and await_resume for a co_await expression.
A C++ nested-name-specifier augmented with source location information.
ExprResult ExprEmpty()
Definition: Ownership.h:289
static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init)
Create an initialization from an initializer (which, for direct initialization from a parenthesized l...
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3612
bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, StringRef Keyword)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:54
static FunctionDecl * findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseType)
bool isReferenceType() const
Definition: Type.h:6061
IdentifierTable & Idents
Definition: ASTContext.h:538
SourceLocation FirstSEHTryLoc
First SEH &#39;__try&#39; statement in the current function.
Definition: ScopeInfo.h:173
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:110
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2222
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1604
Represents the results of name lookup.
Definition: Lookup.h:47
PtrTy get() const
Definition: Ownership.h:174
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, SourceLocation Loc, Expr *E, UnresolvedLookupExpr *Lookup)
Build a call to &#39;operator co_await&#39; if there is a suitable operator for the given expression...
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
StmtResult StmtError()
Definition: Ownership.h:284
Represents a declaration of a type.
Definition: Decl.h:2816
static ExprResult buildPromiseCall(Sema &S, VarDecl *Promise, SourceLocation Loc, StringRef Name, MultiExprArg Args)
static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD, SourceLocation KwLoc)
Look up the std::coroutine_traits<...>::promise_type for the given function type. ...
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5825
ExprResult ActOnCXXThis(SourceLocation loc)
void append(iterator I, iterator E)
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
void CheckVariableDeclarationType(VarDecl *NewVD)
Definition: SemaDecl.cpp:7293
Preprocessor & PP
Definition: Sema.h:317
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1898
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:7503
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3001
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2731
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:276
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
Definition: SemaStmt.cpp:73
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3369
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp)
Definition: SemaStmt.cpp:3470
StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E)
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:541
const char * getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Definition: Builtins.h:86
bool buildCoroutineParameterMoves(SourceLocation Loc)
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10616
Expr - This represents one expression.
Definition: Expr.h:106
int Id
Definition: ASTDiff.cpp:191
const FunctionProtoType * T
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6519
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs)
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
Defines the clang::Preprocessor interface.
DeclContext * getDeclContext()
Definition: DeclBase.h:426
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
Definition: SemaCast.cpp:240
static bool IsOverloaded(const UnresolvedSetImpl &Functions)
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
decls_iterator decls_begin() const
Definition: ExprCXX.h:2643
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7518
static bool isValidCoroutineContext(Sema &S, SourceLocation Loc, StringRef Keyword)
QualType getType() const
Definition: Expr.h:128
bool buildStatements()
Build the coroutine body statements, including the "promise dependent" statements when the promise ty...
static FunctionScopeInfo * checkCoroutineContext(Sema &S, SourceLocation Loc, StringRef Keyword, bool IsImplicit=false)
Check that this is a context in which a coroutine suspension can appear.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1433
static Expr * buildBuiltinCall(Sema &S, SourceLocation Loc, Builtin::ID Id, MultiExprArg CallArgs)
bool isInvalid() const
Definition: Ownership.h:170
bool isUsable() const
Definition: Ownership.h:171
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1369
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
VarDecl * CoroutinePromise
The promise object for this coroutine, if any.
Definition: ScopeInfo.h:188
ExprResult ActOnFinishFullExpr(Expr *Expr)
Definition: Sema.h:5301
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:412
static CoroutineBodyStmt * Create(const ASTContext &C, CtorArgs const &Args)
Definition: StmtCXX.cpp:90
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:875
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3302
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:11603
FunctionDecl * FindUsualDeallocationFunction(SourceLocation StartLoc, bool CanProvideSize, bool Overaligned, DeclarationName Name)
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType, SourceLocation Loc)
Look up the std::experimental::coroutine_handle<PromiseType>.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2031
Only look for allocation functions in the scope of the allocated class.
Definition: Sema.h:5181
ArrayRef< Stmt * > ParamMoves
Definition: StmtCXX.h:342
Describes the kind of initialization being performed, along with location information for tokens rela...
SourceLocation FirstCoroutineStmtLoc
First coroutine statement in the current function.
Definition: ScopeInfo.h:164
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1977
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1380
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:586
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
Definition: Type.h:6250
Represents a template argument.
Definition: TemplateBase.h:51
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1247
void clearDelayedTypo(TypoExpr *TE)
Clears the state of the given TypoExpr.
CoroutineStmtBuilder(Sema &S, FunctionDecl &FD, sema::FunctionScopeInfo &Fn, Stmt *Body)
Construct a CoroutineStmtBuilder and initialize the promise statement and initial/final suspends from...
Represents a &#39;co_yield&#39; expression.
Definition: ExprCXX.h:4391
DeclarationName - The name of a declaration.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:506
bool isBooleanType() const
Definition: Type.h:6383
A set of unresolved declarations.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:738
ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E, UnresolvedLookupExpr *Lookup)
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1338
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:10597
static ExprResult buildCoroutineHandle(Sema &S, QualType PromiseType, SourceLocation Loc)
SourceLocation FirstReturnLoc
First &#39;return&#39; statement in the current function.
Definition: ScopeInfo.h:167
Decl * getCalleeDecl()
Definition: Expr.cpp:1251
StmtResult ActOnFinishFullStmt(Stmt *Stmt)
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Lookup.h:320
Represents the body of a coroutine.
Definition: StmtCXX.h:299
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E)
Look for allocation functions in both the global scope and in the scope of the allocated class...
Definition: Sema.h:5184
CanQualType DependentTy
Definition: ASTContext.h:1026
Represents a &#39;co_await&#39; expression.
Definition: ExprCXX.h:4308
static ExprResult buildOperatorCoawaitLookupExpr(Sema &SemaRef, Scope *S, SourceLocation Loc)
ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E)
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:12541
ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E)
bool isClassType() const
Definition: Type.cpp:398
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Call-style initialization (C++98)
Definition: Decl.h:820
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const VarDecl *NRVOCandidate, QualType ResultType, Expr *Value, bool AllowNRVO=true)
Perform the initialization of a potentially-movable value, which is the result of return value...
Definition: SemaStmt.cpp:3029
ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:1643
Describes the sequence of initializations required to initialize a given object or reference with a s...
Only look for allocation functions in the global scope.
Definition: Sema.h:5178
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6276
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1320
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:540
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:330
Declaration of a class template.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:266
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2283
ExprResult ExprError()
Definition: Ownership.h:283
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1930
bool hasInvalidCoroutineSuspends() const
Definition: ScopeInfo.h:455
void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body)
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:572
ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E, bool IsImplicit=false)
bool buildDependentStatements()
Build the coroutine body statements that require a non-dependent promise type in order to construct...
QualType getType() const
Definition: Decl.h:647
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:318
This represents a decl that may have a name.
Definition: Decl.h:248
No keyword precedes the qualified type name.
Definition: Type.h:4823
Describes an entity that is being initialized.
Look up of an operator name (e.g., operator+) for use with operator overloading.
Definition: Sema.h:3005
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:513
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:278
decls_iterator decls_end() const
Definition: ExprCXX.h:2644
static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD, SourceLocation Loc, bool &Res)
SourceLocation getLocation() const
Definition: DeclBase.h:417
LangStandard::Kind Std
VarDecl * buildCoroutinePromise(SourceLocation Loc)
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
static void noteMemberDeclaredHere(Sema &S, Expr *E, FunctionScopeInfo &Fn)