| 1 |
//===-- SemaCoroutine.cpp - Semantic Analysis for Coroutines --------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file implements semantic analysis for C++ Coroutines. |
| 10 |
// |
| 11 |
// This file contains references to sections of the Coroutines TS, which |
| 12 |
// can be found at http://wg21.link/coroutines. |
| 13 |
// |
| 14 |
//===----------------------------------------------------------------------===// |
| 15 |
|
| 16 |
#include "CoroutineStmtBuilder.h" |
| 17 |
#include "clang/AST/ASTLambda.h" |
| 18 |
#include "clang/AST/Decl.h" |
| 19 |
#include "clang/AST/ExprCXX.h" |
| 20 |
#include "clang/AST/StmtCXX.h" |
| 21 |
#include "clang/Basic/Builtins.h" |
| 22 |
#include "clang/Lex/Preprocessor.h" |
| 23 |
#include "clang/Sema/Initialization.h" |
| 24 |
#include "clang/Sema/Overload.h" |
| 25 |
#include "clang/Sema/ScopeInfo.h" |
| 26 |
#include "clang/Sema/SemaInternal.h" |
| 27 |
#include "llvm/ADT/SmallSet.h" |
| 28 |
|
| 29 |
using namespace clang; |
| 30 |
using namespace sema; |
| 31 |
|
| 32 |
static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD, |
| 33 |
SourceLocation Loc, bool &Res) { |
| 34 |
DeclarationName DN = S.PP.getIdentifierInfo(Name); |
| 35 |
LookupResult LR(S, DN, Loc, Sema::LookupMemberName); |
| 36 |
// Suppress diagnostics when a private member is selected. The same warnings |
| 37 |
// will be produced again when building the call. |
| 38 |
LR.suppressDiagnostics(); |
| 39 |
Res = S.LookupQualifiedName(LR, RD); |
| 40 |
return LR; |
| 41 |
} |
| 42 |
|
| 43 |
static bool lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD, |
| 44 |
SourceLocation Loc) { |
| 45 |
bool Res; |
| 46 |
lookupMember(S, Name, RD, Loc, Res); |
| 47 |
return Res; |
| 48 |
} |
| 49 |
|
| 50 |
/// Look up the std::coroutine_traits<...>::promise_type for the given |
| 51 |
/// function type. |
| 52 |
static QualType lookupPromiseType(Sema &S, const FunctionDecl *FD, |
| 53 |
SourceLocation KwLoc) { |
| 54 |
const FunctionProtoType *FnType = FD->getType()->castAs<FunctionProtoType>(); |
| 55 |
const SourceLocation FuncLoc = FD->getLocation(); |
| 56 |
|
| 57 |
NamespaceDecl *CoroNamespace = nullptr; |
| 58 |
ClassTemplateDecl *CoroTraits = |
| 59 |
S.lookupCoroutineTraits(KwLoc, FuncLoc, CoroNamespace); |
| 60 |
if (!CoroTraits) { |
| 61 |
return QualType(); |
| 62 |
} |
| 63 |
|
| 64 |
// Form template argument list for coroutine_traits<R, P1, P2, ...> according |
| 65 |
// to [dcl.fct.def.coroutine]3 |
| 66 |
TemplateArgumentListInfo Args(KwLoc, KwLoc); |
| 67 |
auto AddArg = [&](QualType T) { |
| 68 |
Args.addArgument(TemplateArgumentLoc( |
| 69 |
TemplateArgument(T), S.Context.getTrivialTypeSourceInfo(T, KwLoc))); |
| 70 |
}; |
| 71 |
AddArg(FnType->getReturnType()); |
| 72 |
// If the function is a non-static member function, add the type |
| 73 |
// of the implicit object parameter before the formal parameters. |
| 74 |
if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) { |
| 75 |
if (MD->isInstance()) { |
| 76 |
// [over.match.funcs]4 |
| 77 |
// For non-static member functions, the type of the implicit object |
| 78 |
// parameter is |
| 79 |
// -- "lvalue reference to cv X" for functions declared without a |
| 80 |
// ref-qualifier or with the & ref-qualifier |
| 81 |
// -- "rvalue reference to cv X" for functions declared with the && |
| 82 |
// ref-qualifier |
| 83 |
QualType T = MD->getThisType()->castAs<PointerType>()->getPointeeType(); |
| 84 |
T = FnType->getRefQualifier() == RQ_RValue |
| 85 |
? S.Context.getRValueReferenceType(T) |
| 86 |
: S.Context.getLValueReferenceType(T, /*SpelledAsLValue*/ true); |
| 87 |
AddArg(T); |
| 88 |
} |
| 89 |
} |
| 90 |
for (QualType T : FnType->getParamTypes()) |
| 91 |
AddArg(T); |
| 92 |
|
| 93 |
// Build the template-id. |
| 94 |
QualType CoroTrait = |
| 95 |
S.CheckTemplateIdType(TemplateName(CoroTraits), KwLoc, Args); |
| 96 |
if (CoroTrait.isNull()) |
| 97 |
return QualType(); |
| 98 |
if (S.RequireCompleteType(KwLoc, CoroTrait, |
| 99 |
diag::err_coroutine_type_missing_specialization)) |
| 100 |
return QualType(); |
| 101 |
|
| 102 |
auto *RD = CoroTrait->getAsCXXRecordDecl(); |
| 103 |
assert(RD && "specialization of class template is not a class?"); |
| 104 |
|
| 105 |
// Look up the ::promise_type member. |
| 106 |
LookupResult R(S, &S.PP.getIdentifierTable().get("promise_type"), KwLoc, |
| 107 |
Sema::LookupOrdinaryName); |
| 108 |
S.LookupQualifiedName(R, RD); |
| 109 |
auto *Promise = R.getAsSingle<TypeDecl>(); |
| 110 |
if (!Promise) { |
| 111 |
S.Diag(FuncLoc, |
| 112 |
diag::err_implied_std_coroutine_traits_promise_type_not_found) |
| 113 |
<< RD; |
| 114 |
return QualType(); |
| 115 |
} |
| 116 |
// The promise type is required to be a class type. |
| 117 |
QualType PromiseType = S.Context.getTypeDeclType(Promise); |
| 118 |
|
| 119 |
auto buildElaboratedType = [&]() { |
| 120 |
auto *NNS = NestedNameSpecifier::Create(S.Context, nullptr, CoroNamespace); |
| 121 |
NNS = NestedNameSpecifier::Create(S.Context, NNS, false, |
| 122 |
CoroTrait.getTypePtr()); |
| 123 |
return S.Context.getElaboratedType(ETK_None, NNS, PromiseType); |
| 124 |
}; |
| 125 |
|
| 126 |
if (!PromiseType->getAsCXXRecordDecl()) { |
| 127 |
S.Diag(FuncLoc, |
| 128 |
diag::err_implied_std_coroutine_traits_promise_type_not_class) |
| 129 |
<< buildElaboratedType(); |
| 130 |
return QualType(); |
| 131 |
} |
| 132 |
if (S.RequireCompleteType(FuncLoc, buildElaboratedType(), |
| 133 |
diag::err_coroutine_promise_type_incomplete)) |
| 134 |
return QualType(); |
| 135 |
|
| 136 |
return PromiseType; |
| 137 |
} |
| 138 |
|
| 139 |
/// Look up the std::coroutine_handle<PromiseType>. |
| 140 |
static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType, |
| 141 |
SourceLocation Loc) { |
| 142 |
if (PromiseType.isNull()) |
| 143 |
return QualType(); |
| 144 |
|
| 145 |
NamespaceDecl *CoroNamespace = S.getCachedCoroNamespace(); |
| 146 |
assert(CoroNamespace && "Should already be diagnosed"); |
| 147 |
|
| 148 |
LookupResult Result(S, &S.PP.getIdentifierTable().get("coroutine_handle"), |
| 149 |
Loc, Sema::LookupOrdinaryName); |
| 150 |
if (!S.LookupQualifiedName(Result, CoroNamespace)) { |
| 151 |
S.Diag(Loc, diag::err_implied_coroutine_type_not_found) |
| 152 |
<< "std::coroutine_handle"; |
| 153 |
return QualType(); |
| 154 |
} |
| 155 |
|
| 156 |
ClassTemplateDecl *CoroHandle = Result.getAsSingle<ClassTemplateDecl>(); |
| 157 |
if (!CoroHandle) { |
| 158 |
Result.suppressDiagnostics(); |
| 159 |
// We found something weird. Complain about the first thing we found. |
| 160 |
NamedDecl *Found = *Result.begin(); |
| 161 |
S.Diag(Found->getLocation(), diag::err_malformed_std_coroutine_handle); |
| 162 |
return QualType(); |
| 163 |
} |
| 164 |
|
| 165 |
// Form template argument list for coroutine_handle<Promise>. |
| 166 |
TemplateArgumentListInfo Args(Loc, Loc); |
| 167 |
Args.addArgument(TemplateArgumentLoc( |
| 168 |
TemplateArgument(PromiseType), |
| 169 |
S.Context.getTrivialTypeSourceInfo(PromiseType, Loc))); |
| 170 |
|
| 171 |
// Build the template-id. |
| 172 |
QualType CoroHandleType = |
| 173 |
S.CheckTemplateIdType(TemplateName(CoroHandle), Loc, Args); |
| 174 |
if (CoroHandleType.isNull()) |
| 175 |
return QualType(); |
| 176 |
if (S.RequireCompleteType(Loc, CoroHandleType, |
| 177 |
diag::err_coroutine_type_missing_specialization)) |
| 178 |
return QualType(); |
| 179 |
|
| 180 |
return CoroHandleType; |
| 181 |
} |
| 182 |
|
| 183 |
static bool isValidCoroutineContext(Sema &S, SourceLocation Loc, |
| 184 |
StringRef Keyword) { |
| 185 |
// [expr.await]p2 dictates that 'co_await' and 'co_yield' must be used within |
| 186 |
// a function body. |
| 187 |
// FIXME: This also covers [expr.await]p2: "An await-expression shall not |
| 188 |
// appear in a default argument." But the diagnostic QoI here could be |
| 189 |
// improved to inform the user that default arguments specifically are not |
| 190 |
// allowed. |
| 191 |
auto *FD = dyn_cast<FunctionDecl>(S.CurContext); |
| 192 |
if (!FD) { |
| 193 |
S.Diag(Loc, isa<ObjCMethodDecl>(S.CurContext) |
| 194 |
? diag::err_coroutine_objc_method |
| 195 |
: diag::err_coroutine_outside_function) << Keyword; |
| 196 |
return false; |
| 197 |
} |
| 198 |
|
| 199 |
// An enumeration for mapping the diagnostic type to the correct diagnostic |
| 200 |
// selection index. |
| 201 |
enum InvalidFuncDiag { |
| 202 |
DiagCtor = 0, |
| 203 |
DiagDtor, |
| 204 |
DiagMain, |
| 205 |
DiagConstexpr, |
| 206 |
DiagAutoRet, |
| 207 |
DiagVarargs, |
| 208 |
DiagConsteval, |
| 209 |
}; |
| 210 |
bool Diagnosed = false; |
| 211 |
auto DiagInvalid = [&](InvalidFuncDiag ID) { |
| 212 |
S.Diag(Loc, diag::err_coroutine_invalid_func_context) << ID << Keyword; |
| 213 |
Diagnosed = true; |
| 214 |
return false; |
| 215 |
}; |
| 216 |
|
| 217 |
// Diagnose when a constructor, destructor |
| 218 |
// or the function 'main' are declared as a coroutine. |
| 219 |
auto *MD = dyn_cast<CXXMethodDecl>(FD); |
| 220 |
// [class.ctor]p11: "A constructor shall not be a coroutine." |
| 221 |
if (MD && isa<CXXConstructorDecl>(MD)) |
| 222 |
return DiagInvalid(DiagCtor); |
| 223 |
// [class.dtor]p17: "A destructor shall not be a coroutine." |
| 224 |
else if (MD && isa<CXXDestructorDecl>(MD)) |
| 225 |
return DiagInvalid(DiagDtor); |
| 226 |
// [basic.start.main]p3: "The function main shall not be a coroutine." |
| 227 |
else if (FD->isMain()) |
| 228 |
return DiagInvalid(DiagMain); |
| 229 |
|
| 230 |
// Emit a diagnostics for each of the following conditions which is not met. |
| 231 |
// [expr.const]p2: "An expression e is a core constant expression unless the |
| 232 |
// evaluation of e [...] would evaluate one of the following expressions: |
| 233 |
// [...] an await-expression [...] a yield-expression." |
| 234 |
if (FD->isConstexpr()) |
| 235 |
DiagInvalid(FD->isConsteval() ? DiagConsteval : DiagConstexpr); |
| 236 |
// [dcl.spec.auto]p15: "A function declared with a return type that uses a |
| 237 |
// placeholder type shall not be a coroutine." |
| 238 |
if (FD->getReturnType()->isUndeducedType()) |
| 239 |
DiagInvalid(DiagAutoRet); |
| 240 |
// [dcl.fct.def.coroutine]p1 |
| 241 |
// The parameter-declaration-clause of the coroutine shall not terminate with |
| 242 |
// an ellipsis that is not part of a parameter-declaration. |
| 243 |
if (FD->isVariadic()) |
| 244 |
DiagInvalid(DiagVarargs); |
| 245 |
|
| 246 |
return !Diagnosed; |
| 247 |
} |
| 248 |
|
| 249 |
/// Build a call to 'operator co_await' if there is a suitable operator for |
| 250 |
/// the given expression. |
| 251 |
ExprResult Sema::BuildOperatorCoawaitCall(SourceLocation Loc, Expr *E, |
| 252 |
UnresolvedLookupExpr *Lookup) { |
| 253 |
UnresolvedSet<16> Functions; |
| 254 |
Functions.append(Lookup->decls_begin(), Lookup->decls_end()); |
| 255 |
return CreateOverloadedUnaryOp(Loc, UO_Coawait, Functions, E); |
| 256 |
} |
| 257 |
|
| 258 |
static ExprResult buildOperatorCoawaitCall(Sema &SemaRef, Scope *S, |
| 259 |
SourceLocation Loc, Expr *E) { |
| 260 |
ExprResult R = SemaRef.BuildOperatorCoawaitLookupExpr(S, Loc); |
| 261 |
if (R.isInvalid()) |
| 262 |
return ExprError(); |
| 263 |
return SemaRef.BuildOperatorCoawaitCall(Loc, E, |
| 264 |
cast<UnresolvedLookupExpr>(R.get())); |
| 265 |
} |
| 266 |
|
| 267 |
static ExprResult buildCoroutineHandle(Sema &S, QualType PromiseType, |
| 268 |
SourceLocation Loc) { |
| 269 |
QualType CoroHandleType = lookupCoroutineHandleType(S, PromiseType, Loc); |
| 270 |
if (CoroHandleType.isNull()) |
| 271 |
return ExprError(); |
| 272 |
|
| 273 |
DeclContext *LookupCtx = S.computeDeclContext(CoroHandleType); |
| 274 |
LookupResult Found(S, &S.PP.getIdentifierTable().get("from_address"), Loc, |
| 275 |
Sema::LookupOrdinaryName); |
| 276 |
if (!S.LookupQualifiedName(Found, LookupCtx)) { |
| 277 |
S.Diag(Loc, diag::err_coroutine_handle_missing_member) |
| 278 |
<< "from_address"; |
| 279 |
return ExprError(); |
| 280 |
} |
| 281 |
|
| 282 |
Expr *FramePtr = |
| 283 |
S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_frame, {}); |
| 284 |
|
| 285 |
CXXScopeSpec SS; |
| 286 |
ExprResult FromAddr = |
| 287 |
S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false); |
| 288 |
if (FromAddr.isInvalid()) |
| 289 |
return ExprError(); |
| 290 |
|
| 291 |
return S.BuildCallExpr(nullptr, FromAddr.get(), Loc, FramePtr, Loc); |
| 292 |
} |
| 293 |
|
| 294 |
struct ReadySuspendResumeResult { |
| 295 |
enum AwaitCallType { ACT_Ready, ACT_Suspend, ACT_Resume }; |
| 296 |
Expr *Results[3]; |
| 297 |
OpaqueValueExpr *OpaqueValue; |
| 298 |
bool IsInvalid; |
| 299 |
}; |
| 300 |
|
| 301 |
static ExprResult buildMemberCall(Sema &S, Expr *Base, SourceLocation Loc, |
| 302 |
StringRef Name, MultiExprArg Args) { |
| 303 |
DeclarationNameInfo NameInfo(&S.PP.getIdentifierTable().get(Name), Loc); |
| 304 |
|
| 305 |
// FIXME: Fix BuildMemberReferenceExpr to take a const CXXScopeSpec&. |
| 306 |
CXXScopeSpec SS; |
| 307 |
ExprResult Result = S.BuildMemberReferenceExpr( |
| 308 |
Base, Base->getType(), Loc, /*IsPtr=*/false, SS, |
| 309 |
SourceLocation(), nullptr, NameInfo, /*TemplateArgs=*/nullptr, |
| 310 |
/*Scope=*/nullptr); |
| 311 |
if (Result.isInvalid()) |
| 312 |
return ExprError(); |
| 313 |
|
| 314 |
// We meant exactly what we asked for. No need for typo correction. |
| 315 |
if (auto *TE = dyn_cast<TypoExpr>(Result.get())) { |
| 316 |
S.clearDelayedTypo(TE); |
| 317 |
S.Diag(Loc, diag::err_no_member) |
| 318 |
<< NameInfo.getName() << Base->getType()->getAsCXXRecordDecl() |
| 319 |
<< Base->getSourceRange(); |
| 320 |
return ExprError(); |
| 321 |
} |
| 322 |
|
| 323 |
return S.BuildCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr); |
| 324 |
} |
| 325 |
|
| 326 |
// See if return type is coroutine-handle and if so, invoke builtin coro-resume |
| 327 |
// on its address. This is to enable experimental support for coroutine-handle |
| 328 |
// returning await_suspend that results in a guaranteed tail call to the target |
| 329 |
// coroutine. |
| 330 |
static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E, |
| 331 |
SourceLocation Loc) { |
| 332 |
if (RetType->isReferenceType()) |
| 333 |
return nullptr; |
| 334 |
Type const *T = RetType.getTypePtr(); |
| 335 |
if (!T->isClassType() && !T->isStructureType()) |
| 336 |
return nullptr; |
| 337 |
|
| 338 |
// FIXME: Add convertability check to coroutine_handle<>. Possibly via |
| 339 |
// EvaluateBinaryTypeTrait(BTT_IsConvertible, ...) which is at the moment |
| 340 |
// a private function in SemaExprCXX.cpp |
| 341 |
|
| 342 |
ExprResult AddressExpr = buildMemberCall(S, E, Loc, "address", std::nullopt); |
| 343 |
if (AddressExpr.isInvalid()) |
| 344 |
return nullptr; |
| 345 |
|
| 346 |
Expr *JustAddress = AddressExpr.get(); |
| 347 |
|
| 348 |
// Check that the type of AddressExpr is void* |
| 349 |
if (!JustAddress->getType().getTypePtr()->isVoidPointerType()) |
| 350 |
S.Diag(cast<CallExpr>(JustAddress)->getCalleeDecl()->getLocation(), |
| 351 |
diag::warn_coroutine_handle_address_invalid_return_type) |
| 352 |
<< JustAddress->getType(); |
| 353 |
|
| 354 |
// Clean up temporary objects so that they don't live across suspension points |
| 355 |
// unnecessarily. We choose to clean up before the call to |
| 356 |
// __builtin_coro_resume so that the cleanup code are not inserted in-between |
| 357 |
// the resume call and return instruction, which would interfere with the |
| 358 |
// musttail call contract. |
| 359 |
JustAddress = S.MaybeCreateExprWithCleanups(JustAddress); |
| 360 |
return S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_resume, |
| 361 |
JustAddress); |
| 362 |
} |
| 363 |
|
| 364 |
/// Build calls to await_ready, await_suspend, and await_resume for a co_await |
| 365 |
/// expression. |
| 366 |
/// The generated AST tries to clean up temporary objects as early as |
| 367 |
/// possible so that they don't live across suspension points if possible. |
| 368 |
/// Having temporary objects living across suspension points unnecessarily can |
| 369 |
/// lead to large frame size, and also lead to memory corruptions if the |
| 370 |
/// coroutine frame is destroyed after coming back from suspension. This is done |
| 371 |
/// by wrapping both the await_ready call and the await_suspend call with |
| 372 |
/// ExprWithCleanups. In the end of this function, we also need to explicitly |
| 373 |
/// set cleanup state so that the CoawaitExpr is also wrapped with an |
| 374 |
/// ExprWithCleanups to clean up the awaiter associated with the co_await |
| 375 |
/// expression. |
| 376 |
static ReadySuspendResumeResult buildCoawaitCalls(Sema &S, VarDecl *CoroPromise, |
| 377 |
SourceLocation Loc, Expr *E) { |
| 378 |
OpaqueValueExpr *Operand = new (S.Context) |
| 379 |
OpaqueValueExpr(Loc, E->getType(), VK_LValue, E->getObjectKind(), E); |
| 380 |
|
| 381 |
// Assume valid until we see otherwise. |
| 382 |
// Further operations are responsible for setting IsInalid to true. |
| 383 |
ReadySuspendResumeResult Calls = {{}, Operand, /*IsInvalid=*/false}; |
| 384 |
|
| 385 |
using ACT = ReadySuspendResumeResult::AwaitCallType; |
| 386 |
|
| 387 |
auto BuildSubExpr = [&](ACT CallType, StringRef Func, |
| 388 |
MultiExprArg Arg) -> Expr * { |
| 389 |
ExprResult Result = buildMemberCall(S, Operand, Loc, Func, Arg); |
| 390 |
if (Result.isInvalid()) { |
| 391 |
Calls.IsInvalid = true; |
| 392 |
return nullptr; |
| 393 |
} |
| 394 |
Calls.Results[CallType] = Result.get(); |
| 395 |
return Result.get(); |
| 396 |
}; |
| 397 |
|
| 398 |
CallExpr *AwaitReady = cast_or_null<CallExpr>( |
| 399 |
BuildSubExpr(ACT::ACT_Ready, "await_ready", std::nullopt)); |
| 400 |
if (!AwaitReady) |
| 401 |
return Calls; |
| 402 |
if (!AwaitReady->getType()->isDependentType()) { |
| 403 |
// [expr.await]p3 [...] |
| 404 |
// — await-ready is the expression e.await_ready(), contextually converted |
| 405 |
// to bool. |
| 406 |
ExprResult Conv = S.PerformContextuallyConvertToBool(AwaitReady); |
| 407 |
if (Conv.isInvalid()) { |
| 408 |
S.Diag(AwaitReady->getDirectCallee()->getBeginLoc(), |
| 409 |
diag::note_await_ready_no_bool_conversion); |
| 410 |
S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required) |
| 411 |
<< AwaitReady->getDirectCallee() << E->getSourceRange(); |
| 412 |
Calls.IsInvalid = true; |
| 413 |
} else |
| 414 |
Calls.Results[ACT::ACT_Ready] = S.MaybeCreateExprWithCleanups(Conv.get()); |
| 415 |
} |
| 416 |
|
| 417 |
ExprResult CoroHandleRes = |
| 418 |
buildCoroutineHandle(S, CoroPromise->getType(), Loc); |
| 419 |
if (CoroHandleRes.isInvalid()) { |
| 420 |
Calls.IsInvalid = true; |
| 421 |
return Calls; |
| 422 |
} |
| 423 |
Expr *CoroHandle = CoroHandleRes.get(); |
| 424 |
CallExpr *AwaitSuspend = cast_or_null<CallExpr>( |
| 425 |
BuildSubExpr(ACT::ACT_Suspend, "await_suspend", CoroHandle)); |
| 426 |
if (!AwaitSuspend) |
| 427 |
return Calls; |
| 428 |
if (!AwaitSuspend->getType()->isDependentType()) { |
| 429 |
// [expr.await]p3 [...] |
| 430 |
// - await-suspend is the expression e.await_suspend(h), which shall be |
| 431 |
// a prvalue of type void, bool, or std::coroutine_handle<Z> for some |
| 432 |
// type Z. |
| 433 |
QualType RetType = AwaitSuspend->getCallReturnType(S.Context); |
| 434 |
|
| 435 |
// Experimental support for coroutine_handle returning await_suspend. |
| 436 |
if (Expr *TailCallSuspend = |
| 437 |
maybeTailCall(S, RetType, AwaitSuspend, Loc)) |
| 438 |
// Note that we don't wrap the expression with ExprWithCleanups here |
| 439 |
// because that might interfere with tailcall contract (e.g. inserting |
| 440 |
// clean up instructions in-between tailcall and return). Instead |
| 441 |
// ExprWithCleanups is wrapped within maybeTailCall() prior to the resume |
| 442 |
// call. |
| 443 |
Calls.Results[ACT::ACT_Suspend] = TailCallSuspend; |
| 444 |
else { |
| 445 |
// non-class prvalues always have cv-unqualified types |
| 446 |
if (RetType->isReferenceType() || |
| 447 |
(!RetType->isBooleanType() && !RetType->isVoidType())) { |
| 448 |
S.Diag(AwaitSuspend->getCalleeDecl()->getLocation(), |
| 449 |
diag::err_await_suspend_invalid_return_type) |
| 450 |
<< RetType; |
| 451 |
S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required) |
| 452 |
<< AwaitSuspend->getDirectCallee(); |
| 453 |
Calls.IsInvalid = true; |
| 454 |
} else |
| 455 |
Calls.Results[ACT::ACT_Suspend] = |
| 456 |
S.MaybeCreateExprWithCleanups(AwaitSuspend); |
| 457 |
} |
| 458 |
} |
| 459 |
|
| 460 |
BuildSubExpr(ACT::ACT_Resume, "await_resume", std::nullopt); |
| 461 |
|
| 462 |
// Make sure the awaiter object gets a chance to be cleaned up. |
| 463 |
S.Cleanup.setExprNeedsCleanups(true); |
| 464 |
|
| 465 |
return Calls; |
| 466 |
} |
| 467 |
|
| 468 |
static ExprResult buildPromiseCall(Sema &S, VarDecl *Promise, |
| 469 |
SourceLocation Loc, StringRef Name, |
| 470 |
MultiExprArg Args) { |
| 471 |
|
| 472 |
// Form a reference to the promise. |
| 473 |
ExprResult PromiseRef = S.BuildDeclRefExpr( |
| 474 |
Promise, Promise->getType().getNonReferenceType(), VK_LValue, Loc); |
| 475 |
if (PromiseRef.isInvalid()) |
| 476 |
return ExprError(); |
| 477 |
|
| 478 |
return buildMemberCall(S, PromiseRef.get(), Loc, Name, Args); |
| 479 |
} |
| 480 |
|
| 481 |
VarDecl *Sema::buildCoroutinePromise(SourceLocation Loc) { |
| 482 |
assert(isa<FunctionDecl>(CurContext) && "not in a function scope"); |
| 483 |
auto *FD = cast<FunctionDecl>(CurContext); |
| 484 |
bool IsThisDependentType = [&] { |
| 485 |
if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD)) |
| 486 |
return MD->isInstance() && MD->getThisType()->isDependentType(); |
| 487 |
else |
| 488 |
return false; |
| 489 |
}(); |
| 490 |
|
| 491 |
QualType T = FD->getType()->isDependentType() || IsThisDependentType |
| 492 |
? Context.DependentTy |
| 493 |
: lookupPromiseType(*this, FD, Loc); |
| 494 |
if (T.isNull()) |
| 495 |
return nullptr; |
| 496 |
|
| 497 |
auto *VD = VarDecl::Create(Context, FD, FD->getLocation(), FD->getLocation(), |
| 498 |
&PP.getIdentifierTable().get("__promise"), T, |
| 499 |
Context.getTrivialTypeSourceInfo(T, Loc), SC_None); |
| 500 |
VD->setImplicit(); |
| 501 |
CheckVariableDeclarationType(VD); |
| 502 |
if (VD->isInvalidDecl()) |
| 503 |
return nullptr; |
| 504 |
|
| 505 |
auto *ScopeInfo = getCurFunction(); |
| 506 |
|
| 507 |
// Build a list of arguments, based on the coroutine function's arguments, |
| 508 |
// that if present will be passed to the promise type's constructor. |
| 509 |
llvm::SmallVector<Expr *, 4> CtorArgExprs; |
| 510 |
|
| 511 |
// Add implicit object parameter. |
| 512 |
if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) { |
| 513 |
if (MD->isInstance() && !isLambdaCallOperator(MD)) { |
| 514 |
ExprResult ThisExpr = ActOnCXXThis(Loc); |
| 515 |
if (ThisExpr.isInvalid()) |
| 516 |
return nullptr; |
| 517 |
ThisExpr = CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get()); |
| 518 |
if (ThisExpr.isInvalid()) |
| 519 |
return nullptr; |
| 520 |
CtorArgExprs.push_back(ThisExpr.get()); |
| 521 |
} |
| 522 |
} |
| 523 |
|
| 524 |
// Add the coroutine function's parameters. |
| 525 |
auto &Moves = ScopeInfo->CoroutineParameterMoves; |
| 526 |
for (auto *PD : FD->parameters()) { |
| 527 |
if (PD->getType()->isDependentType()) |
| 528 |
continue; |
| 529 |
|
| 530 |
auto RefExpr = ExprEmpty(); |
| 531 |
auto Move = Moves.find(PD); |
| 532 |
assert(Move != Moves.end() && |
| 533 |
"Coroutine function parameter not inserted into move map"); |
| 534 |
// If a reference to the function parameter exists in the coroutine |
| 535 |
// frame, use that reference. |
| 536 |
auto *MoveDecl = |
| 537 |
cast<VarDecl>(cast<DeclStmt>(Move->second)->getSingleDecl()); |
| 538 |
RefExpr = |
| 539 |
BuildDeclRefExpr(MoveDecl, MoveDecl->getType().getNonReferenceType(), |
| 540 |
ExprValueKind::VK_LValue, FD->getLocation()); |
| 541 |
if (RefExpr.isInvalid()) |
| 542 |
return nullptr; |
| 543 |
CtorArgExprs.push_back(RefExpr.get()); |
| 544 |
} |
| 545 |
|
| 546 |
// If we have a non-zero number of constructor arguments, try to use them. |
| 547 |
// Otherwise, fall back to the promise type's default constructor. |
| 548 |
if (!CtorArgExprs.empty()) { |
| 549 |
// Create an initialization sequence for the promise type using the |
| 550 |
// constructor arguments, wrapped in a parenthesized list expression. |
| 551 |
Expr *PLE = ParenListExpr::Create(Context, FD->getLocation(), |
| 552 |
CtorArgExprs, FD->getLocation()); |
| 553 |
InitializedEntity Entity = InitializedEntity::InitializeVariable(VD); |
| 554 |
InitializationKind Kind = InitializationKind::CreateForInit( |
| 555 |
VD->getLocation(), /*DirectInit=*/true, PLE); |
| 556 |
InitializationSequence InitSeq(*this, Entity, Kind, CtorArgExprs, |
| 557 |
/*TopLevelOfInitList=*/false, |
| 558 |
/*TreatUnavailableAsInvalid=*/false); |
| 559 |
|
| 560 |
// [dcl.fct.def.coroutine]5.7 |
| 561 |
// promise-constructor-arguments is determined as follows: overload |
| 562 |
// resolution is performed on a promise constructor call created by |
| 563 |
// assembling an argument list q_1 ... q_n . If a viable constructor is |
| 564 |
// found ([over.match.viable]), then promise-constructor-arguments is ( q_1 |
| 565 |
// , ..., q_n ), otherwise promise-constructor-arguments is empty. |
| 566 |
if (InitSeq) { |
| 567 |
ExprResult Result = InitSeq.Perform(*this, Entity, Kind, CtorArgExprs); |
| 568 |
if (Result.isInvalid()) { |
| 569 |
VD->setInvalidDecl(); |
| 570 |
} else if (Result.get()) { |
| 571 |
VD->setInit(MaybeCreateExprWithCleanups(Result.get())); |
| 572 |
VD->setInitStyle(VarDecl::CallInit); |
| 573 |
CheckCompleteVariableDeclaration(VD); |
| 574 |
} |
| 575 |
} else |
| 576 |
ActOnUninitializedDecl(VD); |
| 577 |
} else |
| 578 |
ActOnUninitializedDecl(VD); |
| 579 |
|
| 580 |
FD->addDecl(VD); |
| 581 |
return VD; |
| 582 |
} |
| 583 |
|
| 584 |
/// Check that this is a context in which a coroutine suspension can appear. |
| 585 |
static FunctionScopeInfo *checkCoroutineContext(Sema &S, SourceLocation Loc, |
| 586 |
StringRef Keyword, |
| 587 |
bool IsImplicit = false) { |
| 588 |
if (!isValidCoroutineContext(S, Loc, Keyword)) |
| 589 |
return nullptr; |
| 590 |
|
| 591 |
assert(isa<FunctionDecl>(S.CurContext) && "not in a function scope"); |
| 592 |
|
| 593 |
auto *ScopeInfo = S.getCurFunction(); |
| 594 |
assert(ScopeInfo && "missing function scope for function"); |
| 595 |
|
| 596 |
if (ScopeInfo->FirstCoroutineStmtLoc.isInvalid() && !IsImplicit) |
| 597 |
ScopeInfo->setFirstCoroutineStmt(Loc, Keyword); |
| 598 |
|
| 599 |
if (ScopeInfo->CoroutinePromise) |
| 600 |
return ScopeInfo; |
| 601 |
|
| 602 |
if (!S.buildCoroutineParameterMoves(Loc)) |
| 603 |
return nullptr; |
| 604 |
|
| 605 |
ScopeInfo->CoroutinePromise = S.buildCoroutinePromise(Loc); |
| 606 |
if (!ScopeInfo->CoroutinePromise) |
| 607 |
return nullptr; |
| 608 |
|
| 609 |
return ScopeInfo; |
| 610 |
} |
| 611 |
|
| 612 |
/// Recursively check \p E and all its children to see if any call target |
| 613 |
/// (including constructor call) is declared noexcept. Also any value returned |
| 614 |
/// from the call has a noexcept destructor. |
| 615 |
static void checkNoThrow(Sema &S, const Stmt *E, |
| 616 |
llvm::SmallPtrSetImpl<const Decl *> &ThrowingDecls) { |
| 617 |
auto checkDeclNoexcept = [&](const Decl *D, bool IsDtor = false) { |
| 618 |
// In the case of dtor, the call to dtor is implicit and hence we should |
| 619 |
// pass nullptr to canCalleeThrow. |
| 620 |
if (Sema::canCalleeThrow(S, IsDtor ? nullptr : cast<Expr>(E), D)) { |
| 621 |
if (const auto *FD = dyn_cast<FunctionDecl>(D)) { |
| 622 |
// co_await promise.final_suspend() could end up calling |
| 623 |
// __builtin_coro_resume for symmetric transfer if await_suspend() |
| 624 |
// returns a handle. In that case, even __builtin_coro_resume is not |
| 625 |
// declared as noexcept and may throw, it does not throw _into_ the |
| 626 |
// coroutine that just suspended, but rather throws back out from |
| 627 |
// whoever called coroutine_handle::resume(), hence we claim that |
| 628 |
// logically it does not throw. |
| 629 |
if (FD->getBuiltinID() == Builtin::BI__builtin_coro_resume) |
| 630 |
return; |
| 631 |
} |
| 632 |
if (ThrowingDecls.empty()) { |
| 633 |
// [dcl.fct.def.coroutine]p15 |
| 634 |
// The expression co_await promise.final_suspend() shall not be |
| 635 |
// potentially-throwing ([except.spec]). |
| 636 |
// |
| 637 |
// First time seeing an error, emit the error message. |
| 638 |
S.Diag(cast<FunctionDecl>(S.CurContext)->getLocation(), |
| 639 |
diag::err_coroutine_promise_final_suspend_requires_nothrow); |
| 640 |
} |
| 641 |
ThrowingDecls.insert(D); |
| 642 |
} |
| 643 |
}; |
| 644 |
|
| 645 |
if (auto *CE = dyn_cast<CXXConstructExpr>(E)) { |
| 646 |
CXXConstructorDecl *Ctor = CE->getConstructor(); |
| 647 |
checkDeclNoexcept(Ctor); |
| 648 |
// Check the corresponding destructor of the constructor. |
| 649 |
checkDeclNoexcept(Ctor->getParent()->getDestructor(), /*IsDtor=*/true); |
| 650 |
} else if (auto *CE = dyn_cast<CallExpr>(E)) { |
| 651 |
if (CE->isTypeDependent()) |
| 652 |
return; |
| 653 |
|
| 654 |
checkDeclNoexcept(CE->getCalleeDecl()); |
| 655 |
QualType ReturnType = CE->getCallReturnType(S.getASTContext()); |
| 656 |
// Check the destructor of the call return type, if any. |
| 657 |
if (ReturnType.isDestructedType() == |
| 658 |
QualType::DestructionKind::DK_cxx_destructor) { |
| 659 |
const auto *T = |
| 660 |
cast<RecordType>(ReturnType.getCanonicalType().getTypePtr()); |
| 661 |
checkDeclNoexcept(cast<CXXRecordDecl>(T->getDecl())->getDestructor(), |
| 662 |
/*IsDtor=*/true); |
| 663 |
} |
| 664 |
} else |
| 665 |
for (const auto *Child : E->children()) { |
| 666 |
if (!Child) |
| 667 |
continue; |
| 668 |
checkNoThrow(S, Child, ThrowingDecls); |
| 669 |
} |
| 670 |
} |
| 671 |
|
| 672 |
bool Sema::checkFinalSuspendNoThrow(const Stmt *FinalSuspend) { |
| 673 |
llvm::SmallPtrSet<const Decl *, 4> ThrowingDecls; |
| 674 |
// We first collect all declarations that should not throw but not declared |
| 675 |
// with noexcept. We then sort them based on the location before printing. |
| 676 |
// This is to avoid emitting the same note multiple times on the same |
| 677 |
// declaration, and also provide a deterministic order for the messages. |
| 678 |
checkNoThrow(*this, FinalSuspend, ThrowingDecls); |
| 679 |
auto SortedDecls = llvm::SmallVector<const Decl *, 4>{ThrowingDecls.begin(), |
| 680 |
ThrowingDecls.end()}; |
| 681 |
sort(SortedDecls, [](const Decl *A, const Decl *B) { |
| 682 |
return A->getEndLoc() < B->getEndLoc(); |
| 683 |
}); |
| 684 |
for (const auto *D : SortedDecls) { |
| 685 |
Diag(D->getEndLoc(), diag::note_coroutine_function_declare_noexcept); |
| 686 |
} |
| 687 |
return ThrowingDecls.empty(); |
| 688 |
} |
| 689 |
|
| 690 |
bool Sema::ActOnCoroutineBodyStart(Scope *SC, SourceLocation KWLoc, |
| 691 |
StringRef Keyword) { |
| 692 |
if (!checkCoroutineContext(*this, KWLoc, Keyword)) |
| 693 |
return false; |
| 694 |
auto *ScopeInfo = getCurFunction(); |
| 695 |
assert(ScopeInfo->CoroutinePromise); |
| 696 |
|
| 697 |
// If we have existing coroutine statements then we have already built |
| 698 |
// the initial and final suspend points. |
| 699 |
if (!ScopeInfo->NeedsCoroutineSuspends) |
| 700 |
return true; |
| 701 |
|
| 702 |
ScopeInfo->setNeedsCoroutineSuspends(false); |
| 703 |
|
| 704 |
auto *Fn = cast<FunctionDecl>(CurContext); |
| 705 |
SourceLocation Loc = Fn->getLocation(); |
| 706 |
// Build the initial suspend point |
| 707 |
auto buildSuspends = [&](StringRef Name) mutable -> StmtResult { |
| 708 |
ExprResult Operand = buildPromiseCall(*this, ScopeInfo->CoroutinePromise, |
| 709 |
Loc, Name, std::nullopt); |
| 710 |
if (Operand.isInvalid()) |
| 711 |
return StmtError(); |
| 712 |
ExprResult Suspend = |
| 713 |
buildOperatorCoawaitCall(*this, SC, Loc, Operand.get()); |
| 714 |
if (Suspend.isInvalid()) |
| 715 |
return StmtError(); |
| 716 |
Suspend = BuildResolvedCoawaitExpr(Loc, Operand.get(), Suspend.get(), |
| 717 |
/*IsImplicit*/ true); |
| 718 |
Suspend = ActOnFinishFullExpr(Suspend.get(), /*DiscardedValue*/ false); |
| 719 |
if (Suspend.isInvalid()) { |
| 720 |
Diag(Loc, diag::note_coroutine_promise_suspend_implicitly_required) |
| 721 |
<< ((Name == "initial_suspend") ? 0 : 1); |
| 722 |
Diag(KWLoc, diag::note_declared_coroutine_here) << Keyword; |
| 723 |
return StmtError(); |
| 724 |
} |
| 725 |
return cast<Stmt>(Suspend.get()); |
| 726 |
}; |
| 727 |
|
| 728 |
StmtResult InitSuspend = buildSuspends("initial_suspend"); |
| 729 |
if (InitSuspend.isInvalid()) |
| 730 |
return true; |
| 731 |
|
| 732 |
StmtResult FinalSuspend = buildSuspends("final_suspend"); |
| 733 |
if (FinalSuspend.isInvalid() || !checkFinalSuspendNoThrow(FinalSuspend.get())) |
| 734 |
return true; |
| 735 |
|
| 736 |
ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get()); |
| 737 |
|
| 738 |
return true; |
| 739 |
} |
| 740 |
|
| 741 |
// Recursively walks up the scope hierarchy until either a 'catch' or a function |
| 742 |
// scope is found, whichever comes first. |
| 743 |
static bool isWithinCatchScope(Scope *S) { |
| 744 |
// 'co_await' and 'co_yield' keywords are disallowed within catch blocks, but |
| 745 |
// lambdas that use 'co_await' are allowed. The loop below ends when a |
| 746 |
// function scope is found in order to ensure the following behavior: |
| 747 |
// |
| 748 |
// void foo() { // <- function scope |
| 749 |
// try { // |
| 750 |
// co_await x; // <- 'co_await' is OK within a function scope |
| 751 |
// } catch { // <- catch scope |
| 752 |
// co_await x; // <- 'co_await' is not OK within a catch scope |
| 753 |
// []() { // <- function scope |
| 754 |
// co_await x; // <- 'co_await' is OK within a function scope |
| 755 |
// }(); |
| 756 |
// } |
| 757 |
// } |
| 758 |
while (S && !S->isFunctionScope()) { |
| 759 |
if (S->isCatchScope()) |
| 760 |
return true; |
| 761 |
S = S->getParent(); |
| 762 |
} |
| 763 |
return false; |
| 764 |
} |
| 765 |
|
| 766 |
// [expr.await]p2, emphasis added: "An await-expression shall appear only in |
| 767 |
// a *potentially evaluated* expression within the compound-statement of a |
| 768 |
// function-body *outside of a handler* [...] A context within a function |
| 769 |
// where an await-expression can appear is called a suspension context of the |
| 770 |
// function." |
| 771 |
static bool checkSuspensionContext(Sema &S, SourceLocation Loc, |
| 772 |
StringRef Keyword) { |
| 773 |
// First emphasis of [expr.await]p2: must be a potentially evaluated context. |
| 774 |
// That is, 'co_await' and 'co_yield' cannot appear in subexpressions of |
| 775 |
// \c sizeof. |
| 776 |
if (S.isUnevaluatedContext()) { |
| 777 |
S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword; |
| 778 |
return false; |
| 779 |
} |
| 780 |
|
| 781 |
// Second emphasis of [expr.await]p2: must be outside of an exception handler. |
| 782 |
if (isWithinCatchScope(S.getCurScope())) { |
| 783 |
S.Diag(Loc, diag::err_coroutine_within_handler) << Keyword; |
| 784 |
return false; |
| 785 |
} |
| 786 |
|
| 787 |
return true; |
| 788 |
} |
| 789 |
|
| 790 |
ExprResult Sema::ActOnCoawaitExpr(Scope *S, SourceLocation Loc, Expr *E) { |
| 791 |
if (!checkSuspensionContext(*this, Loc, "co_await")) |
| 792 |
return ExprError(); |
| 793 |
|
| 794 |
if (!ActOnCoroutineBodyStart(S, Loc, "co_await")) { |
| 795 |
CorrectDelayedTyposInExpr(E); |
| 796 |
return ExprError(); |
| 797 |
} |
| 798 |
|
| 799 |
if (E->hasPlaceholderType()) { |
| 800 |
ExprResult R = CheckPlaceholderExpr(E); |
| 801 |
if (R.isInvalid()) return ExprError(); |
| 802 |
E = R.get(); |
| 803 |
} |
| 804 |
ExprResult Lookup = BuildOperatorCoawaitLookupExpr(S, Loc); |
| 805 |
if (Lookup.isInvalid()) |
| 806 |
return ExprError(); |
| 807 |
return BuildUnresolvedCoawaitExpr(Loc, E, |
| 808 |
cast<UnresolvedLookupExpr>(Lookup.get())); |
| 809 |
} |
| 810 |
|
| 811 |
ExprResult Sema::BuildOperatorCoawaitLookupExpr(Scope *S, SourceLocation Loc) { |
| 812 |
DeclarationName OpName = |
| 813 |
Context.DeclarationNames.getCXXOperatorName(OO_Coawait); |
| 814 |
LookupResult Operators(*this, OpName, SourceLocation(), |
| 815 |
Sema::LookupOperatorName); |
| 816 |
LookupName(Operators, S); |
| 817 |
|
| 818 |
assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous"); |
| 819 |
const auto &Functions = Operators.asUnresolvedSet(); |
| 820 |
bool IsOverloaded = |
| 821 |
Functions.size() > 1 || |
| 822 |
(Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin())); |
| 823 |
Expr *CoawaitOp = UnresolvedLookupExpr::Create( |
| 824 |
Context, /*NamingClass*/ nullptr, NestedNameSpecifierLoc(), |
| 825 |
DeclarationNameInfo(OpName, Loc), /*RequiresADL*/ true, IsOverloaded, |
| 826 |
Functions.begin(), Functions.end()); |
| 827 |
assert(CoawaitOp); |
| 828 |
return CoawaitOp; |
| 829 |
} |
| 830 |
|
| 831 |
// Attempts to resolve and build a CoawaitExpr from "raw" inputs, bailing out to |
| 832 |
// DependentCoawaitExpr if needed. |
| 833 |
ExprResult Sema::BuildUnresolvedCoawaitExpr(SourceLocation Loc, Expr *Operand, |
| 834 |
UnresolvedLookupExpr *Lookup) { |
| 835 |
auto *FSI = checkCoroutineContext(*this, Loc, "co_await"); |
| 836 |
if (!FSI) |
| 837 |
return ExprError(); |
| 838 |
|
| 839 |
if (Operand->hasPlaceholderType()) { |
| 840 |
ExprResult R = CheckPlaceholderExpr(Operand); |
| 841 |
if (R.isInvalid()) |
| 842 |
return ExprError(); |
| 843 |
Operand = R.get(); |
| 844 |
} |
| 845 |
|
| 846 |
auto *Promise = FSI->CoroutinePromise; |
| 847 |
if (Promise->getType()->isDependentType()) { |
| 848 |
Expr *Res = new (Context) |
| 849 |
DependentCoawaitExpr(Loc, Context.DependentTy, Operand, Lookup); |
| 850 |
return Res; |
| 851 |
} |
| 852 |
|
| 853 |
auto *RD = Promise->getType()->getAsCXXRecordDecl(); |
| 854 |
auto *Transformed = Operand; |
| 855 |
if (lookupMember(*this, "await_transform", RD, Loc)) { |
| 856 |
ExprResult R = |
| 857 |
buildPromiseCall(*this, Promise, Loc, "await_transform", Operand); |
| 858 |
if (R.isInvalid()) { |
| 859 |
Diag(Loc, |
| 860 |
diag::note_coroutine_promise_implicit_await_transform_required_here) |
| 861 |
<< Operand->getSourceRange(); |
| 862 |
return ExprError(); |
| 863 |
} |
| 864 |
Transformed = R.get(); |
| 865 |
} |
| 866 |
ExprResult Awaiter = BuildOperatorCoawaitCall(Loc, Transformed, Lookup); |
| 867 |
if (Awaiter.isInvalid()) |
| 868 |
return ExprError(); |
| 869 |
|
| 870 |
return BuildResolvedCoawaitExpr(Loc, Operand, Awaiter.get()); |
| 871 |
} |
| 872 |
|
| 873 |
ExprResult Sema::BuildResolvedCoawaitExpr(SourceLocation Loc, Expr *Operand, |
| 874 |
Expr *Awaiter, bool IsImplicit) { |
| 875 |
auto *Coroutine = checkCoroutineContext(*this, Loc, "co_await", IsImplicit); |
| 876 |
if (!Coroutine) |
| 877 |
return ExprError(); |
| 878 |
|
| 879 |
if (Awaiter->hasPlaceholderType()) { |
| 880 |
ExprResult R = CheckPlaceholderExpr(Awaiter); |
| 881 |
if (R.isInvalid()) return ExprError(); |
| 882 |
Awaiter = R.get(); |
| 883 |
} |
| 884 |
|
| 885 |
if (Awaiter->getType()->isDependentType()) { |
| 886 |
Expr *Res = new (Context) |
| 887 |
CoawaitExpr(Loc, Context.DependentTy, Operand, Awaiter, IsImplicit); |
| 888 |
return Res; |
| 889 |
} |
| 890 |
|
| 891 |
// If the expression is a temporary, materialize it as an lvalue so that we |
| 892 |
// can use it multiple times. |
| 893 |
if (Awaiter->isPRValue()) |
| 894 |
Awaiter = CreateMaterializeTemporaryExpr(Awaiter->getType(), Awaiter, true); |
| 895 |
|
| 896 |
// The location of the `co_await` token cannot be used when constructing |
| 897 |
// the member call expressions since it's before the location of `Expr`, which |
| 898 |
// is used as the start of the member call expression. |
| 899 |
SourceLocation CallLoc = Awaiter->getExprLoc(); |
| 900 |
|
| 901 |
// Build the await_ready, await_suspend, await_resume calls. |
| 902 |
ReadySuspendResumeResult RSS = |
| 903 |
buildCoawaitCalls(*this, Coroutine->CoroutinePromise, CallLoc, Awaiter); |
| 904 |
if (RSS.IsInvalid) |
| 905 |
return ExprError(); |
| 906 |
|
| 907 |
Expr *Res = new (Context) |
| 908 |
CoawaitExpr(Loc, Operand, Awaiter, RSS.Results[0], RSS.Results[1], |
| 909 |
RSS.Results[2], RSS.OpaqueValue, IsImplicit); |
| 910 |
|
| 911 |
return Res; |
| 912 |
} |
| 913 |
|
| 914 |
ExprResult Sema::ActOnCoyieldExpr(Scope *S, SourceLocation Loc, Expr *E) { |
| 915 |
if (!checkSuspensionContext(*this, Loc, "co_yield")) |
| 916 |
return ExprError(); |
| 917 |
|
| 918 |
if (!ActOnCoroutineBodyStart(S, Loc, "co_yield")) { |
| 919 |
CorrectDelayedTyposInExpr(E); |
| 920 |
return ExprError(); |
| 921 |
} |
| 922 |
|
| 923 |
// Build yield_value call. |
| 924 |
ExprResult Awaitable = buildPromiseCall( |
| 925 |
*this, getCurFunction()->CoroutinePromise, Loc, "yield_value", E); |
| 926 |
if (Awaitable.isInvalid()) |
| 927 |
return ExprError(); |
| 928 |
|
| 929 |
// Build 'operator co_await' call. |
| 930 |
Awaitable = buildOperatorCoawaitCall(*this, S, Loc, Awaitable.get()); |
| 931 |
if (Awaitable.isInvalid()) |
| 932 |
return ExprError(); |
| 933 |
|
| 934 |
return BuildCoyieldExpr(Loc, Awaitable.get()); |
| 935 |
} |
| 936 |
ExprResult Sema::BuildCoyieldExpr(SourceLocation Loc, Expr *E) { |
| 937 |
auto *Coroutine = checkCoroutineContext(*this, Loc, "co_yield"); |
| 938 |
if (!Coroutine) |
| 939 |
return ExprError(); |
| 940 |
|
| 941 |
if (E->hasPlaceholderType()) { |
| 942 |
ExprResult R = CheckPlaceholderExpr(E); |
| 943 |
if (R.isInvalid()) return ExprError(); |
| 944 |
E = R.get(); |
| 945 |
} |
| 946 |
|
| 947 |
Expr *Operand = E; |
| 948 |
|
| 949 |
if (E->getType()->isDependentType()) { |
| 950 |
Expr *Res = new (Context) CoyieldExpr(Loc, Context.DependentTy, Operand, E); |
| 951 |
return Res; |
| 952 |
} |
| 953 |
|
| 954 |
// If the expression is a temporary, materialize it as an lvalue so that we |
| 955 |
// can use it multiple times. |
| 956 |
if (E->isPRValue()) |
| 957 |
E = CreateMaterializeTemporaryExpr(E->getType(), E, true); |
| 958 |
|
| 959 |
// Build the await_ready, await_suspend, await_resume calls. |
| 960 |
ReadySuspendResumeResult RSS = buildCoawaitCalls( |
| 961 |
*this, Coroutine->CoroutinePromise, Loc, E); |
| 962 |
if (RSS.IsInvalid) |
| 963 |
return ExprError(); |
| 964 |
|
| 965 |
Expr *Res = |
| 966 |
new (Context) CoyieldExpr(Loc, Operand, E, RSS.Results[0], RSS.Results[1], |
| 967 |
RSS.Results[2], RSS.OpaqueValue); |
| 968 |
|
| 969 |
return Res; |
| 970 |
} |
| 971 |
|
| 972 |
StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc, Expr *E) { |
| 973 |
if (!ActOnCoroutineBodyStart(S, Loc, "co_return")) { |
| 974 |
CorrectDelayedTyposInExpr(E); |
| 975 |
return StmtError(); |
| 976 |
} |
| 977 |
return BuildCoreturnStmt(Loc, E); |
| 978 |
} |
| 979 |
|
| 980 |
StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E, |
| 981 |
bool IsImplicit) { |
| 982 |
auto *FSI = checkCoroutineContext(*this, Loc, "co_return", IsImplicit); |
| 983 |
if (!FSI) |
| 984 |
return StmtError(); |
| 985 |
|
| 986 |
if (E && E->hasPlaceholderType() && |
| 987 |
!E->hasPlaceholderType(BuiltinType::Overload)) { |
| 988 |
ExprResult R = CheckPlaceholderExpr(E); |
| 989 |
if (R.isInvalid()) return StmtError(); |
| 990 |
E = R.get(); |
| 991 |
} |
| 992 |
|
| 993 |
VarDecl *Promise = FSI->CoroutinePromise; |
| 994 |
ExprResult PC; |
| 995 |
if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) { |
| 996 |
getNamedReturnInfo(E, SimplerImplicitMoveMode::ForceOn); |
| 997 |
PC = buildPromiseCall(*this, Promise, Loc, "return_value", E); |
| 998 |
} else { |
| 999 |
E = MakeFullDiscardedValueExpr(E).get(); |
| 1000 |
PC = buildPromiseCall(*this, Promise, Loc, "return_void", std::nullopt); |
| 1001 |
} |
| 1002 |
if (PC.isInvalid()) |
| 1003 |
return StmtError(); |
| 1004 |
|
| 1005 |
Expr *PCE = ActOnFinishFullExpr(PC.get(), /*DiscardedValue*/ false).get(); |
| 1006 |
|
| 1007 |
Stmt *Res = new (Context) CoreturnStmt(Loc, E, PCE, IsImplicit); |
| 1008 |
return Res; |
| 1009 |
} |
| 1010 |
|
| 1011 |
/// Look up the std::nothrow object. |
| 1012 |
static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) { |
| 1013 |
NamespaceDecl *Std = S.getStdNamespace(); |
| 1014 |
assert(Std && "Should already be diagnosed"); |
| 1015 |
|
| 1016 |
LookupResult Result(S, &S.PP.getIdentifierTable().get("nothrow"), Loc, |
| 1017 |
Sema::LookupOrdinaryName); |
| 1018 |
if (!S.LookupQualifiedName(Result, Std)) { |
| 1019 |
// <coroutine> is not requred to include <new>, so we couldn't omit |
| 1020 |
// the check here. |
| 1021 |
S.Diag(Loc, diag::err_implicit_coroutine_std_nothrow_type_not_found); |
| 1022 |
return nullptr; |
| 1023 |
} |
| 1024 |
|
| 1025 |
auto *VD = Result.getAsSingle<VarDecl>(); |
| 1026 |
if (!VD) { |
| 1027 |
Result.suppressDiagnostics(); |
| 1028 |
// We found something weird. Complain about the first thing we found. |
| 1029 |
NamedDecl *Found = *Result.begin(); |
| 1030 |
S.Diag(Found->getLocation(), diag::err_malformed_std_nothrow); |
| 1031 |
return nullptr; |
| 1032 |
} |
| 1033 |
|
| 1034 |
ExprResult DR = S.BuildDeclRefExpr(VD, VD->getType(), VK_LValue, Loc); |
| 1035 |
if (DR.isInvalid()) |
| 1036 |
return nullptr; |
| 1037 |
|
| 1038 |
return DR.get(); |
| 1039 |
} |
| 1040 |
|
| 1041 |
static TypeSourceInfo *getTypeSourceInfoForStdAlignValT(Sema &S, |
| 1042 |
SourceLocation Loc) { |
| 1043 |
EnumDecl *StdAlignValT = S.getStdAlignValT(); |
| 1044 |
QualType StdAlignValDecl = S.Context.getTypeDeclType(StdAlignValT); |
| 1045 |
return S.Context.getTrivialTypeSourceInfo(StdAlignValDecl); |
| 1046 |
} |
| 1047 |
|
| 1048 |
// Find an appropriate delete for the promise. |
| 1049 |
static bool findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseType, |
| 1050 |
FunctionDecl *&OperatorDelete) { |
| 1051 |
DeclarationName DeleteName = |
| 1052 |
S.Context.DeclarationNames.getCXXOperatorName(OO_Delete); |
| 1053 |
|
| 1054 |
auto *PointeeRD = PromiseType->getAsCXXRecordDecl(); |
| 1055 |
assert(PointeeRD && "PromiseType must be a CxxRecordDecl type"); |
| 1056 |
|
| 1057 |
const bool Overaligned = S.getLangOpts().CoroAlignedAllocation; |
| 1058 |
|
| 1059 |
// [dcl.fct.def.coroutine]p12 |
| 1060 |
// The deallocation function's name is looked up by searching for it in the |
| 1061 |
// scope of the promise type. If nothing is found, a search is performed in |
| 1062 |
// the global scope. |
| 1063 |
if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete, |
| 1064 |
/*Diagnose*/ true, /*WantSize*/ true, |
| 1065 |
/*WantAligned*/ Overaligned)) |
| 1066 |
return false; |
| 1067 |
|
| 1068 |
// [dcl.fct.def.coroutine]p12 |
| 1069 |
// If both a usual deallocation function with only a pointer parameter and a |
| 1070 |
// usual deallocation function with both a pointer parameter and a size |
| 1071 |
// parameter are found, then the selected deallocation function shall be the |
| 1072 |
// one with two parameters. Otherwise, the selected deallocation function |
| 1073 |
// shall be the function with one parameter. |
| 1074 |
if (!OperatorDelete) { |
| 1075 |
// Look for a global declaration. |
| 1076 |
// Coroutines can always provide their required size. |
| 1077 |
const bool CanProvideSize = true; |
| 1078 |
// Sema::FindUsualDeallocationFunction will try to find the one with two |
| 1079 |
// parameters first. It will return the deallocation function with one |
| 1080 |
// parameter if failed. |
| 1081 |
OperatorDelete = S.FindUsualDeallocationFunction(Loc, CanProvideSize, |
| 1082 |
Overaligned, DeleteName); |
| 1083 |
|
| 1084 |
if (!OperatorDelete) |
| 1085 |
return false; |
| 1086 |
} |
| 1087 |
|
| 1088 |
S.MarkFunctionReferenced(Loc, OperatorDelete); |
| 1089 |
return true; |
| 1090 |
} |
| 1091 |
|
| 1092 |
|
| 1093 |
void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) { |
| 1094 |
FunctionScopeInfo *Fn = getCurFunction(); |
| 1095 |
assert(Fn && Fn->isCoroutine() && "not a coroutine"); |
| 1096 |
if (!Body) { |
| 1097 |
assert(FD->isInvalidDecl() && |
| 1098 |
"a null body is only allowed for invalid declarations"); |
| 1099 |
return; |
| 1100 |
} |
| 1101 |
// We have a function that uses coroutine keywords, but we failed to build |
| 1102 |
// the promise type. |
| 1103 |
if (!Fn->CoroutinePromise) |
| 1104 |
return FD->setInvalidDecl(); |
| 1105 |
|
| 1106 |
if (isa<CoroutineBodyStmt>(Body)) { |
| 1107 |
// Nothing todo. the body is already a transformed coroutine body statement. |
| 1108 |
return; |
| 1109 |
} |
| 1110 |
|
| 1111 |
// The always_inline attribute doesn't reliably apply to a coroutine, |
| 1112 |
// because the coroutine will be split into pieces and some pieces |
| 1113 |
// might be called indirectly, as in a virtual call. Even the ramp |
| 1114 |
// function cannot be inlined at -O0, due to pipeline ordering |
| 1115 |
// problems (see https://llvm.org/PR53413). Tell the user about it. |
| 1116 |
if (FD->hasAttr<AlwaysInlineAttr>()) |
| 1117 |
Diag(FD->getLocation(), diag::warn_always_inline_coroutine); |
| 1118 |
|
| 1119 |
// [stmt.return.coroutine]p1: |
| 1120 |
// A coroutine shall not enclose a return statement ([stmt.return]). |
| 1121 |
if (Fn->FirstReturnLoc.isValid()) { |
| 1122 |
assert(Fn->FirstCoroutineStmtLoc.isValid() && |
| 1123 |
"first coroutine location not set"); |
| 1124 |
Diag(Fn->FirstReturnLoc, diag::err_return_in_coroutine); |
| 1125 |
Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) |
| 1126 |
<< Fn->getFirstCoroutineStmtKeyword(); |
| 1127 |
} |
| 1128 |
|
| 1129 |
// Coroutines will get splitted into pieces. The GNU address of label |
| 1130 |
// extension wouldn't be meaningful in coroutines. |
| 1131 |
for (AddrLabelExpr *ALE : Fn->AddrLabels) |
| 1132 |
Diag(ALE->getBeginLoc(), diag::err_coro_invalid_addr_of_label); |
| 1133 |
|
| 1134 |
CoroutineStmtBuilder Builder(*this, *FD, *Fn, Body); |
| 1135 |
if (Builder.isInvalid() || !Builder.buildStatements()) |
| 1136 |
return FD->setInvalidDecl(); |
| 1137 |
|
| 1138 |
// Build body for the coroutine wrapper statement. |
| 1139 |
Body = CoroutineBodyStmt::Create(Context, Builder); |
| 1140 |
} |
| 1141 |
|
| 1142 |
CoroutineStmtBuilder::CoroutineStmtBuilder(Sema &S, FunctionDecl &FD, |
| 1143 |
sema::FunctionScopeInfo &Fn, |
| 1144 |
Stmt *Body) |
| 1145 |
: S(S), FD(FD), Fn(Fn), Loc(FD.getLocation()), |
| 1146 |
IsPromiseDependentType( |
| 1147 |
!Fn.CoroutinePromise || |
| 1148 |
Fn.CoroutinePromise->getType()->isDependentType()) { |
| 1149 |
this->Body = Body; |
| 1150 |
|
| 1151 |
for (auto KV : Fn.CoroutineParameterMoves) |
| 1152 |
this->ParamMovesVector.push_back(KV.second); |
| 1153 |
this->ParamMoves = this->ParamMovesVector; |
| 1154 |
|
| 1155 |
if (!IsPromiseDependentType) { |
| 1156 |
PromiseRecordDecl = Fn.CoroutinePromise->getType()->getAsCXXRecordDecl(); |
| 1157 |
assert(PromiseRecordDecl && "Type should have already been checked"); |
| 1158 |
} |
| 1159 |
this->IsValid = makePromiseStmt() && makeInitialAndFinalSuspend(); |
| 1160 |
} |
| 1161 |
|
| 1162 |
bool CoroutineStmtBuilder::buildStatements() { |
| 1163 |
assert(this->IsValid && "coroutine already invalid"); |
| 1164 |
this->IsValid = makeReturnObject(); |
| 1165 |
if (this->IsValid && !IsPromiseDependentType) |
| 1166 |
buildDependentStatements(); |
| 1167 |
return this->IsValid; |
| 1168 |
} |
| 1169 |
|
| 1170 |
bool CoroutineStmtBuilder::buildDependentStatements() { |
| 1171 |
assert(this->IsValid && "coroutine already invalid"); |
| 1172 |
assert(!this->IsPromiseDependentType && |
| 1173 |
"coroutine cannot have a dependent promise type"); |
| 1174 |
this->IsValid = makeOnException() && makeOnFallthrough() && |
| 1175 |
makeGroDeclAndReturnStmt() && makeReturnOnAllocFailure() && |
| 1176 |
makeNewAndDeleteExpr(); |
| 1177 |
return this->IsValid; |
| 1178 |
} |
| 1179 |
|
| 1180 |
bool CoroutineStmtBuilder::makePromiseStmt() { |
| 1181 |
// Form a declaration statement for the promise declaration, so that AST |
| 1182 |
// visitors can more easily find it. |
| 1183 |
StmtResult PromiseStmt = |
| 1184 |
S.ActOnDeclStmt(S.ConvertDeclToDeclGroup(Fn.CoroutinePromise), Loc, Loc); |
| 1185 |
if (PromiseStmt.isInvalid()) |
| 1186 |
return false; |
| 1187 |
|
| 1188 |
this->Promise = PromiseStmt.get(); |
| 1189 |
return true; |
| 1190 |
} |
| 1191 |
|
| 1192 |
bool CoroutineStmtBuilder::makeInitialAndFinalSuspend() { |
| 1193 |
if (Fn.hasInvalidCoroutineSuspends()) |
| 1194 |
return false; |
| 1195 |
this->InitialSuspend = cast<Expr>(Fn.CoroutineSuspends.first); |
| 1196 |
this->FinalSuspend = cast<Expr>(Fn.CoroutineSuspends.second); |
| 1197 |
return true; |
| 1198 |
} |
| 1199 |
|
| 1200 |
static bool diagReturnOnAllocFailure(Sema &S, Expr *E, |
| 1201 |
CXXRecordDecl *PromiseRecordDecl, |
| 1202 |
FunctionScopeInfo &Fn) { |
| 1203 |
auto Loc = E->getExprLoc(); |
| 1204 |
if (auto *DeclRef = dyn_cast_or_null<DeclRefExpr>(E)) { |
| 1205 |
auto *Decl = DeclRef->getDecl(); |
| 1206 |
if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(Decl)) { |
| 1207 |
if (Method->isStatic()) |
| 1208 |
return true; |
| 1209 |
else |
| 1210 |
Loc = Decl->getLocation(); |
| 1211 |
} |
| 1212 |
} |
| 1213 |
|
| 1214 |
S.Diag( |
| 1215 |
Loc, |
| 1216 |
diag::err_coroutine_promise_get_return_object_on_allocation_failure) |
| 1217 |
<< PromiseRecordDecl; |
| 1218 |
S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) |
| 1219 |
<< Fn.getFirstCoroutineStmtKeyword(); |
| 1220 |
return false; |
| 1221 |
} |
| 1222 |
|
| 1223 |
bool CoroutineStmtBuilder::makeReturnOnAllocFailure() { |
| 1224 |
assert(!IsPromiseDependentType && |
| 1225 |
"cannot make statement while the promise type is dependent"); |
| 1226 |
|
| 1227 |
// [dcl.fct.def.coroutine]p10 |
| 1228 |
// If a search for the name get_return_object_on_allocation_failure in |
| 1229 |
// the scope of the promise type ([class.member.lookup]) finds any |
| 1230 |
// declarations, then the result of a call to an allocation function used to |
| 1231 |
// obtain storage for the coroutine state is assumed to return nullptr if it |
| 1232 |
// fails to obtain storage, ... If the allocation function returns nullptr, |
| 1233 |
// ... and the return value is obtained by a call to |
| 1234 |
// T::get_return_object_on_allocation_failure(), where T is the |
| 1235 |
// promise type. |
| 1236 |
DeclarationName DN = |
| 1237 |
S.PP.getIdentifierInfo("get_return_object_on_allocation_failure"); |
| 1238 |
LookupResult Found(S, DN, Loc, Sema::LookupMemberName); |
| 1239 |
if (!S.LookupQualifiedName(Found, PromiseRecordDecl)) |
| 1240 |
return true; |
| 1241 |
|
| 1242 |
CXXScopeSpec SS; |
| 1243 |
ExprResult DeclNameExpr = |
| 1244 |
S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false); |
| 1245 |
if (DeclNameExpr.isInvalid()) |
| 1246 |
return false; |
| 1247 |
|
| 1248 |
if (!diagReturnOnAllocFailure(S, DeclNameExpr.get(), PromiseRecordDecl, Fn)) |
| 1249 |
return false; |
| 1250 |
|
| 1251 |
ExprResult ReturnObjectOnAllocationFailure = |
| 1252 |
S.BuildCallExpr(nullptr, DeclNameExpr.get(), Loc, {}, Loc); |
| 1253 |
if (ReturnObjectOnAllocationFailure.isInvalid()) |
| 1254 |
return false; |
| 1255 |
|
| 1256 |
StmtResult ReturnStmt = |
| 1257 |
S.BuildReturnStmt(Loc, ReturnObjectOnAllocationFailure.get()); |
| 1258 |
if (ReturnStmt.isInvalid()) { |
| 1259 |
S.Diag(Found.getFoundDecl()->getLocation(), diag::note_member_declared_here) |
| 1260 |
<< DN; |
| 1261 |
S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) |
| 1262 |
<< Fn.getFirstCoroutineStmtKeyword(); |
| 1263 |
return false; |
| 1264 |
} |
| 1265 |
|
| 1266 |
this->ReturnStmtOnAllocFailure = ReturnStmt.get(); |
| 1267 |
return true; |
| 1268 |
} |
| 1269 |
|
| 1270 |
// Collect placement arguments for allocation function of coroutine FD. |
| 1271 |
// Return true if we collect placement arguments succesfully. Return false, |
| 1272 |
// otherwise. |
| 1273 |
static bool collectPlacementArgs(Sema &S, FunctionDecl &FD, SourceLocation Loc, |
| 1274 |
SmallVectorImpl<Expr *> &PlacementArgs) { |
| 1275 |
if (auto *MD = dyn_cast<CXXMethodDecl>(&FD)) { |
| 1276 |
if (MD->isInstance() && !isLambdaCallOperator(MD)) { |
| 1277 |
ExprResult ThisExpr = S.ActOnCXXThis(Loc); |
| 1278 |
if (ThisExpr.isInvalid()) |
| 1279 |
return false; |
| 1280 |
ThisExpr = S.CreateBuiltinUnaryOp(Loc, UO_Deref, ThisExpr.get()); |
| 1281 |
if (ThisExpr.isInvalid()) |
| 1282 |
return false; |
| 1283 |
PlacementArgs.push_back(ThisExpr.get()); |
| 1284 |
} |
| 1285 |
} |
| 1286 |
|
| 1287 |
for (auto *PD : FD.parameters()) { |
| 1288 |
if (PD->getType()->isDependentType()) |
| 1289 |
continue; |
| 1290 |
|
| 1291 |
// Build a reference to the parameter. |
| 1292 |
auto PDLoc = PD->getLocation(); |
| 1293 |
ExprResult PDRefExpr = |
| 1294 |
S.BuildDeclRefExpr(PD, PD->getOriginalType().getNonReferenceType(), |
| 1295 |
ExprValueKind::VK_LValue, PDLoc); |
| 1296 |
if (PDRefExpr.isInvalid()) |
| 1297 |
return false; |
| 1298 |
|
| 1299 |
PlacementArgs.push_back(PDRefExpr.get()); |
| 1300 |
} |
| 1301 |
|
| 1302 |
return true; |
| 1303 |
} |
| 1304 |
|
| 1305 |
bool CoroutineStmtBuilder::makeNewAndDeleteExpr() { |
| 1306 |
// Form and check allocation and deallocation calls. |
| 1307 |
assert(!IsPromiseDependentType && |
| 1308 |
"cannot make statement while the promise type is dependent"); |
| 1309 |
QualType PromiseType = Fn.CoroutinePromise->getType(); |
| 1310 |
|
| 1311 |
if (S.RequireCompleteType(Loc, PromiseType, diag::err_incomplete_type)) |
| 1312 |
return false; |
| 1313 |
|
| 1314 |
const bool RequiresNoThrowAlloc = ReturnStmtOnAllocFailure != nullptr; |
| 1315 |
|
| 1316 |
// According to [dcl.fct.def.coroutine]p9, Lookup allocation functions using a |
| 1317 |
// parameter list composed of the requested size of the coroutine state being |
| 1318 |
// allocated, followed by the coroutine function's arguments. If a matching |
| 1319 |
// allocation function exists, use it. Otherwise, use an allocation function |
| 1320 |
// that just takes the requested size. |
| 1321 |
// |
| 1322 |
// [dcl.fct.def.coroutine]p9 |
| 1323 |
// An implementation may need to allocate additional storage for a |
| 1324 |
// coroutine. |
| 1325 |
// This storage is known as the coroutine state and is obtained by calling a |
| 1326 |
// non-array allocation function ([basic.stc.dynamic.allocation]). The |
| 1327 |
// allocation function's name is looked up by searching for it in the scope of |
| 1328 |
// the promise type. |
| 1329 |
// - If any declarations are found, overload resolution is performed on a |
| 1330 |
// function call created by assembling an argument list. The first argument is |
| 1331 |
// the amount of space requested, and has type std::size_t. The |
| 1332 |
// lvalues p1 ... pn are the succeeding arguments. |
| 1333 |
// |
| 1334 |
// ...where "p1 ... pn" are defined earlier as: |
| 1335 |
// |
| 1336 |
// [dcl.fct.def.coroutine]p3 |
| 1337 |
// The promise type of a coroutine is `std::coroutine_traits<R, P1, ..., |
| 1338 |
// Pn>` |
| 1339 |
// , where R is the return type of the function, and `P1, ..., Pn` are the |
| 1340 |
// sequence of types of the non-object function parameters, preceded by the |
| 1341 |
// type of the object parameter ([dcl.fct]) if the coroutine is a non-static |
| 1342 |
// member function. [dcl.fct.def.coroutine]p4 In the following, p_i is an |
| 1343 |
// lvalue of type P_i, where p1 denotes the object parameter and p_i+1 denotes |
| 1344 |
// the i-th non-object function parameter for a non-static member function, |
| 1345 |
// and p_i denotes the i-th function parameter otherwise. For a non-static |
| 1346 |
// member function, q_1 is an lvalue that denotes *this; any other q_i is an |
| 1347 |
// lvalue that denotes the parameter copy corresponding to p_i. |
| 1348 |
|
| 1349 |
FunctionDecl *OperatorNew = nullptr; |
| 1350 |
SmallVector<Expr *, 1> PlacementArgs; |
| 1351 |
|
| 1352 |
const bool PromiseContainsNew = [this, &PromiseType]() -> bool { |
| 1353 |
DeclarationName NewName = |
| 1354 |
S.getASTContext().DeclarationNames.getCXXOperatorName(OO_New); |
| 1355 |
LookupResult R(S, NewName, Loc, Sema::LookupOrdinaryName); |
| 1356 |
|
| 1357 |
if (PromiseType->isRecordType()) |
| 1358 |
S.LookupQualifiedName(R, PromiseType->getAsCXXRecordDecl()); |
| 1359 |
|
| 1360 |
return !R.empty() && !R.isAmbiguous(); |
| 1361 |
}(); |
| 1362 |
|
| 1363 |
// Helper function to indicate whether the last lookup found the aligned |
| 1364 |
// allocation function. |
| 1365 |
bool PassAlignment = S.getLangOpts().CoroAlignedAllocation; |
| 1366 |
auto LookupAllocationFunction = [&](Sema::AllocationFunctionScope NewScope = |
| 1367 |
Sema::AFS_Both, |
| 1368 |
bool WithoutPlacementArgs = false, |
| 1369 |
bool ForceNonAligned = false) { |
| 1370 |
// [dcl.fct.def.coroutine]p9 |
| 1371 |
// The allocation function's name is looked up by searching for it in the |
| 1372 |
// scope of the promise type. |
| 1373 |
// - If any declarations are found, ... |
| 1374 |
// - If no declarations are found in the scope of the promise type, a search |
| 1375 |
// is performed in the global scope. |
| 1376 |
if (NewScope == Sema::AFS_Both) |
| 1377 |
NewScope = PromiseContainsNew ? Sema::AFS_Class : Sema::AFS_Global; |
| 1378 |
|
| 1379 |
PassAlignment = !ForceNonAligned && S.getLangOpts().CoroAlignedAllocation; |
| 1380 |
FunctionDecl *UnusedResult = nullptr; |
| 1381 |
S.FindAllocationFunctions(Loc, SourceRange(), NewScope, |
| 1382 |
/*DeleteScope*/ Sema::AFS_Both, PromiseType, |
| 1383 |
/*isArray*/ false, PassAlignment, |
| 1384 |
WithoutPlacementArgs ? MultiExprArg{} |
| 1385 |
: PlacementArgs, |
| 1386 |
OperatorNew, UnusedResult, /*Diagnose*/ false); |
| 1387 |
}; |
| 1388 |
|
| 1389 |
// We don't expect to call to global operator new with (size, p0, …, pn). |
| 1390 |
// So if we choose to lookup the allocation function in global scope, we |
| 1391 |
// shouldn't lookup placement arguments. |
| 1392 |
if (PromiseContainsNew && !collectPlacementArgs(S, FD, Loc, PlacementArgs)) |
| 1393 |
return false; |
| 1394 |
|
| 1395 |
LookupAllocationFunction(); |
| 1396 |
|
| 1397 |
if (PromiseContainsNew && !PlacementArgs.empty()) { |
| 1398 |
// [dcl.fct.def.coroutine]p9 |
| 1399 |
// If no viable function is found ([over.match.viable]), overload |
| 1400 |
// resolution |
| 1401 |
// is performed again on a function call created by passing just the amount |
| 1402 |
// of space required as an argument of type std::size_t. |
| 1403 |
// |
| 1404 |
// Proposed Change of [dcl.fct.def.coroutine]p9 in P2014R0: |
| 1405 |
// Otherwise, overload resolution is performed again on a function call |
| 1406 |
// created |
| 1407 |
// by passing the amount of space requested as an argument of type |
| 1408 |
// std::size_t as the first argument, and the requested alignment as |
| 1409 |
// an argument of type std:align_val_t as the second argument. |
| 1410 |
if (!OperatorNew || |
| 1411 |
(S.getLangOpts().CoroAlignedAllocation && !PassAlignment)) |
| 1412 |
LookupAllocationFunction(/*NewScope*/ Sema::AFS_Class, |
| 1413 |
/*WithoutPlacementArgs*/ true); |
| 1414 |
} |
| 1415 |
|
| 1416 |
// Proposed Change of [dcl.fct.def.coroutine]p12 in P2014R0: |
| 1417 |
// Otherwise, overload resolution is performed again on a function call |
| 1418 |
// created |
| 1419 |
// by passing the amount of space requested as an argument of type |
| 1420 |
// std::size_t as the first argument, and the lvalues p1 ... pn as the |
| 1421 |
// succeeding arguments. Otherwise, overload resolution is performed again |
| 1422 |
// on a function call created by passing just the amount of space required as |
| 1423 |
// an argument of type std::size_t. |
| 1424 |
// |
| 1425 |
// So within the proposed change in P2014RO, the priority order of aligned |
| 1426 |
// allocation functions wiht promise_type is: |
| 1427 |
// |
| 1428 |
// void* operator new( std::size_t, std::align_val_t, placement_args... ); |
| 1429 |
// void* operator new( std::size_t, std::align_val_t); |
| 1430 |
// void* operator new( std::size_t, placement_args... ); |
| 1431 |
// void* operator new( std::size_t); |
| 1432 |
|
| 1433 |
// Helper variable to emit warnings. |
| 1434 |
bool FoundNonAlignedInPromise = false; |
| 1435 |
if (PromiseContainsNew && S.getLangOpts().CoroAlignedAllocation) |
| 1436 |
if (!OperatorNew || !PassAlignment) { |
| 1437 |
FoundNonAlignedInPromise = OperatorNew; |
| 1438 |
|
| 1439 |
LookupAllocationFunction(/*NewScope*/ Sema::AFS_Class, |
| 1440 |
/*WithoutPlacementArgs*/ false, |
| 1441 |
/*ForceNonAligned*/ true); |
| 1442 |
|
| 1443 |
if (!OperatorNew && !PlacementArgs.empty()) |
| 1444 |
LookupAllocationFunction(/*NewScope*/ Sema::AFS_Class, |
| 1445 |
/*WithoutPlacementArgs*/ true, |
| 1446 |
/*ForceNonAligned*/ true); |
| 1447 |
} |
| 1448 |
|
| 1449 |
bool IsGlobalOverload = |
| 1450 |
OperatorNew && !isa<CXXRecordDecl>(OperatorNew->getDeclContext()); |
| 1451 |
// If we didn't find a class-local new declaration and non-throwing new |
| 1452 |
// was is required then we need to lookup the non-throwing global operator |
| 1453 |
// instead. |
| 1454 |
if (RequiresNoThrowAlloc && (!OperatorNew || IsGlobalOverload)) { |
| 1455 |
auto *StdNoThrow = buildStdNoThrowDeclRef(S, Loc); |
| 1456 |
if (!StdNoThrow) |
| 1457 |
return false; |
| 1458 |
PlacementArgs = {StdNoThrow}; |
| 1459 |
OperatorNew = nullptr; |
| 1460 |
LookupAllocationFunction(Sema::AFS_Global); |
| 1461 |
} |
| 1462 |
|
| 1463 |
// If we found a non-aligned allocation function in the promise_type, |
| 1464 |
// it indicates the user forgot to update the allocation function. Let's emit |
| 1465 |
// a warning here. |
| 1466 |
if (FoundNonAlignedInPromise) { |
| 1467 |
S.Diag(OperatorNew->getLocation(), |
| 1468 |
diag::warn_non_aligned_allocation_function) |
| 1469 |
<< &FD; |
| 1470 |
} |
| 1471 |
|
| 1472 |
if (!OperatorNew) { |
| 1473 |
if (PromiseContainsNew) |
| 1474 |
S.Diag(Loc, diag::err_coroutine_unusable_new) << PromiseType << &FD; |
| 1475 |
else if (RequiresNoThrowAlloc) |
| 1476 |
S.Diag(Loc, diag::err_coroutine_unfound_nothrow_new) |
| 1477 |
<< &FD << S.getLangOpts().CoroAlignedAllocation; |
| 1478 |
|
| 1479 |
return false; |
| 1480 |
} |
| 1481 |
|
| 1482 |
if (RequiresNoThrowAlloc) { |
| 1483 |
const auto *FT = OperatorNew->getType()->castAs<FunctionProtoType>(); |
| 1484 |
if (!FT->isNothrow(/*ResultIfDependent*/ false)) { |
| 1485 |
S.Diag(OperatorNew->getLocation(), |
| 1486 |
diag::err_coroutine_promise_new_requires_nothrow) |
| 1487 |
<< OperatorNew; |
| 1488 |
S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required) |
| 1489 |
<< OperatorNew; |
| 1490 |
return false; |
| 1491 |
} |
| 1492 |
} |
| 1493 |
|
| 1494 |
FunctionDecl *OperatorDelete = nullptr; |
| 1495 |
if (!findDeleteForPromise(S, Loc, PromiseType, OperatorDelete)) { |
| 1496 |
// FIXME: We should add an error here. According to: |
| 1497 |
// [dcl.fct.def.coroutine]p12 |
| 1498 |
// If no usual deallocation function is found, the program is ill-formed. |
| 1499 |
return false; |
| 1500 |
} |
| 1501 |
|
| 1502 |
Expr *FramePtr = |
| 1503 |
S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_frame, {}); |
| 1504 |
|
| 1505 |
Expr *FrameSize = |
| 1506 |
S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_size, {}); |
| 1507 |
|
| 1508 |
Expr *FrameAlignment = nullptr; |
| 1509 |
|
| 1510 |
if (S.getLangOpts().CoroAlignedAllocation) { |
| 1511 |
FrameAlignment = |
| 1512 |
S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_align, {}); |
| 1513 |
|
| 1514 |
TypeSourceInfo *AlignValTy = getTypeSourceInfoForStdAlignValT(S, Loc); |
| 1515 |
if (!AlignValTy) |
| 1516 |
return false; |
| 1517 |
|
| 1518 |
FrameAlignment = S.BuildCXXNamedCast(Loc, tok::kw_static_cast, AlignValTy, |
| 1519 |
FrameAlignment, SourceRange(Loc, Loc), |
| 1520 |
SourceRange(Loc, Loc)) |
| 1521 |
.get(); |
| 1522 |
} |
| 1523 |
|
| 1524 |
// Make new call. |
| 1525 |
ExprResult NewRef = |
| 1526 |
S.BuildDeclRefExpr(OperatorNew, OperatorNew->getType(), VK_LValue, Loc); |
| 1527 |
if (NewRef.isInvalid()) |
| 1528 |
return false; |
| 1529 |
|
| 1530 |
SmallVector<Expr *, 2> NewArgs(1, FrameSize); |
| 1531 |
if (S.getLangOpts().CoroAlignedAllocation && PassAlignment) |
| 1532 |
NewArgs.push_back(FrameAlignment); |
| 1533 |
|
| 1534 |
if (OperatorNew->getNumParams() > NewArgs.size()) |
| 1535 |
llvm::append_range(NewArgs, PlacementArgs); |
| 1536 |
|
| 1537 |
ExprResult NewExpr = |
| 1538 |
S.BuildCallExpr(S.getCurScope(), NewRef.get(), Loc, NewArgs, Loc); |
| 1539 |
NewExpr = S.ActOnFinishFullExpr(NewExpr.get(), /*DiscardedValue*/ false); |
| 1540 |
if (NewExpr.isInvalid()) |
| 1541 |
return false; |
| 1542 |
|
| 1543 |
// Make delete call. |
| 1544 |
|
| 1545 |
QualType OpDeleteQualType = OperatorDelete->getType(); |
| 1546 |
|
| 1547 |
ExprResult DeleteRef = |
| 1548 |
S.BuildDeclRefExpr(OperatorDelete, OpDeleteQualType, VK_LValue, Loc); |
| 1549 |
if (DeleteRef.isInvalid()) |
| 1550 |
return false; |
| 1551 |
|
| 1552 |
Expr *CoroFree = |
| 1553 |
S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_free, {FramePtr}); |
| 1554 |
|
| 1555 |
SmallVector<Expr *, 2> DeleteArgs{CoroFree}; |
| 1556 |
|
| 1557 |
// [dcl.fct.def.coroutine]p12 |
| 1558 |
// The selected deallocation function shall be called with the address of |
| 1559 |
// the block of storage to be reclaimed as its first argument. If a |
| 1560 |
// deallocation function with a parameter of type std::size_t is |
| 1561 |
// used, the size of the block is passed as the corresponding argument. |
| 1562 |
const auto *OpDeleteType = |
| 1563 |
OpDeleteQualType.getTypePtr()->castAs<FunctionProtoType>(); |
| 1564 |
if (OpDeleteType->getNumParams() > DeleteArgs.size() && |
| 1565 |
S.getASTContext().hasSameUnqualifiedType( |
| 1566 |
OpDeleteType->getParamType(DeleteArgs.size()), FrameSize->getType())) |
| 1567 |
DeleteArgs.push_back(FrameSize); |
| 1568 |
|
| 1569 |
// Proposed Change of [dcl.fct.def.coroutine]p12 in P2014R0: |
| 1570 |
// If deallocation function lookup finds a usual deallocation function with |
| 1571 |
// a pointer parameter, size parameter and alignment parameter then this |
| 1572 |
// will be the selected deallocation function, otherwise if lookup finds a |
| 1573 |
// usual deallocation function with both a pointer parameter and a size |
| 1574 |
// parameter, then this will be the selected deallocation function. |
| 1575 |
// Otherwise, if lookup finds a usual deallocation function with only a |
| 1576 |
// pointer parameter, then this will be the selected deallocation |
| 1577 |
// function. |
| 1578 |
// |
| 1579 |
// So we are not forced to pass alignment to the deallocation function. |
| 1580 |
if (S.getLangOpts().CoroAlignedAllocation && |
| 1581 |
OpDeleteType->getNumParams() > DeleteArgs.size() && |
| 1582 |
S.getASTContext().hasSameUnqualifiedType( |
| 1583 |
OpDeleteType->getParamType(DeleteArgs.size()), |
| 1584 |
FrameAlignment->getType())) |
| 1585 |
DeleteArgs.push_back(FrameAlignment); |
| 1586 |
|
| 1587 |
ExprResult DeleteExpr = |
| 1588 |
S.BuildCallExpr(S.getCurScope(), DeleteRef.get(), Loc, DeleteArgs, Loc); |
| 1589 |
DeleteExpr = |
| 1590 |
S.ActOnFinishFullExpr(DeleteExpr.get(), /*DiscardedValue*/ false); |
| 1591 |
if (DeleteExpr.isInvalid()) |
| 1592 |
return false; |
| 1593 |
|
| 1594 |
this->Allocate = NewExpr.get(); |
| 1595 |
this->Deallocate = DeleteExpr.get(); |
| 1596 |
|
| 1597 |
return true; |
| 1598 |
} |
| 1599 |
|
| 1600 |
bool CoroutineStmtBuilder::makeOnFallthrough() { |
| 1601 |
assert(!IsPromiseDependentType && |
| 1602 |
"cannot make statement while the promise type is dependent"); |
| 1603 |
|
| 1604 |
// [dcl.fct.def.coroutine]/p6 |
| 1605 |
// If searches for the names return_void and return_value in the scope of |
| 1606 |
// the promise type each find any declarations, the program is ill-formed. |
| 1607 |
// [Note 1: If return_void is found, flowing off the end of a coroutine is |
| 1608 |
// equivalent to a co_return with no operand. Otherwise, flowing off the end |
| 1609 |
// of a coroutine results in undefined behavior ([stmt.return.coroutine]). — |
| 1610 |
// end note] |
| 1611 |
bool HasRVoid, HasRValue; |
| 1612 |
LookupResult LRVoid = |
| 1613 |
lookupMember(S, "return_void", PromiseRecordDecl, Loc, HasRVoid); |
| 1614 |
LookupResult LRValue = |
| 1615 |
lookupMember(S, "return_value", PromiseRecordDecl, Loc, HasRValue); |
| 1616 |
|
| 1617 |
StmtResult Fallthrough; |
| 1618 |
if (HasRVoid && HasRValue) { |
| 1619 |
// FIXME Improve this diagnostic |
| 1620 |
S.Diag(FD.getLocation(), |
| 1621 |
diag::err_coroutine_promise_incompatible_return_functions) |
| 1622 |
<< PromiseRecordDecl; |
| 1623 |
S.Diag(LRVoid.getRepresentativeDecl()->getLocation(), |
| 1624 |
diag::note_member_first_declared_here) |
| 1625 |
<< LRVoid.getLookupName(); |
| 1626 |
S.Diag(LRValue.getRepresentativeDecl()->getLocation(), |
| 1627 |
diag::note_member_first_declared_here) |
| 1628 |
<< LRValue.getLookupName(); |
| 1629 |
return false; |
| 1630 |
} else if (!HasRVoid && !HasRValue) { |
| 1631 |
// We need to set 'Fallthrough'. Otherwise the other analysis part might |
| 1632 |
// think the coroutine has defined a return_value method. So it might emit |
| 1633 |
// **false** positive warning. e.g., |
| 1634 |
// |
| 1635 |
// promise_without_return_func foo() { |
| 1636 |
// co_await something(); |
| 1637 |
// } |
| 1638 |
// |
| 1639 |
// Then AnalysisBasedWarning would emit a warning about `foo()` lacking a |
| 1640 |
// co_return statements, which isn't correct. |
| 1641 |
Fallthrough = S.ActOnNullStmt(PromiseRecordDecl->getLocation()); |
| 1642 |
if (Fallthrough.isInvalid()) |
| 1643 |
return false; |
| 1644 |
} else if (HasRVoid) { |
| 1645 |
Fallthrough = S.BuildCoreturnStmt(FD.getLocation(), nullptr, |
| 1646 |
/*IsImplicit*/false); |
| 1647 |
Fallthrough = S.ActOnFinishFullStmt(Fallthrough.get()); |
| 1648 |
if (Fallthrough.isInvalid()) |
| 1649 |
return false; |
| 1650 |
} |
| 1651 |
|
| 1652 |
this->OnFallthrough = Fallthrough.get(); |
| 1653 |
return true; |
| 1654 |
} |
| 1655 |
|
| 1656 |
bool CoroutineStmtBuilder::makeOnException() { |
| 1657 |
// Try to form 'p.unhandled_exception();' |
| 1658 |
assert(!IsPromiseDependentType && |
| 1659 |
"cannot make statement while the promise type is dependent"); |
| 1660 |
|
| 1661 |
const bool RequireUnhandledException = S.getLangOpts().CXXExceptions; |
| 1662 |
|
| 1663 |
if (!lookupMember(S, "unhandled_exception", PromiseRecordDecl, Loc)) { |
| 1664 |
auto DiagID = |
| 1665 |
RequireUnhandledException |
| 1666 |
? diag::err_coroutine_promise_unhandled_exception_required |
| 1667 |
: diag:: |
| 1668 |
warn_coroutine_promise_unhandled_exception_required_with_exceptions; |
| 1669 |
S.Diag(Loc, DiagID) << PromiseRecordDecl; |
| 1670 |
S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here) |
| 1671 |
<< PromiseRecordDecl; |
| 1672 |
return !RequireUnhandledException; |
| 1673 |
} |
| 1674 |
|
| 1675 |
// If exceptions are disabled, don't try to build OnException. |
| 1676 |
if (!S.getLangOpts().CXXExceptions) |
| 1677 |
return true; |
| 1678 |
|
| 1679 |
ExprResult UnhandledException = buildPromiseCall( |
| 1680 |
S, Fn.CoroutinePromise, Loc, "unhandled_exception", std::nullopt); |
| 1681 |
UnhandledException = S.ActOnFinishFullExpr(UnhandledException.get(), Loc, |
| 1682 |
/*DiscardedValue*/ false); |
| 1683 |
if (UnhandledException.isInvalid()) |
| 1684 |
return false; |
| 1685 |
|
| 1686 |
// Since the body of the coroutine will be wrapped in try-catch, it will |
| 1687 |
// be incompatible with SEH __try if present in a function. |
| 1688 |
if (!S.getLangOpts().Borland && Fn.FirstSEHTryLoc.isValid()) { |
| 1689 |
S.Diag(Fn.FirstSEHTryLoc, diag::err_seh_in_a_coroutine_with_cxx_exceptions); |
| 1690 |
S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) |
| 1691 |
<< Fn.getFirstCoroutineStmtKeyword(); |
| 1692 |
return false; |
| 1693 |
} |
| 1694 |
|
| 1695 |
this->OnException = UnhandledException.get(); |
| 1696 |
return true; |
| 1697 |
} |
| 1698 |
|
| 1699 |
bool CoroutineStmtBuilder::makeReturnObject() { |
| 1700 |
// [dcl.fct.def.coroutine]p7 |
| 1701 |
// The expression promise.get_return_object() is used to initialize the |
| 1702 |
// returned reference or prvalue result object of a call to a coroutine. |
| 1703 |
ExprResult ReturnObject = buildPromiseCall(S, Fn.CoroutinePromise, Loc, |
| 1704 |
"get_return_object", std::nullopt); |
| 1705 |
if (ReturnObject.isInvalid()) |
| 1706 |
return false; |
| 1707 |
|
| 1708 |
this->ReturnValue = ReturnObject.get(); |
| 1709 |
return true; |
| 1710 |
} |
| 1711 |
|
| 1712 |
static void noteMemberDeclaredHere(Sema &S, Expr *E, FunctionScopeInfo &Fn) { |
| 1713 |
if (auto *MbrRef = dyn_cast<CXXMemberCallExpr>(E)) { |
| 1714 |
auto *MethodDecl = MbrRef->getMethodDecl(); |
| 1715 |
S.Diag(MethodDecl->getLocation(), diag::note_member_declared_here) |
| 1716 |
<< MethodDecl; |
| 1717 |
} |
| 1718 |
S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here) |
| 1719 |
<< Fn.getFirstCoroutineStmtKeyword(); |
| 1720 |
} |
| 1721 |
|
| 1722 |
bool CoroutineStmtBuilder::makeGroDeclAndReturnStmt() { |
| 1723 |
assert(!IsPromiseDependentType && |
| 1724 |
"cannot make statement while the promise type is dependent"); |
| 1725 |
assert(this->ReturnValue && "ReturnValue must be already formed"); |
| 1726 |
|
| 1727 |
QualType const GroType = this->ReturnValue->getType(); |
| 1728 |
assert(!GroType->isDependentType() && |
| 1729 |
"get_return_object type must no longer be dependent"); |
| 1730 |
|
| 1731 |
QualType const FnRetType = FD.getReturnType(); |
| 1732 |
assert(!FnRetType->isDependentType() && |
| 1733 |
"get_return_object type must no longer be dependent"); |
| 1734 |
|
| 1735 |
if (FnRetType->isVoidType()) { |
| 1736 |
ExprResult Res = |
| 1737 |
S.ActOnFinishFullExpr(this->ReturnValue, Loc, /*DiscardedValue*/ false); |
| 1738 |
if (Res.isInvalid()) |
| 1739 |
return false; |
| 1740 |
|
| 1741 |
return true; |
| 1742 |
} |
| 1743 |
|
| 1744 |
if (GroType->isVoidType()) { |
| 1745 |
// Trigger a nice error message. |
| 1746 |
InitializedEntity Entity = |
| 1747 |
InitializedEntity::InitializeResult(Loc, FnRetType); |
| 1748 |
S.PerformCopyInitialization(Entity, SourceLocation(), ReturnValue); |
| 1749 |
noteMemberDeclaredHere(S, ReturnValue, Fn); |
| 1750 |
return false; |
| 1751 |
} |
| 1752 |
|
| 1753 |
StmtResult ReturnStmt = S.BuildReturnStmt(Loc, ReturnValue); |
| 1754 |
if (ReturnStmt.isInvalid()) { |
| 1755 |
noteMemberDeclaredHere(S, ReturnValue, Fn); |
| 1756 |
return false; |
| 1757 |
} |
| 1758 |
|
| 1759 |
this->ReturnStmt = ReturnStmt.get(); |
| 1760 |
return true; |
| 1761 |
} |
| 1762 |
|
| 1763 |
// Create a static_cast\<T&&>(expr). |
| 1764 |
static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) { |
| 1765 |
if (T.isNull()) |
| 1766 |
T = E->getType(); |
| 1767 |
QualType TargetType = S.BuildReferenceType( |
| 1768 |
T, /*SpelledAsLValue*/ false, SourceLocation(), DeclarationName()); |
| 1769 |
SourceLocation ExprLoc = E->getBeginLoc(); |
| 1770 |
TypeSourceInfo *TargetLoc = |
| 1771 |
S.Context.getTrivialTypeSourceInfo(TargetType, ExprLoc); |
| 1772 |
|
| 1773 |
return S |
| 1774 |
.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E, |
| 1775 |
SourceRange(ExprLoc, ExprLoc), E->getSourceRange()) |
| 1776 |
.get(); |
| 1777 |
} |
| 1778 |
|
| 1779 |
/// Build a variable declaration for move parameter. |
| 1780 |
static VarDecl *buildVarDecl(Sema &S, SourceLocation Loc, QualType Type, |
| 1781 |
IdentifierInfo *II) { |
| 1782 |
TypeSourceInfo *TInfo = S.Context.getTrivialTypeSourceInfo(Type, Loc); |
| 1783 |
VarDecl *Decl = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, II, Type, |
| 1784 |
TInfo, SC_None); |
| 1785 |
Decl->setImplicit(); |
| 1786 |
return Decl; |
| 1787 |
} |
| 1788 |
|
| 1789 |
// Build statements that move coroutine function parameters to the coroutine |
| 1790 |
// frame, and store them on the function scope info. |
| 1791 |
bool Sema::buildCoroutineParameterMoves(SourceLocation Loc) { |
| 1792 |
assert(isa<FunctionDecl>(CurContext) && "not in a function scope"); |
| 1793 |
auto *FD = cast<FunctionDecl>(CurContext); |
| 1794 |
|
| 1795 |
auto *ScopeInfo = getCurFunction(); |
| 1796 |
if (!ScopeInfo->CoroutineParameterMoves.empty()) |
| 1797 |
return false; |
| 1798 |
|
| 1799 |
// [dcl.fct.def.coroutine]p13 |
| 1800 |
// When a coroutine is invoked, after initializing its parameters |
| 1801 |
// ([expr.call]), a copy is created for each coroutine parameter. For a |
| 1802 |
// parameter of type cv T, the copy is a variable of type cv T with |
| 1803 |
// automatic storage duration that is direct-initialized from an xvalue of |
| 1804 |
// type T referring to the parameter. |
| 1805 |
for (auto *PD : FD->parameters()) { |
| 1806 |
if (PD->getType()->isDependentType()) |
| 1807 |
continue; |
| 1808 |
|
| 1809 |
ExprResult PDRefExpr = |
| 1810 |
BuildDeclRefExpr(PD, PD->getType().getNonReferenceType(), |
| 1811 |
ExprValueKind::VK_LValue, Loc); // FIXME: scope? |
| 1812 |
if (PDRefExpr.isInvalid()) |
| 1813 |
return false; |
| 1814 |
|
| 1815 |
Expr *CExpr = nullptr; |
| 1816 |
if (PD->getType()->getAsCXXRecordDecl() || |
| 1817 |
PD->getType()->isRValueReferenceType()) |
| 1818 |
CExpr = castForMoving(*this, PDRefExpr.get()); |
| 1819 |
else |
| 1820 |
CExpr = PDRefExpr.get(); |
| 1821 |
// [dcl.fct.def.coroutine]p13 |
| 1822 |
// The initialization and destruction of each parameter copy occurs in the |
| 1823 |
// context of the called coroutine. |
| 1824 |
auto *D = buildVarDecl(*this, Loc, PD->getType(), PD->getIdentifier()); |
| 1825 |
AddInitializerToDecl(D, CExpr, /*DirectInit=*/true); |
| 1826 |
|
| 1827 |
// Convert decl to a statement. |
| 1828 |
StmtResult Stmt = ActOnDeclStmt(ConvertDeclToDeclGroup(D), Loc, Loc); |
| 1829 |
if (Stmt.isInvalid()) |
| 1830 |
return false; |
| 1831 |
|
| 1832 |
ScopeInfo->CoroutineParameterMoves.insert(std::make_pair(PD, Stmt.get())); |
| 1833 |
} |
| 1834 |
return true; |
| 1835 |
} |
| 1836 |
|
| 1837 |
StmtResult Sema::BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) { |
| 1838 |
CoroutineBodyStmt *Res = CoroutineBodyStmt::Create(Context, Args); |
| 1839 |
if (!Res) |
| 1840 |
return StmtError(); |
| 1841 |
return Res; |
| 1842 |
} |
| 1843 |
|
| 1844 |
ClassTemplateDecl *Sema::lookupCoroutineTraits(SourceLocation KwLoc, |
| 1845 |
SourceLocation FuncLoc, |
| 1846 |
NamespaceDecl *&Namespace) { |
| 1847 |
if (!StdCoroutineTraitsCache) { |
| 1848 |
// Because coroutines moved from std::experimental in the TS to std in |
| 1849 |
// C++20, we look in both places to give users time to transition their |
| 1850 |
// TS-specific code to C++20. Diagnostics are given when the TS usage is |
| 1851 |
// discovered. |
| 1852 |
// TODO: Become stricter when <experimental/coroutine> is removed. |
| 1853 |
|
| 1854 |
IdentifierInfo const &TraitIdent = |
| 1855 |
PP.getIdentifierTable().get("coroutine_traits"); |
| 1856 |
|
| 1857 |
NamespaceDecl *StdSpace = getStdNamespace(); |
| 1858 |
LookupResult ResStd(*this, &TraitIdent, FuncLoc, LookupOrdinaryName); |
| 1859 |
bool InStd = StdSpace && LookupQualifiedName(ResStd, StdSpace); |
| 1860 |
|
| 1861 |
NamespaceDecl *ExpSpace = lookupStdExperimentalNamespace(); |
| 1862 |
LookupResult ResExp(*this, &TraitIdent, FuncLoc, LookupOrdinaryName); |
| 1863 |
bool InExp = ExpSpace && LookupQualifiedName(ResExp, ExpSpace); |
| 1864 |
|
| 1865 |
if (!InStd && !InExp) { |
| 1866 |
// The goggles, they found nothing! |
| 1867 |
Diag(KwLoc, diag::err_implied_coroutine_type_not_found) |
| 1868 |
<< "std::coroutine_traits"; |
| 1869 |
return nullptr; |
| 1870 |
} |
| 1871 |
|
| 1872 |
// Prefer ::std to std::experimental. |
| 1873 |
LookupResult &Result = InStd ? ResStd : ResExp; |
| 1874 |
CoroTraitsNamespaceCache = InStd ? StdSpace : ExpSpace; |
| 1875 |
|
| 1876 |
// coroutine_traits is required to be a class template. |
| 1877 |
StdCoroutineTraitsCache = Result.getAsSingle<ClassTemplateDecl>(); |
| 1878 |
if (!StdCoroutineTraitsCache) { |
| 1879 |
Result.suppressDiagnostics(); |
| 1880 |
NamedDecl *Found = *Result.begin(); |
| 1881 |
Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits); |
| 1882 |
return nullptr; |
| 1883 |
} |
| 1884 |
|
| 1885 |
if (InExp) { |
| 1886 |
// Found in std::experimental |
| 1887 |
Diag(KwLoc, diag::warn_deprecated_coroutine_namespace) |
| 1888 |
<< "coroutine_traits"; |
| 1889 |
ResExp.suppressDiagnostics(); |
| 1890 |
NamedDecl *Found = *ResExp.begin(); |
| 1891 |
Diag(Found->getLocation(), diag::note_entity_declared_at) << Found; |
| 1892 |
|
| 1893 |
if (InStd && |
| 1894 |
StdCoroutineTraitsCache != ResExp.getAsSingle<ClassTemplateDecl>()) { |
| 1895 |
// Also found something different in std |
| 1896 |
Diag(KwLoc, |
| 1897 |
diag::err_mixed_use_std_and_experimental_namespace_for_coroutine); |
| 1898 |
Diag(StdCoroutineTraitsCache->getLocation(), |
| 1899 |
diag::note_entity_declared_at) |
| 1900 |
<< StdCoroutineTraitsCache; |
| 1901 |
|
| 1902 |
return nullptr; |
| 1903 |
} |
| 1904 |
} |
| 1905 |
} |
| 1906 |
Namespace = CoroTraitsNamespaceCache; |
| 1907 |
return StdCoroutineTraitsCache; |
| 1908 |
} |