1 //===--- SemaLambda.cpp - Semantic Analysis for C++11 Lambdas -------------===// 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++ lambda expressions. 10 // 11 //===----------------------------------------------------------------------===// 12 #include "clang/Sema/DeclSpec.h" 13 #include "TypeLocBuilder.h" 14 #include "clang/AST/ASTLambda.h" 15 #include "clang/AST/ExprCXX.h" 16 #include "clang/Basic/TargetInfo.h" 17 #include "clang/Sema/Initialization.h" 18 #include "clang/Sema/Lookup.h" 19 #include "clang/Sema/Scope.h" 20 #include "clang/Sema/ScopeInfo.h" 21 #include "clang/Sema/SemaInternal.h" 22 #include "clang/Sema/SemaLambda.h" 23 #include "llvm/ADT/STLExtras.h" 24 using namespace clang; 25 using namespace sema; 26 27 /// Examines the FunctionScopeInfo stack to determine the nearest 28 /// enclosing lambda (to the current lambda) that is 'capture-ready' for 29 /// the variable referenced in the current lambda (i.e. \p VarToCapture). 30 /// If successful, returns the index into Sema's FunctionScopeInfo stack 31 /// of the capture-ready lambda's LambdaScopeInfo. 32 /// 33 /// Climbs down the stack of lambdas (deepest nested lambda - i.e. current 34 /// lambda - is on top) to determine the index of the nearest enclosing/outer 35 /// lambda that is ready to capture the \p VarToCapture being referenced in 36 /// the current lambda. 37 /// As we climb down the stack, we want the index of the first such lambda - 38 /// that is the lambda with the highest index that is 'capture-ready'. 39 /// 40 /// A lambda 'L' is capture-ready for 'V' (var or this) if: 41 /// - its enclosing context is non-dependent 42 /// - and if the chain of lambdas between L and the lambda in which 43 /// V is potentially used (i.e. the lambda at the top of the scope info 44 /// stack), can all capture or have already captured V. 45 /// If \p VarToCapture is 'null' then we are trying to capture 'this'. 46 /// 47 /// Note that a lambda that is deemed 'capture-ready' still needs to be checked 48 /// for whether it is 'capture-capable' (see 49 /// getStackIndexOfNearestEnclosingCaptureCapableLambda), before it can truly 50 /// capture. 51 /// 52 /// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a 53 /// LambdaScopeInfo inherits from). The current/deepest/innermost lambda 54 /// is at the top of the stack and has the highest index. 55 /// \param VarToCapture - the variable to capture. If NULL, capture 'this'. 56 /// 57 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains 58 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda 59 /// which is capture-ready. If the return value evaluates to 'false' then 60 /// no lambda is capture-ready for \p VarToCapture. 61 62 static inline Optional<unsigned> 63 getStackIndexOfNearestEnclosingCaptureReadyLambda( 64 ArrayRef<const clang::sema::FunctionScopeInfo *> FunctionScopes, 65 VarDecl *VarToCapture) { 66 // Label failure to capture. 67 const Optional<unsigned> NoLambdaIsCaptureReady; 68 69 // Ignore all inner captured regions. 70 unsigned CurScopeIndex = FunctionScopes.size() - 1; 71 while (CurScopeIndex > 0 && isa<clang::sema::CapturedRegionScopeInfo>( 72 FunctionScopes[CurScopeIndex])) 73 --CurScopeIndex; 74 assert( 75 isa<clang::sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]) && 76 "The function on the top of sema's function-info stack must be a lambda"); 77 78 // If VarToCapture is null, we are attempting to capture 'this'. 79 const bool IsCapturingThis = !VarToCapture; 80 const bool IsCapturingVariable = !IsCapturingThis; 81 82 // Start with the current lambda at the top of the stack (highest index). 83 DeclContext *EnclosingDC = 84 cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex])->CallOperator; 85 86 do { 87 const clang::sema::LambdaScopeInfo *LSI = 88 cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]); 89 // IF we have climbed down to an intervening enclosing lambda that contains 90 // the variable declaration - it obviously can/must not capture the 91 // variable. 92 // Since its enclosing DC is dependent, all the lambdas between it and the 93 // innermost nested lambda are dependent (otherwise we wouldn't have 94 // arrived here) - so we don't yet have a lambda that can capture the 95 // variable. 96 if (IsCapturingVariable && 97 VarToCapture->getDeclContext()->Equals(EnclosingDC)) 98 return NoLambdaIsCaptureReady; 99 100 // For an enclosing lambda to be capture ready for an entity, all 101 // intervening lambda's have to be able to capture that entity. If even 102 // one of the intervening lambda's is not capable of capturing the entity 103 // then no enclosing lambda can ever capture that entity. 104 // For e.g. 105 // const int x = 10; 106 // [=](auto a) { #1 107 // [](auto b) { #2 <-- an intervening lambda that can never capture 'x' 108 // [=](auto c) { #3 109 // f(x, c); <-- can not lead to x's speculative capture by #1 or #2 110 // }; }; }; 111 // If they do not have a default implicit capture, check to see 112 // if the entity has already been explicitly captured. 113 // If even a single dependent enclosing lambda lacks the capability 114 // to ever capture this variable, there is no further enclosing 115 // non-dependent lambda that can capture this variable. 116 if (LSI->ImpCaptureStyle == sema::LambdaScopeInfo::ImpCap_None) { 117 if (IsCapturingVariable && !LSI->isCaptured(VarToCapture)) 118 return NoLambdaIsCaptureReady; 119 if (IsCapturingThis && !LSI->isCXXThisCaptured()) 120 return NoLambdaIsCaptureReady; 121 } 122 EnclosingDC = getLambdaAwareParentOfDeclContext(EnclosingDC); 123 124 assert(CurScopeIndex); 125 --CurScopeIndex; 126 } while (!EnclosingDC->isTranslationUnit() && 127 EnclosingDC->isDependentContext() && 128 isLambdaCallOperator(EnclosingDC)); 129 130 assert(CurScopeIndex < (FunctionScopes.size() - 1)); 131 // If the enclosingDC is not dependent, then the immediately nested lambda 132 // (one index above) is capture-ready. 133 if (!EnclosingDC->isDependentContext()) 134 return CurScopeIndex + 1; 135 return NoLambdaIsCaptureReady; 136 } 137 138 /// Examines the FunctionScopeInfo stack to determine the nearest 139 /// enclosing lambda (to the current lambda) that is 'capture-capable' for 140 /// the variable referenced in the current lambda (i.e. \p VarToCapture). 141 /// If successful, returns the index into Sema's FunctionScopeInfo stack 142 /// of the capture-capable lambda's LambdaScopeInfo. 143 /// 144 /// Given the current stack of lambdas being processed by Sema and 145 /// the variable of interest, to identify the nearest enclosing lambda (to the 146 /// current lambda at the top of the stack) that can truly capture 147 /// a variable, it has to have the following two properties: 148 /// a) 'capture-ready' - be the innermost lambda that is 'capture-ready': 149 /// - climb down the stack (i.e. starting from the innermost and examining 150 /// each outer lambda step by step) checking if each enclosing 151 /// lambda can either implicitly or explicitly capture the variable. 152 /// Record the first such lambda that is enclosed in a non-dependent 153 /// context. If no such lambda currently exists return failure. 154 /// b) 'capture-capable' - make sure the 'capture-ready' lambda can truly 155 /// capture the variable by checking all its enclosing lambdas: 156 /// - check if all outer lambdas enclosing the 'capture-ready' lambda 157 /// identified above in 'a' can also capture the variable (this is done 158 /// via tryCaptureVariable for variables and CheckCXXThisCapture for 159 /// 'this' by passing in the index of the Lambda identified in step 'a') 160 /// 161 /// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a 162 /// LambdaScopeInfo inherits from). The current/deepest/innermost lambda 163 /// is at the top of the stack. 164 /// 165 /// \param VarToCapture - the variable to capture. If NULL, capture 'this'. 166 /// 167 /// 168 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains 169 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda 170 /// which is capture-capable. If the return value evaluates to 'false' then 171 /// no lambda is capture-capable for \p VarToCapture. 172 173 Optional<unsigned> clang::getStackIndexOfNearestEnclosingCaptureCapableLambda( 174 ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes, 175 VarDecl *VarToCapture, Sema &S) { 176 177 const Optional<unsigned> NoLambdaIsCaptureCapable; 178 179 const Optional<unsigned> OptionalStackIndex = 180 getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes, 181 VarToCapture); 182 if (!OptionalStackIndex) 183 return NoLambdaIsCaptureCapable; 184 185 const unsigned IndexOfCaptureReadyLambda = OptionalStackIndex.getValue(); 186 assert(((IndexOfCaptureReadyLambda != (FunctionScopes.size() - 1)) || 187 S.getCurGenericLambda()) && 188 "The capture ready lambda for a potential capture can only be the " 189 "current lambda if it is a generic lambda"); 190 191 const sema::LambdaScopeInfo *const CaptureReadyLambdaLSI = 192 cast<sema::LambdaScopeInfo>(FunctionScopes[IndexOfCaptureReadyLambda]); 193 194 // If VarToCapture is null, we are attempting to capture 'this' 195 const bool IsCapturingThis = !VarToCapture; 196 const bool IsCapturingVariable = !IsCapturingThis; 197 198 if (IsCapturingVariable) { 199 // Check if the capture-ready lambda can truly capture the variable, by 200 // checking whether all enclosing lambdas of the capture-ready lambda allow 201 // the capture - i.e. make sure it is capture-capable. 202 QualType CaptureType, DeclRefType; 203 const bool CanCaptureVariable = 204 !S.tryCaptureVariable(VarToCapture, 205 /*ExprVarIsUsedInLoc*/ SourceLocation(), 206 clang::Sema::TryCapture_Implicit, 207 /*EllipsisLoc*/ SourceLocation(), 208 /*BuildAndDiagnose*/ false, CaptureType, 209 DeclRefType, &IndexOfCaptureReadyLambda); 210 if (!CanCaptureVariable) 211 return NoLambdaIsCaptureCapable; 212 } else { 213 // Check if the capture-ready lambda can truly capture 'this' by checking 214 // whether all enclosing lambdas of the capture-ready lambda can capture 215 // 'this'. 216 const bool CanCaptureThis = 217 !S.CheckCXXThisCapture( 218 CaptureReadyLambdaLSI->PotentialThisCaptureLocation, 219 /*Explicit*/ false, /*BuildAndDiagnose*/ false, 220 &IndexOfCaptureReadyLambda); 221 if (!CanCaptureThis) 222 return NoLambdaIsCaptureCapable; 223 } 224 return IndexOfCaptureReadyLambda; 225 } 226 227 static inline TemplateParameterList * 228 getGenericLambdaTemplateParameterList(LambdaScopeInfo *LSI, Sema &SemaRef) { 229 if (!LSI->GLTemplateParameterList && !LSI->TemplateParams.empty()) { 230 LSI->GLTemplateParameterList = TemplateParameterList::Create( 231 SemaRef.Context, 232 /*Template kw loc*/ SourceLocation(), 233 /*L angle loc*/ LSI->ExplicitTemplateParamsRange.getBegin(), 234 LSI->TemplateParams, 235 /*R angle loc*/LSI->ExplicitTemplateParamsRange.getEnd(), 236 LSI->RequiresClause.get()); 237 } 238 return LSI->GLTemplateParameterList; 239 } 240 241 CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange, 242 TypeSourceInfo *Info, 243 bool KnownDependent, 244 LambdaCaptureDefault CaptureDefault) { 245 DeclContext *DC = CurContext; 246 while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext())) 247 DC = DC->getParent(); 248 bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(), 249 *this); 250 // Start constructing the lambda class. 251 CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, Info, 252 IntroducerRange.getBegin(), 253 KnownDependent, 254 IsGenericLambda, 255 CaptureDefault); 256 DC->addDecl(Class); 257 258 return Class; 259 } 260 261 /// Determine whether the given context is or is enclosed in an inline 262 /// function. 263 static bool isInInlineFunction(const DeclContext *DC) { 264 while (!DC->isFileContext()) { 265 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 266 if (FD->isInlined()) 267 return true; 268 269 DC = DC->getLexicalParent(); 270 } 271 272 return false; 273 } 274 275 std::tuple<MangleNumberingContext *, Decl *> 276 Sema::getCurrentMangleNumberContext(const DeclContext *DC) { 277 // Compute the context for allocating mangling numbers in the current 278 // expression, if the ABI requires them. 279 Decl *ManglingContextDecl = ExprEvalContexts.back().ManglingContextDecl; 280 281 enum ContextKind { 282 Normal, 283 DefaultArgument, 284 DataMember, 285 StaticDataMember, 286 InlineVariable, 287 VariableTemplate 288 } Kind = Normal; 289 290 // Default arguments of member function parameters that appear in a class 291 // definition, as well as the initializers of data members, receive special 292 // treatment. Identify them. 293 if (ManglingContextDecl) { 294 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ManglingContextDecl)) { 295 if (const DeclContext *LexicalDC 296 = Param->getDeclContext()->getLexicalParent()) 297 if (LexicalDC->isRecord()) 298 Kind = DefaultArgument; 299 } else if (VarDecl *Var = dyn_cast<VarDecl>(ManglingContextDecl)) { 300 if (Var->getDeclContext()->isRecord()) 301 Kind = StaticDataMember; 302 else if (Var->getMostRecentDecl()->isInline()) 303 Kind = InlineVariable; 304 else if (Var->getDescribedVarTemplate()) 305 Kind = VariableTemplate; 306 else if (auto *VTS = dyn_cast<VarTemplateSpecializationDecl>(Var)) { 307 if (!VTS->isExplicitSpecialization()) 308 Kind = VariableTemplate; 309 } 310 } else if (isa<FieldDecl>(ManglingContextDecl)) { 311 Kind = DataMember; 312 } 313 } 314 315 // Itanium ABI [5.1.7]: 316 // In the following contexts [...] the one-definition rule requires closure 317 // types in different translation units to "correspond": 318 bool IsInNonspecializedTemplate = 319 inTemplateInstantiation() || CurContext->isDependentContext(); 320 switch (Kind) { 321 case Normal: { 322 // -- the bodies of non-exported nonspecialized template functions 323 // -- the bodies of inline functions 324 if ((IsInNonspecializedTemplate && 325 !(ManglingContextDecl && isa<ParmVarDecl>(ManglingContextDecl))) || 326 isInInlineFunction(CurContext)) { 327 while (auto *CD = dyn_cast<CapturedDecl>(DC)) 328 DC = CD->getParent(); 329 return std::make_tuple(&Context.getManglingNumberContext(DC), nullptr); 330 } 331 332 return std::make_tuple(nullptr, nullptr); 333 } 334 335 case StaticDataMember: 336 // -- the initializers of nonspecialized static members of template classes 337 if (!IsInNonspecializedTemplate) 338 return std::make_tuple(nullptr, ManglingContextDecl); 339 // Fall through to get the current context. 340 LLVM_FALLTHROUGH; 341 342 case DataMember: 343 // -- the in-class initializers of class members 344 case DefaultArgument: 345 // -- default arguments appearing in class definitions 346 case InlineVariable: 347 // -- the initializers of inline variables 348 case VariableTemplate: 349 // -- the initializers of templated variables 350 return std::make_tuple( 351 &Context.getManglingNumberContext(ASTContext::NeedExtraManglingDecl, 352 ManglingContextDecl), 353 ManglingContextDecl); 354 } 355 356 llvm_unreachable("unexpected context"); 357 } 358 359 CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class, 360 SourceRange IntroducerRange, 361 TypeSourceInfo *MethodTypeInfo, 362 SourceLocation EndLoc, 363 ArrayRef<ParmVarDecl *> Params, 364 ConstexprSpecKind ConstexprKind, 365 Expr *TrailingRequiresClause) { 366 QualType MethodType = MethodTypeInfo->getType(); 367 TemplateParameterList *TemplateParams = 368 getGenericLambdaTemplateParameterList(getCurLambda(), *this); 369 // If a lambda appears in a dependent context or is a generic lambda (has 370 // template parameters) and has an 'auto' return type, deduce it to a 371 // dependent type. 372 if (Class->isDependentContext() || TemplateParams) { 373 const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>(); 374 QualType Result = FPT->getReturnType(); 375 if (Result->isUndeducedType()) { 376 Result = SubstAutoType(Result, Context.DependentTy); 377 MethodType = Context.getFunctionType(Result, FPT->getParamTypes(), 378 FPT->getExtProtoInfo()); 379 } 380 } 381 382 // C++11 [expr.prim.lambda]p5: 383 // The closure type for a lambda-expression has a public inline function 384 // call operator (13.5.4) whose parameters and return type are described by 385 // the lambda-expression's parameter-declaration-clause and 386 // trailing-return-type respectively. 387 DeclarationName MethodName 388 = Context.DeclarationNames.getCXXOperatorName(OO_Call); 389 DeclarationNameLoc MethodNameLoc; 390 MethodNameLoc.CXXOperatorName.BeginOpNameLoc 391 = IntroducerRange.getBegin().getRawEncoding(); 392 MethodNameLoc.CXXOperatorName.EndOpNameLoc 393 = IntroducerRange.getEnd().getRawEncoding(); 394 CXXMethodDecl *Method = CXXMethodDecl::Create( 395 Context, Class, EndLoc, 396 DeclarationNameInfo(MethodName, IntroducerRange.getBegin(), 397 MethodNameLoc), 398 MethodType, MethodTypeInfo, SC_None, 399 /*isInline=*/true, ConstexprKind, EndLoc, TrailingRequiresClause); 400 Method->setAccess(AS_public); 401 if (!TemplateParams) 402 Class->addDecl(Method); 403 404 // Temporarily set the lexical declaration context to the current 405 // context, so that the Scope stack matches the lexical nesting. 406 Method->setLexicalDeclContext(CurContext); 407 // Create a function template if we have a template parameter list 408 FunctionTemplateDecl *const TemplateMethod = TemplateParams ? 409 FunctionTemplateDecl::Create(Context, Class, 410 Method->getLocation(), MethodName, 411 TemplateParams, 412 Method) : nullptr; 413 if (TemplateMethod) { 414 TemplateMethod->setAccess(AS_public); 415 Method->setDescribedFunctionTemplate(TemplateMethod); 416 Class->addDecl(TemplateMethod); 417 TemplateMethod->setLexicalDeclContext(CurContext); 418 } 419 420 // Add parameters. 421 if (!Params.empty()) { 422 Method->setParams(Params); 423 CheckParmsForFunctionDef(Params, 424 /*CheckParameterNames=*/false); 425 426 for (auto P : Method->parameters()) 427 P->setOwningFunction(Method); 428 } 429 430 return Method; 431 } 432 433 void Sema::handleLambdaNumbering( 434 CXXRecordDecl *Class, CXXMethodDecl *Method, 435 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling) { 436 if (Mangling) { 437 bool HasKnownInternalLinkage; 438 unsigned ManglingNumber, DeviceManglingNumber; 439 Decl *ManglingContextDecl; 440 std::tie(HasKnownInternalLinkage, ManglingNumber, DeviceManglingNumber, 441 ManglingContextDecl) = Mangling.getValue(); 442 Class->setLambdaMangling(ManglingNumber, ManglingContextDecl, 443 HasKnownInternalLinkage); 444 Class->setDeviceLambdaManglingNumber(DeviceManglingNumber); 445 return; 446 } 447 448 auto getMangleNumberingContext = 449 [this](CXXRecordDecl *Class, 450 Decl *ManglingContextDecl) -> MangleNumberingContext * { 451 // Get mangle numbering context if there's any extra decl context. 452 if (ManglingContextDecl) 453 return &Context.getManglingNumberContext( 454 ASTContext::NeedExtraManglingDecl, ManglingContextDecl); 455 // Otherwise, from that lambda's decl context. 456 auto DC = Class->getDeclContext(); 457 while (auto *CD = dyn_cast<CapturedDecl>(DC)) 458 DC = CD->getParent(); 459 return &Context.getManglingNumberContext(DC); 460 }; 461 462 MangleNumberingContext *MCtx; 463 Decl *ManglingContextDecl; 464 std::tie(MCtx, ManglingContextDecl) = 465 getCurrentMangleNumberContext(Class->getDeclContext()); 466 bool HasKnownInternalLinkage = false; 467 if (!MCtx && getLangOpts().CUDA) { 468 // Force lambda numbering in CUDA/HIP as we need to name lambdas following 469 // ODR. Both device- and host-compilation need to have a consistent naming 470 // on kernel functions. As lambdas are potential part of these `__global__` 471 // function names, they needs numbering following ODR. 472 MCtx = getMangleNumberingContext(Class, ManglingContextDecl); 473 assert(MCtx && "Retrieving mangle numbering context failed!"); 474 HasKnownInternalLinkage = true; 475 } 476 if (MCtx) { 477 unsigned ManglingNumber = MCtx->getManglingNumber(Method); 478 Class->setLambdaMangling(ManglingNumber, ManglingContextDecl, 479 HasKnownInternalLinkage); 480 Class->setDeviceLambdaManglingNumber(MCtx->getDeviceManglingNumber(Method)); 481 } 482 } 483 484 void Sema::buildLambdaScope(LambdaScopeInfo *LSI, 485 CXXMethodDecl *CallOperator, 486 SourceRange IntroducerRange, 487 LambdaCaptureDefault CaptureDefault, 488 SourceLocation CaptureDefaultLoc, 489 bool ExplicitParams, 490 bool ExplicitResultType, 491 bool Mutable) { 492 LSI->CallOperator = CallOperator; 493 CXXRecordDecl *LambdaClass = CallOperator->getParent(); 494 LSI->Lambda = LambdaClass; 495 if (CaptureDefault == LCD_ByCopy) 496 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval; 497 else if (CaptureDefault == LCD_ByRef) 498 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref; 499 LSI->CaptureDefaultLoc = CaptureDefaultLoc; 500 LSI->IntroducerRange = IntroducerRange; 501 LSI->ExplicitParams = ExplicitParams; 502 LSI->Mutable = Mutable; 503 504 if (ExplicitResultType) { 505 LSI->ReturnType = CallOperator->getReturnType(); 506 507 if (!LSI->ReturnType->isDependentType() && 508 !LSI->ReturnType->isVoidType()) { 509 if (RequireCompleteType(CallOperator->getBeginLoc(), LSI->ReturnType, 510 diag::err_lambda_incomplete_result)) { 511 // Do nothing. 512 } 513 } 514 } else { 515 LSI->HasImplicitReturnType = true; 516 } 517 } 518 519 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) { 520 LSI->finishedExplicitCaptures(); 521 } 522 523 void Sema::ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc, 524 ArrayRef<NamedDecl *> TParams, 525 SourceLocation RAngleLoc, 526 ExprResult RequiresClause) { 527 LambdaScopeInfo *LSI = getCurLambda(); 528 assert(LSI && "Expected a lambda scope"); 529 assert(LSI->NumExplicitTemplateParams == 0 && 530 "Already acted on explicit template parameters"); 531 assert(LSI->TemplateParams.empty() && 532 "Explicit template parameters should come " 533 "before invented (auto) ones"); 534 assert(!TParams.empty() && 535 "No template parameters to act on"); 536 LSI->TemplateParams.append(TParams.begin(), TParams.end()); 537 LSI->NumExplicitTemplateParams = TParams.size(); 538 LSI->ExplicitTemplateParamsRange = {LAngleLoc, RAngleLoc}; 539 LSI->RequiresClause = RequiresClause; 540 } 541 542 void Sema::addLambdaParameters( 543 ArrayRef<LambdaIntroducer::LambdaCapture> Captures, 544 CXXMethodDecl *CallOperator, Scope *CurScope) { 545 // Introduce our parameters into the function scope 546 for (unsigned p = 0, NumParams = CallOperator->getNumParams(); 547 p < NumParams; ++p) { 548 ParmVarDecl *Param = CallOperator->getParamDecl(p); 549 550 // If this has an identifier, add it to the scope stack. 551 if (CurScope && Param->getIdentifier()) { 552 bool Error = false; 553 // Resolution of CWG 2211 in C++17 renders shadowing ill-formed, but we 554 // retroactively apply it. 555 for (const auto &Capture : Captures) { 556 if (Capture.Id == Param->getIdentifier()) { 557 Error = true; 558 Diag(Param->getLocation(), diag::err_parameter_shadow_capture); 559 Diag(Capture.Loc, diag::note_var_explicitly_captured_here) 560 << Capture.Id << true; 561 } 562 } 563 if (!Error) 564 CheckShadow(CurScope, Param); 565 566 PushOnScopeChains(Param, CurScope); 567 } 568 } 569 } 570 571 /// If this expression is an enumerator-like expression of some type 572 /// T, return the type T; otherwise, return null. 573 /// 574 /// Pointer comparisons on the result here should always work because 575 /// it's derived from either the parent of an EnumConstantDecl 576 /// (i.e. the definition) or the declaration returned by 577 /// EnumType::getDecl() (i.e. the definition). 578 static EnumDecl *findEnumForBlockReturn(Expr *E) { 579 // An expression is an enumerator-like expression of type T if, 580 // ignoring parens and parens-like expressions: 581 E = E->IgnoreParens(); 582 583 // - it is an enumerator whose enum type is T or 584 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 585 if (EnumConstantDecl *D 586 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 587 return cast<EnumDecl>(D->getDeclContext()); 588 } 589 return nullptr; 590 } 591 592 // - it is a comma expression whose RHS is an enumerator-like 593 // expression of type T or 594 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 595 if (BO->getOpcode() == BO_Comma) 596 return findEnumForBlockReturn(BO->getRHS()); 597 return nullptr; 598 } 599 600 // - it is a statement-expression whose value expression is an 601 // enumerator-like expression of type T or 602 if (StmtExpr *SE = dyn_cast<StmtExpr>(E)) { 603 if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back())) 604 return findEnumForBlockReturn(last); 605 return nullptr; 606 } 607 608 // - it is a ternary conditional operator (not the GNU ?: 609 // extension) whose second and third operands are 610 // enumerator-like expressions of type T or 611 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 612 if (EnumDecl *ED = findEnumForBlockReturn(CO->getTrueExpr())) 613 if (ED == findEnumForBlockReturn(CO->getFalseExpr())) 614 return ED; 615 return nullptr; 616 } 617 618 // (implicitly:) 619 // - it is an implicit integral conversion applied to an 620 // enumerator-like expression of type T or 621 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 622 // We can sometimes see integral conversions in valid 623 // enumerator-like expressions. 624 if (ICE->getCastKind() == CK_IntegralCast) 625 return findEnumForBlockReturn(ICE->getSubExpr()); 626 627 // Otherwise, just rely on the type. 628 } 629 630 // - it is an expression of that formal enum type. 631 if (const EnumType *ET = E->getType()->getAs<EnumType>()) { 632 return ET->getDecl(); 633 } 634 635 // Otherwise, nope. 636 return nullptr; 637 } 638 639 /// Attempt to find a type T for which the returned expression of the 640 /// given statement is an enumerator-like expression of that type. 641 static EnumDecl *findEnumForBlockReturn(ReturnStmt *ret) { 642 if (Expr *retValue = ret->getRetValue()) 643 return findEnumForBlockReturn(retValue); 644 return nullptr; 645 } 646 647 /// Attempt to find a common type T for which all of the returned 648 /// expressions in a block are enumerator-like expressions of that 649 /// type. 650 static EnumDecl *findCommonEnumForBlockReturns(ArrayRef<ReturnStmt*> returns) { 651 ArrayRef<ReturnStmt*>::iterator i = returns.begin(), e = returns.end(); 652 653 // Try to find one for the first return. 654 EnumDecl *ED = findEnumForBlockReturn(*i); 655 if (!ED) return nullptr; 656 657 // Check that the rest of the returns have the same enum. 658 for (++i; i != e; ++i) { 659 if (findEnumForBlockReturn(*i) != ED) 660 return nullptr; 661 } 662 663 // Never infer an anonymous enum type. 664 if (!ED->hasNameForLinkage()) return nullptr; 665 666 return ED; 667 } 668 669 /// Adjust the given return statements so that they formally return 670 /// the given type. It should require, at most, an IntegralCast. 671 static void adjustBlockReturnsToEnum(Sema &S, ArrayRef<ReturnStmt*> returns, 672 QualType returnType) { 673 for (ArrayRef<ReturnStmt*>::iterator 674 i = returns.begin(), e = returns.end(); i != e; ++i) { 675 ReturnStmt *ret = *i; 676 Expr *retValue = ret->getRetValue(); 677 if (S.Context.hasSameType(retValue->getType(), returnType)) 678 continue; 679 680 // Right now we only support integral fixup casts. 681 assert(returnType->isIntegralOrUnscopedEnumerationType()); 682 assert(retValue->getType()->isIntegralOrUnscopedEnumerationType()); 683 684 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(retValue); 685 686 Expr *E = (cleanups ? cleanups->getSubExpr() : retValue); 687 E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast, E, 688 /*base path*/ nullptr, VK_RValue, 689 FPOptionsOverride()); 690 if (cleanups) { 691 cleanups->setSubExpr(E); 692 } else { 693 ret->setRetValue(E); 694 } 695 } 696 } 697 698 void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) { 699 assert(CSI.HasImplicitReturnType); 700 // If it was ever a placeholder, it had to been deduced to DependentTy. 701 assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType()); 702 assert((!isa<LambdaScopeInfo>(CSI) || !getLangOpts().CPlusPlus14) && 703 "lambda expressions use auto deduction in C++14 onwards"); 704 705 // C++ core issue 975: 706 // If a lambda-expression does not include a trailing-return-type, 707 // it is as if the trailing-return-type denotes the following type: 708 // - if there are no return statements in the compound-statement, 709 // or all return statements return either an expression of type 710 // void or no expression or braced-init-list, the type void; 711 // - otherwise, if all return statements return an expression 712 // and the types of the returned expressions after 713 // lvalue-to-rvalue conversion (4.1 [conv.lval]), 714 // array-to-pointer conversion (4.2 [conv.array]), and 715 // function-to-pointer conversion (4.3 [conv.func]) are the 716 // same, that common type; 717 // - otherwise, the program is ill-formed. 718 // 719 // C++ core issue 1048 additionally removes top-level cv-qualifiers 720 // from the types of returned expressions to match the C++14 auto 721 // deduction rules. 722 // 723 // In addition, in blocks in non-C++ modes, if all of the return 724 // statements are enumerator-like expressions of some type T, where 725 // T has a name for linkage, then we infer the return type of the 726 // block to be that type. 727 728 // First case: no return statements, implicit void return type. 729 ASTContext &Ctx = getASTContext(); 730 if (CSI.Returns.empty()) { 731 // It's possible there were simply no /valid/ return statements. 732 // In this case, the first one we found may have at least given us a type. 733 if (CSI.ReturnType.isNull()) 734 CSI.ReturnType = Ctx.VoidTy; 735 return; 736 } 737 738 // Second case: at least one return statement has dependent type. 739 // Delay type checking until instantiation. 740 assert(!CSI.ReturnType.isNull() && "We should have a tentative return type."); 741 if (CSI.ReturnType->isDependentType()) 742 return; 743 744 // Try to apply the enum-fuzz rule. 745 if (!getLangOpts().CPlusPlus) { 746 assert(isa<BlockScopeInfo>(CSI)); 747 const EnumDecl *ED = findCommonEnumForBlockReturns(CSI.Returns); 748 if (ED) { 749 CSI.ReturnType = Context.getTypeDeclType(ED); 750 adjustBlockReturnsToEnum(*this, CSI.Returns, CSI.ReturnType); 751 return; 752 } 753 } 754 755 // Third case: only one return statement. Don't bother doing extra work! 756 if (CSI.Returns.size() == 1) 757 return; 758 759 // General case: many return statements. 760 // Check that they all have compatible return types. 761 762 // We require the return types to strictly match here. 763 // Note that we've already done the required promotions as part of 764 // processing the return statement. 765 for (const ReturnStmt *RS : CSI.Returns) { 766 const Expr *RetE = RS->getRetValue(); 767 768 QualType ReturnType = 769 (RetE ? RetE->getType() : Context.VoidTy).getUnqualifiedType(); 770 if (Context.getCanonicalFunctionResultType(ReturnType) == 771 Context.getCanonicalFunctionResultType(CSI.ReturnType)) { 772 // Use the return type with the strictest possible nullability annotation. 773 auto RetTyNullability = ReturnType->getNullability(Ctx); 774 auto BlockNullability = CSI.ReturnType->getNullability(Ctx); 775 if (BlockNullability && 776 (!RetTyNullability || 777 hasWeakerNullability(*RetTyNullability, *BlockNullability))) 778 CSI.ReturnType = ReturnType; 779 continue; 780 } 781 782 // FIXME: This is a poor diagnostic for ReturnStmts without expressions. 783 // TODO: It's possible that the *first* return is the divergent one. 784 Diag(RS->getBeginLoc(), 785 diag::err_typecheck_missing_return_type_incompatible) 786 << ReturnType << CSI.ReturnType << isa<LambdaScopeInfo>(CSI); 787 // Continue iterating so that we keep emitting diagnostics. 788 } 789 } 790 791 QualType Sema::buildLambdaInitCaptureInitialization( 792 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, 793 Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool IsDirectInit, 794 Expr *&Init) { 795 // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to 796 // deduce against. 797 QualType DeductType = Context.getAutoDeductType(); 798 TypeLocBuilder TLB; 799 AutoTypeLoc TL = TLB.push<AutoTypeLoc>(DeductType); 800 TL.setNameLoc(Loc); 801 if (ByRef) { 802 DeductType = BuildReferenceType(DeductType, true, Loc, Id); 803 assert(!DeductType.isNull() && "can't build reference to auto"); 804 TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc); 805 } 806 if (EllipsisLoc.isValid()) { 807 if (Init->containsUnexpandedParameterPack()) { 808 Diag(EllipsisLoc, getLangOpts().CPlusPlus20 809 ? diag::warn_cxx17_compat_init_capture_pack 810 : diag::ext_init_capture_pack); 811 DeductType = Context.getPackExpansionType(DeductType, NumExpansions, 812 /*ExpectPackInType=*/false); 813 TLB.push<PackExpansionTypeLoc>(DeductType).setEllipsisLoc(EllipsisLoc); 814 } else { 815 // Just ignore the ellipsis for now and form a non-pack variable. We'll 816 // diagnose this later when we try to capture it. 817 } 818 } 819 TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType); 820 821 // Deduce the type of the init capture. 822 QualType DeducedType = deduceVarTypeFromInitializer( 823 /*VarDecl*/nullptr, DeclarationName(Id), DeductType, TSI, 824 SourceRange(Loc, Loc), IsDirectInit, Init); 825 if (DeducedType.isNull()) 826 return QualType(); 827 828 // Are we a non-list direct initialization? 829 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 830 831 // Perform initialization analysis and ensure any implicit conversions 832 // (such as lvalue-to-rvalue) are enforced. 833 InitializedEntity Entity = 834 InitializedEntity::InitializeLambdaCapture(Id, DeducedType, Loc); 835 InitializationKind Kind = 836 IsDirectInit 837 ? (CXXDirectInit ? InitializationKind::CreateDirect( 838 Loc, Init->getBeginLoc(), Init->getEndLoc()) 839 : InitializationKind::CreateDirectList(Loc)) 840 : InitializationKind::CreateCopy(Loc, Init->getBeginLoc()); 841 842 MultiExprArg Args = Init; 843 if (CXXDirectInit) 844 Args = 845 MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs()); 846 QualType DclT; 847 InitializationSequence InitSeq(*this, Entity, Kind, Args); 848 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 849 850 if (Result.isInvalid()) 851 return QualType(); 852 853 Init = Result.getAs<Expr>(); 854 return DeducedType; 855 } 856 857 VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc, 858 QualType InitCaptureType, 859 SourceLocation EllipsisLoc, 860 IdentifierInfo *Id, 861 unsigned InitStyle, Expr *Init) { 862 // FIXME: Retain the TypeSourceInfo from buildLambdaInitCaptureInitialization 863 // rather than reconstructing it here. 864 TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType, Loc); 865 if (auto PETL = TSI->getTypeLoc().getAs<PackExpansionTypeLoc>()) 866 PETL.setEllipsisLoc(EllipsisLoc); 867 868 // Create a dummy variable representing the init-capture. This is not actually 869 // used as a variable, and only exists as a way to name and refer to the 870 // init-capture. 871 // FIXME: Pass in separate source locations for '&' and identifier. 872 VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc, 873 Loc, Id, InitCaptureType, TSI, SC_Auto); 874 NewVD->setInitCapture(true); 875 NewVD->setReferenced(true); 876 // FIXME: Pass in a VarDecl::InitializationStyle. 877 NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle)); 878 NewVD->markUsed(Context); 879 NewVD->setInit(Init); 880 if (NewVD->isParameterPack()) 881 getCurLambda()->LocalPacks.push_back(NewVD); 882 return NewVD; 883 } 884 885 void Sema::addInitCapture(LambdaScopeInfo *LSI, VarDecl *Var) { 886 assert(Var->isInitCapture() && "init capture flag should be set"); 887 LSI->addCapture(Var, /*isBlock*/false, Var->getType()->isReferenceType(), 888 /*isNested*/false, Var->getLocation(), SourceLocation(), 889 Var->getType(), /*Invalid*/false); 890 } 891 892 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, 893 Declarator &ParamInfo, 894 Scope *CurScope) { 895 LambdaScopeInfo *const LSI = getCurLambda(); 896 assert(LSI && "LambdaScopeInfo should be on stack!"); 897 898 // Determine if we're within a context where we know that the lambda will 899 // be dependent, because there are template parameters in scope. 900 bool KnownDependent; 901 if (LSI->NumExplicitTemplateParams > 0) { 902 auto *TemplateParamScope = CurScope->getTemplateParamParent(); 903 assert(TemplateParamScope && 904 "Lambda with explicit template param list should establish a " 905 "template param scope"); 906 assert(TemplateParamScope->getParent()); 907 KnownDependent = TemplateParamScope->getParent() 908 ->getTemplateParamParent() != nullptr; 909 } else { 910 KnownDependent = CurScope->getTemplateParamParent() != nullptr; 911 } 912 913 // Determine the signature of the call operator. 914 TypeSourceInfo *MethodTyInfo; 915 bool ExplicitParams = true; 916 bool ExplicitResultType = true; 917 bool ContainsUnexpandedParameterPack = false; 918 SourceLocation EndLoc; 919 SmallVector<ParmVarDecl *, 8> Params; 920 if (ParamInfo.getNumTypeObjects() == 0) { 921 // C++11 [expr.prim.lambda]p4: 922 // If a lambda-expression does not include a lambda-declarator, it is as 923 // if the lambda-declarator were (). 924 FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention( 925 /*IsVariadic=*/false, /*IsCXXMethod=*/true)); 926 EPI.HasTrailingReturn = true; 927 EPI.TypeQuals.addConst(); 928 LangAS AS = getDefaultCXXMethodAddrSpace(); 929 if (AS != LangAS::Default) 930 EPI.TypeQuals.addAddressSpace(AS); 931 932 // C++1y [expr.prim.lambda]: 933 // The lambda return type is 'auto', which is replaced by the 934 // trailing-return type if provided and/or deduced from 'return' 935 // statements 936 // We don't do this before C++1y, because we don't support deduced return 937 // types there. 938 QualType DefaultTypeForNoTrailingReturn = 939 getLangOpts().CPlusPlus14 ? Context.getAutoDeductType() 940 : Context.DependentTy; 941 QualType MethodTy = 942 Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI); 943 MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy); 944 ExplicitParams = false; 945 ExplicitResultType = false; 946 EndLoc = Intro.Range.getEnd(); 947 } else { 948 assert(ParamInfo.isFunctionDeclarator() && 949 "lambda-declarator is a function"); 950 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo(); 951 952 // C++11 [expr.prim.lambda]p5: 953 // This function call operator is declared const (9.3.1) if and only if 954 // the lambda-expression's parameter-declaration-clause is not followed 955 // by mutable. It is neither virtual nor declared volatile. [...] 956 if (!FTI.hasMutableQualifier()) { 957 FTI.getOrCreateMethodQualifiers().SetTypeQual(DeclSpec::TQ_const, 958 SourceLocation()); 959 } 960 961 MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope); 962 assert(MethodTyInfo && "no type from lambda-declarator"); 963 EndLoc = ParamInfo.getSourceRange().getEnd(); 964 965 ExplicitResultType = FTI.hasTrailingReturnType(); 966 967 if (FTIHasNonVoidParameters(FTI)) { 968 Params.reserve(FTI.NumParams); 969 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) 970 Params.push_back(cast<ParmVarDecl>(FTI.Params[i].Param)); 971 } 972 973 // Check for unexpanded parameter packs in the method type. 974 if (MethodTyInfo->getType()->containsUnexpandedParameterPack()) 975 DiagnoseUnexpandedParameterPack(Intro.Range.getBegin(), MethodTyInfo, 976 UPPC_DeclarationType); 977 } 978 979 CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo, 980 KnownDependent, Intro.Default); 981 CXXMethodDecl *Method = 982 startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params, 983 ParamInfo.getDeclSpec().getConstexprSpecifier(), 984 ParamInfo.getTrailingRequiresClause()); 985 if (ExplicitParams) 986 CheckCXXDefaultArguments(Method); 987 988 // This represents the function body for the lambda function, check if we 989 // have to apply optnone due to a pragma. 990 AddRangeBasedOptnone(Method); 991 992 // code_seg attribute on lambda apply to the method. 993 if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true)) 994 Method->addAttr(A); 995 996 // Attributes on the lambda apply to the method. 997 ProcessDeclAttributes(CurScope, Method, ParamInfo); 998 999 // CUDA lambdas get implicit host and device attributes. 1000 if (getLangOpts().CUDA) 1001 CUDASetLambdaAttrs(Method); 1002 1003 // OpenMP lambdas might get assumumption attributes. 1004 if (LangOpts.OpenMP) 1005 ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Method); 1006 1007 // Number the lambda for linkage purposes if necessary. 1008 handleLambdaNumbering(Class, Method); 1009 1010 // Introduce the function call operator as the current declaration context. 1011 PushDeclContext(CurScope, Method); 1012 1013 // Build the lambda scope. 1014 buildLambdaScope(LSI, Method, Intro.Range, Intro.Default, Intro.DefaultLoc, 1015 ExplicitParams, ExplicitResultType, !Method->isConst()); 1016 1017 // C++11 [expr.prim.lambda]p9: 1018 // A lambda-expression whose smallest enclosing scope is a block scope is a 1019 // local lambda expression; any other lambda expression shall not have a 1020 // capture-default or simple-capture in its lambda-introducer. 1021 // 1022 // For simple-captures, this is covered by the check below that any named 1023 // entity is a variable that can be captured. 1024 // 1025 // For DR1632, we also allow a capture-default in any context where we can 1026 // odr-use 'this' (in particular, in a default initializer for a non-static 1027 // data member). 1028 if (Intro.Default != LCD_None && !Class->getParent()->isFunctionOrMethod() && 1029 (getCurrentThisType().isNull() || 1030 CheckCXXThisCapture(SourceLocation(), /*Explicit*/true, 1031 /*BuildAndDiagnose*/false))) 1032 Diag(Intro.DefaultLoc, diag::err_capture_default_non_local); 1033 1034 // Distinct capture names, for diagnostics. 1035 llvm::SmallSet<IdentifierInfo*, 8> CaptureNames; 1036 1037 // Handle explicit captures. 1038 SourceLocation PrevCaptureLoc 1039 = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc; 1040 for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; 1041 PrevCaptureLoc = C->Loc, ++C) { 1042 if (C->Kind == LCK_This || C->Kind == LCK_StarThis) { 1043 if (C->Kind == LCK_StarThis) 1044 Diag(C->Loc, !getLangOpts().CPlusPlus17 1045 ? diag::ext_star_this_lambda_capture_cxx17 1046 : diag::warn_cxx14_compat_star_this_lambda_capture); 1047 1048 // C++11 [expr.prim.lambda]p8: 1049 // An identifier or this shall not appear more than once in a 1050 // lambda-capture. 1051 if (LSI->isCXXThisCaptured()) { 1052 Diag(C->Loc, diag::err_capture_more_than_once) 1053 << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation()) 1054 << FixItHint::CreateRemoval( 1055 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1056 continue; 1057 } 1058 1059 // C++2a [expr.prim.lambda]p8: 1060 // If a lambda-capture includes a capture-default that is =, 1061 // each simple-capture of that lambda-capture shall be of the form 1062 // "&identifier", "this", or "* this". [ Note: The form [&,this] is 1063 // redundant but accepted for compatibility with ISO C++14. --end note ] 1064 if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis) 1065 Diag(C->Loc, !getLangOpts().CPlusPlus20 1066 ? diag::ext_equals_this_lambda_capture_cxx20 1067 : diag::warn_cxx17_compat_equals_this_lambda_capture); 1068 1069 // C++11 [expr.prim.lambda]p12: 1070 // If this is captured by a local lambda expression, its nearest 1071 // enclosing function shall be a non-static member function. 1072 QualType ThisCaptureType = getCurrentThisType(); 1073 if (ThisCaptureType.isNull()) { 1074 Diag(C->Loc, diag::err_this_capture) << true; 1075 continue; 1076 } 1077 1078 CheckCXXThisCapture(C->Loc, /*Explicit=*/true, /*BuildAndDiagnose*/ true, 1079 /*FunctionScopeIndexToStopAtPtr*/ nullptr, 1080 C->Kind == LCK_StarThis); 1081 if (!LSI->Captures.empty()) 1082 LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange; 1083 continue; 1084 } 1085 1086 assert(C->Id && "missing identifier for capture"); 1087 1088 if (C->Init.isInvalid()) 1089 continue; 1090 1091 VarDecl *Var = nullptr; 1092 if (C->Init.isUsable()) { 1093 Diag(C->Loc, getLangOpts().CPlusPlus14 1094 ? diag::warn_cxx11_compat_init_capture 1095 : diag::ext_init_capture); 1096 1097 // If the initializer expression is usable, but the InitCaptureType 1098 // is not, then an error has occurred - so ignore the capture for now. 1099 // for e.g., [n{0}] { }; <-- if no <initializer_list> is included. 1100 // FIXME: we should create the init capture variable and mark it invalid 1101 // in this case. 1102 if (C->InitCaptureType.get().isNull()) 1103 continue; 1104 1105 if (C->Init.get()->containsUnexpandedParameterPack() && 1106 !C->InitCaptureType.get()->getAs<PackExpansionType>()) 1107 DiagnoseUnexpandedParameterPack(C->Init.get(), UPPC_Initializer); 1108 1109 unsigned InitStyle; 1110 switch (C->InitKind) { 1111 case LambdaCaptureInitKind::NoInit: 1112 llvm_unreachable("not an init-capture?"); 1113 case LambdaCaptureInitKind::CopyInit: 1114 InitStyle = VarDecl::CInit; 1115 break; 1116 case LambdaCaptureInitKind::DirectInit: 1117 InitStyle = VarDecl::CallInit; 1118 break; 1119 case LambdaCaptureInitKind::ListInit: 1120 InitStyle = VarDecl::ListInit; 1121 break; 1122 } 1123 Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(), 1124 C->EllipsisLoc, C->Id, InitStyle, 1125 C->Init.get()); 1126 // C++1y [expr.prim.lambda]p11: 1127 // An init-capture behaves as if it declares and explicitly 1128 // captures a variable [...] whose declarative region is the 1129 // lambda-expression's compound-statement 1130 if (Var) 1131 PushOnScopeChains(Var, CurScope, false); 1132 } else { 1133 assert(C->InitKind == LambdaCaptureInitKind::NoInit && 1134 "init capture has valid but null init?"); 1135 1136 // C++11 [expr.prim.lambda]p8: 1137 // If a lambda-capture includes a capture-default that is &, the 1138 // identifiers in the lambda-capture shall not be preceded by &. 1139 // If a lambda-capture includes a capture-default that is =, [...] 1140 // each identifier it contains shall be preceded by &. 1141 if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) { 1142 Diag(C->Loc, diag::err_reference_capture_with_reference_default) 1143 << FixItHint::CreateRemoval( 1144 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1145 continue; 1146 } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) { 1147 Diag(C->Loc, diag::err_copy_capture_with_copy_default) 1148 << FixItHint::CreateRemoval( 1149 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1150 continue; 1151 } 1152 1153 // C++11 [expr.prim.lambda]p10: 1154 // The identifiers in a capture-list are looked up using the usual 1155 // rules for unqualified name lookup (3.4.1) 1156 DeclarationNameInfo Name(C->Id, C->Loc); 1157 LookupResult R(*this, Name, LookupOrdinaryName); 1158 LookupName(R, CurScope); 1159 if (R.isAmbiguous()) 1160 continue; 1161 if (R.empty()) { 1162 // FIXME: Disable corrections that would add qualification? 1163 CXXScopeSpec ScopeSpec; 1164 DeclFilterCCC<VarDecl> Validator{}; 1165 if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R, Validator)) 1166 continue; 1167 } 1168 1169 Var = R.getAsSingle<VarDecl>(); 1170 if (Var && DiagnoseUseOfDecl(Var, C->Loc)) 1171 continue; 1172 } 1173 1174 // C++11 [expr.prim.lambda]p8: 1175 // An identifier or this shall not appear more than once in a 1176 // lambda-capture. 1177 if (!CaptureNames.insert(C->Id).second) { 1178 if (Var && LSI->isCaptured(Var)) { 1179 Diag(C->Loc, diag::err_capture_more_than_once) 1180 << C->Id << SourceRange(LSI->getCapture(Var).getLocation()) 1181 << FixItHint::CreateRemoval( 1182 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1183 } else 1184 // Previous capture captured something different (one or both was 1185 // an init-cpature): no fixit. 1186 Diag(C->Loc, diag::err_capture_more_than_once) << C->Id; 1187 continue; 1188 } 1189 1190 // C++11 [expr.prim.lambda]p10: 1191 // [...] each such lookup shall find a variable with automatic storage 1192 // duration declared in the reaching scope of the local lambda expression. 1193 // Note that the 'reaching scope' check happens in tryCaptureVariable(). 1194 if (!Var) { 1195 Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id; 1196 continue; 1197 } 1198 1199 // Ignore invalid decls; they'll just confuse the code later. 1200 if (Var->isInvalidDecl()) 1201 continue; 1202 1203 if (!Var->hasLocalStorage()) { 1204 Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id; 1205 Diag(Var->getLocation(), diag::note_previous_decl) << C->Id; 1206 continue; 1207 } 1208 1209 // C++11 [expr.prim.lambda]p23: 1210 // A capture followed by an ellipsis is a pack expansion (14.5.3). 1211 SourceLocation EllipsisLoc; 1212 if (C->EllipsisLoc.isValid()) { 1213 if (Var->isParameterPack()) { 1214 EllipsisLoc = C->EllipsisLoc; 1215 } else { 1216 Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 1217 << (C->Init.isUsable() ? C->Init.get()->getSourceRange() 1218 : SourceRange(C->Loc)); 1219 1220 // Just ignore the ellipsis. 1221 } 1222 } else if (Var->isParameterPack()) { 1223 ContainsUnexpandedParameterPack = true; 1224 } 1225 1226 if (C->Init.isUsable()) { 1227 addInitCapture(LSI, Var); 1228 } else { 1229 TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef : 1230 TryCapture_ExplicitByVal; 1231 tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc); 1232 } 1233 if (!LSI->Captures.empty()) 1234 LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange; 1235 } 1236 finishLambdaExplicitCaptures(LSI); 1237 1238 LSI->ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack; 1239 1240 // Add lambda parameters into scope. 1241 addLambdaParameters(Intro.Captures, Method, CurScope); 1242 1243 // Enter a new evaluation context to insulate the lambda from any 1244 // cleanups from the enclosing full-expression. 1245 PushExpressionEvaluationContext( 1246 LSI->CallOperator->isConsteval() 1247 ? ExpressionEvaluationContext::ConstantEvaluated 1248 : ExpressionEvaluationContext::PotentiallyEvaluated); 1249 } 1250 1251 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, 1252 bool IsInstantiation) { 1253 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(FunctionScopes.back()); 1254 1255 // Leave the expression-evaluation context. 1256 DiscardCleanupsInEvaluationContext(); 1257 PopExpressionEvaluationContext(); 1258 1259 // Leave the context of the lambda. 1260 if (!IsInstantiation) 1261 PopDeclContext(); 1262 1263 // Finalize the lambda. 1264 CXXRecordDecl *Class = LSI->Lambda; 1265 Class->setInvalidDecl(); 1266 SmallVector<Decl*, 4> Fields(Class->fields()); 1267 ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(), 1268 SourceLocation(), ParsedAttributesView()); 1269 CheckCompletedCXXClass(nullptr, Class); 1270 1271 PopFunctionScopeInfo(); 1272 } 1273 1274 template <typename Func> 1275 static void repeatForLambdaConversionFunctionCallingConvs( 1276 Sema &S, const FunctionProtoType &CallOpProto, Func F) { 1277 CallingConv DefaultFree = S.Context.getDefaultCallingConvention( 1278 CallOpProto.isVariadic(), /*IsCXXMethod=*/false); 1279 CallingConv DefaultMember = S.Context.getDefaultCallingConvention( 1280 CallOpProto.isVariadic(), /*IsCXXMethod=*/true); 1281 CallingConv CallOpCC = CallOpProto.getCallConv(); 1282 1283 /// Implement emitting a version of the operator for many of the calling 1284 /// conventions for MSVC, as described here: 1285 /// https://devblogs.microsoft.com/oldnewthing/20150220-00/?p=44623. 1286 /// Experimentally, we determined that cdecl, stdcall, fastcall, and 1287 /// vectorcall are generated by MSVC when it is supported by the target. 1288 /// Additionally, we are ensuring that the default-free/default-member and 1289 /// call-operator calling convention are generated as well. 1290 /// NOTE: We intentionally generate a 'thiscall' on Win32 implicitly from the 1291 /// 'member default', despite MSVC not doing so. We do this in order to ensure 1292 /// that someone who intentionally places 'thiscall' on the lambda call 1293 /// operator will still get that overload, since we don't have the a way of 1294 /// detecting the attribute by the time we get here. 1295 if (S.getLangOpts().MSVCCompat) { 1296 CallingConv Convs[] = { 1297 CC_C, CC_X86StdCall, CC_X86FastCall, CC_X86VectorCall, 1298 DefaultFree, DefaultMember, CallOpCC}; 1299 llvm::sort(Convs); 1300 llvm::iterator_range<CallingConv *> Range( 1301 std::begin(Convs), std::unique(std::begin(Convs), std::end(Convs))); 1302 const TargetInfo &TI = S.getASTContext().getTargetInfo(); 1303 1304 for (CallingConv C : Range) { 1305 if (TI.checkCallingConvention(C) == TargetInfo::CCCR_OK) 1306 F(C); 1307 } 1308 return; 1309 } 1310 1311 if (CallOpCC == DefaultMember && DefaultMember != DefaultFree) { 1312 F(DefaultFree); 1313 F(DefaultMember); 1314 } else { 1315 F(CallOpCC); 1316 } 1317 } 1318 1319 // Returns the 'standard' calling convention to be used for the lambda 1320 // conversion function, that is, the 'free' function calling convention unless 1321 // it is overridden by a non-default calling convention attribute. 1322 static CallingConv 1323 getLambdaConversionFunctionCallConv(Sema &S, 1324 const FunctionProtoType *CallOpProto) { 1325 CallingConv DefaultFree = S.Context.getDefaultCallingConvention( 1326 CallOpProto->isVariadic(), /*IsCXXMethod=*/false); 1327 CallingConv DefaultMember = S.Context.getDefaultCallingConvention( 1328 CallOpProto->isVariadic(), /*IsCXXMethod=*/true); 1329 CallingConv CallOpCC = CallOpProto->getCallConv(); 1330 1331 // If the call-operator hasn't been changed, return both the 'free' and 1332 // 'member' function calling convention. 1333 if (CallOpCC == DefaultMember && DefaultMember != DefaultFree) 1334 return DefaultFree; 1335 return CallOpCC; 1336 } 1337 1338 QualType Sema::getLambdaConversionFunctionResultType( 1339 const FunctionProtoType *CallOpProto, CallingConv CC) { 1340 const FunctionProtoType::ExtProtoInfo CallOpExtInfo = 1341 CallOpProto->getExtProtoInfo(); 1342 FunctionProtoType::ExtProtoInfo InvokerExtInfo = CallOpExtInfo; 1343 InvokerExtInfo.ExtInfo = InvokerExtInfo.ExtInfo.withCallingConv(CC); 1344 InvokerExtInfo.TypeQuals = Qualifiers(); 1345 assert(InvokerExtInfo.RefQualifier == RQ_None && 1346 "Lambda's call operator should not have a reference qualifier"); 1347 return Context.getFunctionType(CallOpProto->getReturnType(), 1348 CallOpProto->getParamTypes(), InvokerExtInfo); 1349 } 1350 1351 /// Add a lambda's conversion to function pointer, as described in 1352 /// C++11 [expr.prim.lambda]p6. 1353 static void addFunctionPointerConversion(Sema &S, SourceRange IntroducerRange, 1354 CXXRecordDecl *Class, 1355 CXXMethodDecl *CallOperator, 1356 QualType InvokerFunctionTy) { 1357 // This conversion is explicitly disabled if the lambda's function has 1358 // pass_object_size attributes on any of its parameters. 1359 auto HasPassObjectSizeAttr = [](const ParmVarDecl *P) { 1360 return P->hasAttr<PassObjectSizeAttr>(); 1361 }; 1362 if (llvm::any_of(CallOperator->parameters(), HasPassObjectSizeAttr)) 1363 return; 1364 1365 // Add the conversion to function pointer. 1366 QualType PtrToFunctionTy = S.Context.getPointerType(InvokerFunctionTy); 1367 1368 // Create the type of the conversion function. 1369 FunctionProtoType::ExtProtoInfo ConvExtInfo( 1370 S.Context.getDefaultCallingConvention( 1371 /*IsVariadic=*/false, /*IsCXXMethod=*/true)); 1372 // The conversion function is always const and noexcept. 1373 ConvExtInfo.TypeQuals = Qualifiers(); 1374 ConvExtInfo.TypeQuals.addConst(); 1375 ConvExtInfo.ExceptionSpec.Type = EST_BasicNoexcept; 1376 QualType ConvTy = 1377 S.Context.getFunctionType(PtrToFunctionTy, None, ConvExtInfo); 1378 1379 SourceLocation Loc = IntroducerRange.getBegin(); 1380 DeclarationName ConversionName 1381 = S.Context.DeclarationNames.getCXXConversionFunctionName( 1382 S.Context.getCanonicalType(PtrToFunctionTy)); 1383 DeclarationNameLoc ConvNameLoc; 1384 // Construct a TypeSourceInfo for the conversion function, and wire 1385 // all the parameters appropriately for the FunctionProtoTypeLoc 1386 // so that everything works during transformation/instantiation of 1387 // generic lambdas. 1388 // The main reason for wiring up the parameters of the conversion 1389 // function with that of the call operator is so that constructs 1390 // like the following work: 1391 // auto L = [](auto b) { <-- 1 1392 // return [](auto a) -> decltype(a) { <-- 2 1393 // return a; 1394 // }; 1395 // }; 1396 // int (*fp)(int) = L(5); 1397 // Because the trailing return type can contain DeclRefExprs that refer 1398 // to the original call operator's variables, we hijack the call 1399 // operators ParmVarDecls below. 1400 TypeSourceInfo *ConvNamePtrToFunctionTSI = 1401 S.Context.getTrivialTypeSourceInfo(PtrToFunctionTy, Loc); 1402 ConvNameLoc.NamedType.TInfo = ConvNamePtrToFunctionTSI; 1403 1404 // The conversion function is a conversion to a pointer-to-function. 1405 TypeSourceInfo *ConvTSI = S.Context.getTrivialTypeSourceInfo(ConvTy, Loc); 1406 FunctionProtoTypeLoc ConvTL = 1407 ConvTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>(); 1408 // Get the result of the conversion function which is a pointer-to-function. 1409 PointerTypeLoc PtrToFunctionTL = 1410 ConvTL.getReturnLoc().getAs<PointerTypeLoc>(); 1411 // Do the same for the TypeSourceInfo that is used to name the conversion 1412 // operator. 1413 PointerTypeLoc ConvNamePtrToFunctionTL = 1414 ConvNamePtrToFunctionTSI->getTypeLoc().getAs<PointerTypeLoc>(); 1415 1416 // Get the underlying function types that the conversion function will 1417 // be converting to (should match the type of the call operator). 1418 FunctionProtoTypeLoc CallOpConvTL = 1419 PtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>(); 1420 FunctionProtoTypeLoc CallOpConvNameTL = 1421 ConvNamePtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>(); 1422 1423 // Wire up the FunctionProtoTypeLocs with the call operator's parameters. 1424 // These parameter's are essentially used to transform the name and 1425 // the type of the conversion operator. By using the same parameters 1426 // as the call operator's we don't have to fix any back references that 1427 // the trailing return type of the call operator's uses (such as 1428 // decltype(some_type<decltype(a)>::type{} + decltype(a){}) etc.) 1429 // - we can simply use the return type of the call operator, and 1430 // everything should work. 1431 SmallVector<ParmVarDecl *, 4> InvokerParams; 1432 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 1433 ParmVarDecl *From = CallOperator->getParamDecl(I); 1434 1435 InvokerParams.push_back(ParmVarDecl::Create( 1436 S.Context, 1437 // Temporarily add to the TU. This is set to the invoker below. 1438 S.Context.getTranslationUnitDecl(), From->getBeginLoc(), 1439 From->getLocation(), From->getIdentifier(), From->getType(), 1440 From->getTypeSourceInfo(), From->getStorageClass(), 1441 /*DefArg=*/nullptr)); 1442 CallOpConvTL.setParam(I, From); 1443 CallOpConvNameTL.setParam(I, From); 1444 } 1445 1446 CXXConversionDecl *Conversion = CXXConversionDecl::Create( 1447 S.Context, Class, Loc, 1448 DeclarationNameInfo(ConversionName, Loc, ConvNameLoc), ConvTy, ConvTSI, 1449 /*isInline=*/true, ExplicitSpecifier(), 1450 S.getLangOpts().CPlusPlus17 ? ConstexprSpecKind::Constexpr 1451 : ConstexprSpecKind::Unspecified, 1452 CallOperator->getBody()->getEndLoc()); 1453 Conversion->setAccess(AS_public); 1454 Conversion->setImplicit(true); 1455 1456 if (Class->isGenericLambda()) { 1457 // Create a template version of the conversion operator, using the template 1458 // parameter list of the function call operator. 1459 FunctionTemplateDecl *TemplateCallOperator = 1460 CallOperator->getDescribedFunctionTemplate(); 1461 FunctionTemplateDecl *ConversionTemplate = 1462 FunctionTemplateDecl::Create(S.Context, Class, 1463 Loc, ConversionName, 1464 TemplateCallOperator->getTemplateParameters(), 1465 Conversion); 1466 ConversionTemplate->setAccess(AS_public); 1467 ConversionTemplate->setImplicit(true); 1468 Conversion->setDescribedFunctionTemplate(ConversionTemplate); 1469 Class->addDecl(ConversionTemplate); 1470 } else 1471 Class->addDecl(Conversion); 1472 // Add a non-static member function that will be the result of 1473 // the conversion with a certain unique ID. 1474 DeclarationName InvokerName = &S.Context.Idents.get( 1475 getLambdaStaticInvokerName()); 1476 // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo() 1477 // we should get a prebuilt TrivialTypeSourceInfo from Context 1478 // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc 1479 // then rewire the parameters accordingly, by hoisting up the InvokeParams 1480 // loop below and then use its Params to set Invoke->setParams(...) below. 1481 // This would avoid the 'const' qualifier of the calloperator from 1482 // contaminating the type of the invoker, which is currently adjusted 1483 // in SemaTemplateDeduction.cpp:DeduceTemplateArguments. Fixing the 1484 // trailing return type of the invoker would require a visitor to rebuild 1485 // the trailing return type and adjusting all back DeclRefExpr's to refer 1486 // to the new static invoker parameters - not the call operator's. 1487 CXXMethodDecl *Invoke = CXXMethodDecl::Create( 1488 S.Context, Class, Loc, DeclarationNameInfo(InvokerName, Loc), 1489 InvokerFunctionTy, CallOperator->getTypeSourceInfo(), SC_Static, 1490 /*isInline=*/true, ConstexprSpecKind::Unspecified, 1491 CallOperator->getBody()->getEndLoc()); 1492 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) 1493 InvokerParams[I]->setOwningFunction(Invoke); 1494 Invoke->setParams(InvokerParams); 1495 Invoke->setAccess(AS_private); 1496 Invoke->setImplicit(true); 1497 if (Class->isGenericLambda()) { 1498 FunctionTemplateDecl *TemplateCallOperator = 1499 CallOperator->getDescribedFunctionTemplate(); 1500 FunctionTemplateDecl *StaticInvokerTemplate = FunctionTemplateDecl::Create( 1501 S.Context, Class, Loc, InvokerName, 1502 TemplateCallOperator->getTemplateParameters(), 1503 Invoke); 1504 StaticInvokerTemplate->setAccess(AS_private); 1505 StaticInvokerTemplate->setImplicit(true); 1506 Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate); 1507 Class->addDecl(StaticInvokerTemplate); 1508 } else 1509 Class->addDecl(Invoke); 1510 } 1511 1512 /// Add a lambda's conversion to function pointers, as described in 1513 /// C++11 [expr.prim.lambda]p6. Note that in most cases, this should emit only a 1514 /// single pointer conversion. In the event that the default calling convention 1515 /// for free and member functions is different, it will emit both conventions. 1516 static void addFunctionPointerConversions(Sema &S, SourceRange IntroducerRange, 1517 CXXRecordDecl *Class, 1518 CXXMethodDecl *CallOperator) { 1519 const FunctionProtoType *CallOpProto = 1520 CallOperator->getType()->castAs<FunctionProtoType>(); 1521 1522 repeatForLambdaConversionFunctionCallingConvs( 1523 S, *CallOpProto, [&](CallingConv CC) { 1524 QualType InvokerFunctionTy = 1525 S.getLambdaConversionFunctionResultType(CallOpProto, CC); 1526 addFunctionPointerConversion(S, IntroducerRange, Class, CallOperator, 1527 InvokerFunctionTy); 1528 }); 1529 } 1530 1531 /// Add a lambda's conversion to block pointer. 1532 static void addBlockPointerConversion(Sema &S, 1533 SourceRange IntroducerRange, 1534 CXXRecordDecl *Class, 1535 CXXMethodDecl *CallOperator) { 1536 const FunctionProtoType *CallOpProto = 1537 CallOperator->getType()->castAs<FunctionProtoType>(); 1538 QualType FunctionTy = S.getLambdaConversionFunctionResultType( 1539 CallOpProto, getLambdaConversionFunctionCallConv(S, CallOpProto)); 1540 QualType BlockPtrTy = S.Context.getBlockPointerType(FunctionTy); 1541 1542 FunctionProtoType::ExtProtoInfo ConversionEPI( 1543 S.Context.getDefaultCallingConvention( 1544 /*IsVariadic=*/false, /*IsCXXMethod=*/true)); 1545 ConversionEPI.TypeQuals = Qualifiers(); 1546 ConversionEPI.TypeQuals.addConst(); 1547 QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, None, ConversionEPI); 1548 1549 SourceLocation Loc = IntroducerRange.getBegin(); 1550 DeclarationName Name 1551 = S.Context.DeclarationNames.getCXXConversionFunctionName( 1552 S.Context.getCanonicalType(BlockPtrTy)); 1553 DeclarationNameLoc NameLoc; 1554 NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc); 1555 CXXConversionDecl *Conversion = CXXConversionDecl::Create( 1556 S.Context, Class, Loc, DeclarationNameInfo(Name, Loc, NameLoc), ConvTy, 1557 S.Context.getTrivialTypeSourceInfo(ConvTy, Loc), 1558 /*isInline=*/true, ExplicitSpecifier(), ConstexprSpecKind::Unspecified, 1559 CallOperator->getBody()->getEndLoc()); 1560 Conversion->setAccess(AS_public); 1561 Conversion->setImplicit(true); 1562 Class->addDecl(Conversion); 1563 } 1564 1565 ExprResult Sema::BuildCaptureInit(const Capture &Cap, 1566 SourceLocation ImplicitCaptureLoc, 1567 bool IsOpenMPMapping) { 1568 // VLA captures don't have a stored initialization expression. 1569 if (Cap.isVLATypeCapture()) 1570 return ExprResult(); 1571 1572 // An init-capture is initialized directly from its stored initializer. 1573 if (Cap.isInitCapture()) 1574 return Cap.getVariable()->getInit(); 1575 1576 // For anything else, build an initialization expression. For an implicit 1577 // capture, the capture notionally happens at the capture-default, so use 1578 // that location here. 1579 SourceLocation Loc = 1580 ImplicitCaptureLoc.isValid() ? ImplicitCaptureLoc : Cap.getLocation(); 1581 1582 // C++11 [expr.prim.lambda]p21: 1583 // When the lambda-expression is evaluated, the entities that 1584 // are captured by copy are used to direct-initialize each 1585 // corresponding non-static data member of the resulting closure 1586 // object. (For array members, the array elements are 1587 // direct-initialized in increasing subscript order.) These 1588 // initializations are performed in the (unspecified) order in 1589 // which the non-static data members are declared. 1590 1591 // C++ [expr.prim.lambda]p12: 1592 // An entity captured by a lambda-expression is odr-used (3.2) in 1593 // the scope containing the lambda-expression. 1594 ExprResult Init; 1595 IdentifierInfo *Name = nullptr; 1596 if (Cap.isThisCapture()) { 1597 QualType ThisTy = getCurrentThisType(); 1598 Expr *This = BuildCXXThisExpr(Loc, ThisTy, ImplicitCaptureLoc.isValid()); 1599 if (Cap.isCopyCapture()) 1600 Init = CreateBuiltinUnaryOp(Loc, UO_Deref, This); 1601 else 1602 Init = This; 1603 } else { 1604 assert(Cap.isVariableCapture() && "unknown kind of capture"); 1605 VarDecl *Var = Cap.getVariable(); 1606 Name = Var->getIdentifier(); 1607 Init = BuildDeclarationNameExpr( 1608 CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var); 1609 } 1610 1611 // In OpenMP, the capture kind doesn't actually describe how to capture: 1612 // variables are "mapped" onto the device in a process that does not formally 1613 // make a copy, even for a "copy capture". 1614 if (IsOpenMPMapping) 1615 return Init; 1616 1617 if (Init.isInvalid()) 1618 return ExprError(); 1619 1620 Expr *InitExpr = Init.get(); 1621 InitializedEntity Entity = InitializedEntity::InitializeLambdaCapture( 1622 Name, Cap.getCaptureType(), Loc); 1623 InitializationKind InitKind = 1624 InitializationKind::CreateDirect(Loc, Loc, Loc); 1625 InitializationSequence InitSeq(*this, Entity, InitKind, InitExpr); 1626 return InitSeq.Perform(*this, Entity, InitKind, InitExpr); 1627 } 1628 1629 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, 1630 Scope *CurScope) { 1631 LambdaScopeInfo LSI = *cast<LambdaScopeInfo>(FunctionScopes.back()); 1632 ActOnFinishFunctionBody(LSI.CallOperator, Body); 1633 return BuildLambdaExpr(StartLoc, Body->getEndLoc(), &LSI); 1634 } 1635 1636 static LambdaCaptureDefault 1637 mapImplicitCaptureStyle(CapturingScopeInfo::ImplicitCaptureStyle ICS) { 1638 switch (ICS) { 1639 case CapturingScopeInfo::ImpCap_None: 1640 return LCD_None; 1641 case CapturingScopeInfo::ImpCap_LambdaByval: 1642 return LCD_ByCopy; 1643 case CapturingScopeInfo::ImpCap_CapturedRegion: 1644 case CapturingScopeInfo::ImpCap_LambdaByref: 1645 return LCD_ByRef; 1646 case CapturingScopeInfo::ImpCap_Block: 1647 llvm_unreachable("block capture in lambda"); 1648 } 1649 llvm_unreachable("Unknown implicit capture style"); 1650 } 1651 1652 bool Sema::CaptureHasSideEffects(const Capture &From) { 1653 if (From.isInitCapture()) { 1654 Expr *Init = From.getVariable()->getInit(); 1655 if (Init && Init->HasSideEffects(Context)) 1656 return true; 1657 } 1658 1659 if (!From.isCopyCapture()) 1660 return false; 1661 1662 const QualType T = From.isThisCapture() 1663 ? getCurrentThisType()->getPointeeType() 1664 : From.getCaptureType(); 1665 1666 if (T.isVolatileQualified()) 1667 return true; 1668 1669 const Type *BaseT = T->getBaseElementTypeUnsafe(); 1670 if (const CXXRecordDecl *RD = BaseT->getAsCXXRecordDecl()) 1671 return !RD->isCompleteDefinition() || !RD->hasTrivialCopyConstructor() || 1672 !RD->hasTrivialDestructor(); 1673 1674 return false; 1675 } 1676 1677 bool Sema::DiagnoseUnusedLambdaCapture(SourceRange CaptureRange, 1678 const Capture &From) { 1679 if (CaptureHasSideEffects(From)) 1680 return false; 1681 1682 if (From.isVLATypeCapture()) 1683 return false; 1684 1685 auto diag = Diag(From.getLocation(), diag::warn_unused_lambda_capture); 1686 if (From.isThisCapture()) 1687 diag << "'this'"; 1688 else 1689 diag << From.getVariable(); 1690 diag << From.isNonODRUsed(); 1691 diag << FixItHint::CreateRemoval(CaptureRange); 1692 return true; 1693 } 1694 1695 /// Create a field within the lambda class or captured statement record for the 1696 /// given capture. 1697 FieldDecl *Sema::BuildCaptureField(RecordDecl *RD, 1698 const sema::Capture &Capture) { 1699 SourceLocation Loc = Capture.getLocation(); 1700 QualType FieldType = Capture.getCaptureType(); 1701 1702 TypeSourceInfo *TSI = nullptr; 1703 if (Capture.isVariableCapture()) { 1704 auto *Var = Capture.getVariable(); 1705 if (Var->isInitCapture()) 1706 TSI = Capture.getVariable()->getTypeSourceInfo(); 1707 } 1708 1709 // FIXME: Should we really be doing this? A null TypeSourceInfo seems more 1710 // appropriate, at least for an implicit capture. 1711 if (!TSI) 1712 TSI = Context.getTrivialTypeSourceInfo(FieldType, Loc); 1713 1714 // Build the non-static data member. 1715 FieldDecl *Field = 1716 FieldDecl::Create(Context, RD, /*StartLoc=*/Loc, /*IdLoc=*/Loc, 1717 /*Id=*/nullptr, FieldType, TSI, /*BW=*/nullptr, 1718 /*Mutable=*/false, ICIS_NoInit); 1719 // If the variable being captured has an invalid type, mark the class as 1720 // invalid as well. 1721 if (!FieldType->isDependentType()) { 1722 if (RequireCompleteSizedType(Loc, FieldType, 1723 diag::err_field_incomplete_or_sizeless)) { 1724 RD->setInvalidDecl(); 1725 Field->setInvalidDecl(); 1726 } else { 1727 NamedDecl *Def; 1728 FieldType->isIncompleteType(&Def); 1729 if (Def && Def->isInvalidDecl()) { 1730 RD->setInvalidDecl(); 1731 Field->setInvalidDecl(); 1732 } 1733 } 1734 } 1735 Field->setImplicit(true); 1736 Field->setAccess(AS_private); 1737 RD->addDecl(Field); 1738 1739 if (Capture.isVLATypeCapture()) 1740 Field->setCapturedVLAType(Capture.getCapturedVLAType()); 1741 1742 return Field; 1743 } 1744 1745 ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc, 1746 LambdaScopeInfo *LSI) { 1747 // Collect information from the lambda scope. 1748 SmallVector<LambdaCapture, 4> Captures; 1749 SmallVector<Expr *, 4> CaptureInits; 1750 SourceLocation CaptureDefaultLoc = LSI->CaptureDefaultLoc; 1751 LambdaCaptureDefault CaptureDefault = 1752 mapImplicitCaptureStyle(LSI->ImpCaptureStyle); 1753 CXXRecordDecl *Class; 1754 CXXMethodDecl *CallOperator; 1755 SourceRange IntroducerRange; 1756 bool ExplicitParams; 1757 bool ExplicitResultType; 1758 CleanupInfo LambdaCleanup; 1759 bool ContainsUnexpandedParameterPack; 1760 bool IsGenericLambda; 1761 { 1762 CallOperator = LSI->CallOperator; 1763 Class = LSI->Lambda; 1764 IntroducerRange = LSI->IntroducerRange; 1765 ExplicitParams = LSI->ExplicitParams; 1766 ExplicitResultType = !LSI->HasImplicitReturnType; 1767 LambdaCleanup = LSI->Cleanup; 1768 ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack; 1769 IsGenericLambda = Class->isGenericLambda(); 1770 1771 CallOperator->setLexicalDeclContext(Class); 1772 Decl *TemplateOrNonTemplateCallOperatorDecl = 1773 CallOperator->getDescribedFunctionTemplate() 1774 ? CallOperator->getDescribedFunctionTemplate() 1775 : cast<Decl>(CallOperator); 1776 1777 // FIXME: Is this really the best choice? Keeping the lexical decl context 1778 // set as CurContext seems more faithful to the source. 1779 TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class); 1780 1781 PopExpressionEvaluationContext(); 1782 1783 // True if the current capture has a used capture or default before it. 1784 bool CurHasPreviousCapture = CaptureDefault != LCD_None; 1785 SourceLocation PrevCaptureLoc = CurHasPreviousCapture ? 1786 CaptureDefaultLoc : IntroducerRange.getBegin(); 1787 1788 for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) { 1789 const Capture &From = LSI->Captures[I]; 1790 1791 if (From.isInvalid()) 1792 return ExprError(); 1793 1794 assert(!From.isBlockCapture() && "Cannot capture __block variables"); 1795 bool IsImplicit = I >= LSI->NumExplicitCaptures; 1796 SourceLocation ImplicitCaptureLoc = 1797 IsImplicit ? CaptureDefaultLoc : SourceLocation(); 1798 1799 // Use source ranges of explicit captures for fixits where available. 1800 SourceRange CaptureRange = LSI->ExplicitCaptureRanges[I]; 1801 1802 // Warn about unused explicit captures. 1803 bool IsCaptureUsed = true; 1804 if (!CurContext->isDependentContext() && !IsImplicit && 1805 !From.isODRUsed()) { 1806 // Initialized captures that are non-ODR used may not be eliminated. 1807 // FIXME: Where did the IsGenericLambda here come from? 1808 bool NonODRUsedInitCapture = 1809 IsGenericLambda && From.isNonODRUsed() && From.isInitCapture(); 1810 if (!NonODRUsedInitCapture) { 1811 bool IsLast = (I + 1) == LSI->NumExplicitCaptures; 1812 SourceRange FixItRange; 1813 if (CaptureRange.isValid()) { 1814 if (!CurHasPreviousCapture && !IsLast) { 1815 // If there are no captures preceding this capture, remove the 1816 // following comma. 1817 FixItRange = SourceRange(CaptureRange.getBegin(), 1818 getLocForEndOfToken(CaptureRange.getEnd())); 1819 } else { 1820 // Otherwise, remove the comma since the last used capture. 1821 FixItRange = SourceRange(getLocForEndOfToken(PrevCaptureLoc), 1822 CaptureRange.getEnd()); 1823 } 1824 } 1825 1826 IsCaptureUsed = !DiagnoseUnusedLambdaCapture(FixItRange, From); 1827 } 1828 } 1829 1830 if (CaptureRange.isValid()) { 1831 CurHasPreviousCapture |= IsCaptureUsed; 1832 PrevCaptureLoc = CaptureRange.getEnd(); 1833 } 1834 1835 // Map the capture to our AST representation. 1836 LambdaCapture Capture = [&] { 1837 if (From.isThisCapture()) { 1838 // Capturing 'this' implicitly with a default of '[=]' is deprecated, 1839 // because it results in a reference capture. Don't warn prior to 1840 // C++2a; there's nothing that can be done about it before then. 1841 if (getLangOpts().CPlusPlus20 && IsImplicit && 1842 CaptureDefault == LCD_ByCopy) { 1843 Diag(From.getLocation(), diag::warn_deprecated_this_capture); 1844 Diag(CaptureDefaultLoc, diag::note_deprecated_this_capture) 1845 << FixItHint::CreateInsertion( 1846 getLocForEndOfToken(CaptureDefaultLoc), ", this"); 1847 } 1848 return LambdaCapture(From.getLocation(), IsImplicit, 1849 From.isCopyCapture() ? LCK_StarThis : LCK_This); 1850 } else if (From.isVLATypeCapture()) { 1851 return LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType); 1852 } else { 1853 assert(From.isVariableCapture() && "unknown kind of capture"); 1854 VarDecl *Var = From.getVariable(); 1855 LambdaCaptureKind Kind = 1856 From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef; 1857 return LambdaCapture(From.getLocation(), IsImplicit, Kind, Var, 1858 From.getEllipsisLoc()); 1859 } 1860 }(); 1861 1862 // Form the initializer for the capture field. 1863 ExprResult Init = BuildCaptureInit(From, ImplicitCaptureLoc); 1864 1865 // FIXME: Skip this capture if the capture is not used, the initializer 1866 // has no side-effects, the type of the capture is trivial, and the 1867 // lambda is not externally visible. 1868 1869 // Add a FieldDecl for the capture and form its initializer. 1870 BuildCaptureField(Class, From); 1871 Captures.push_back(Capture); 1872 CaptureInits.push_back(Init.get()); 1873 1874 if (LangOpts.CUDA) 1875 CUDACheckLambdaCapture(CallOperator, From); 1876 } 1877 1878 Class->setCaptures(Context, Captures); 1879 1880 // C++11 [expr.prim.lambda]p6: 1881 // The closure type for a lambda-expression with no lambda-capture 1882 // has a public non-virtual non-explicit const conversion function 1883 // to pointer to function having the same parameter and return 1884 // types as the closure type's function call operator. 1885 if (Captures.empty() && CaptureDefault == LCD_None) 1886 addFunctionPointerConversions(*this, IntroducerRange, Class, 1887 CallOperator); 1888 1889 // Objective-C++: 1890 // The closure type for a lambda-expression has a public non-virtual 1891 // non-explicit const conversion function to a block pointer having the 1892 // same parameter and return types as the closure type's function call 1893 // operator. 1894 // FIXME: Fix generic lambda to block conversions. 1895 if (getLangOpts().Blocks && getLangOpts().ObjC && !IsGenericLambda) 1896 addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator); 1897 1898 // Finalize the lambda class. 1899 SmallVector<Decl*, 4> Fields(Class->fields()); 1900 ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(), 1901 SourceLocation(), ParsedAttributesView()); 1902 CheckCompletedCXXClass(nullptr, Class); 1903 } 1904 1905 Cleanup.mergeFrom(LambdaCleanup); 1906 1907 LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange, 1908 CaptureDefault, CaptureDefaultLoc, 1909 ExplicitParams, ExplicitResultType, 1910 CaptureInits, EndLoc, 1911 ContainsUnexpandedParameterPack); 1912 // If the lambda expression's call operator is not explicitly marked constexpr 1913 // and we are not in a dependent context, analyze the call operator to infer 1914 // its constexpr-ness, suppressing diagnostics while doing so. 1915 if (getLangOpts().CPlusPlus17 && !CallOperator->isInvalidDecl() && 1916 !CallOperator->isConstexpr() && 1917 !isa<CoroutineBodyStmt>(CallOperator->getBody()) && 1918 !Class->getDeclContext()->isDependentContext()) { 1919 CallOperator->setConstexprKind( 1920 CheckConstexprFunctionDefinition(CallOperator, 1921 CheckConstexprKind::CheckValid) 1922 ? ConstexprSpecKind::Constexpr 1923 : ConstexprSpecKind::Unspecified); 1924 } 1925 1926 // Emit delayed shadowing warnings now that the full capture list is known. 1927 DiagnoseShadowingLambdaDecls(LSI); 1928 1929 if (!CurContext->isDependentContext()) { 1930 switch (ExprEvalContexts.back().Context) { 1931 // C++11 [expr.prim.lambda]p2: 1932 // A lambda-expression shall not appear in an unevaluated operand 1933 // (Clause 5). 1934 case ExpressionEvaluationContext::Unevaluated: 1935 case ExpressionEvaluationContext::UnevaluatedList: 1936 case ExpressionEvaluationContext::UnevaluatedAbstract: 1937 // C++1y [expr.const]p2: 1938 // A conditional-expression e is a core constant expression unless the 1939 // evaluation of e, following the rules of the abstract machine, would 1940 // evaluate [...] a lambda-expression. 1941 // 1942 // This is technically incorrect, there are some constant evaluated contexts 1943 // where this should be allowed. We should probably fix this when DR1607 is 1944 // ratified, it lays out the exact set of conditions where we shouldn't 1945 // allow a lambda-expression. 1946 case ExpressionEvaluationContext::ConstantEvaluated: 1947 // We don't actually diagnose this case immediately, because we 1948 // could be within a context where we might find out later that 1949 // the expression is potentially evaluated (e.g., for typeid). 1950 ExprEvalContexts.back().Lambdas.push_back(Lambda); 1951 break; 1952 1953 case ExpressionEvaluationContext::DiscardedStatement: 1954 case ExpressionEvaluationContext::PotentiallyEvaluated: 1955 case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed: 1956 break; 1957 } 1958 } 1959 1960 return MaybeBindToTemporary(Lambda); 1961 } 1962 1963 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation, 1964 SourceLocation ConvLocation, 1965 CXXConversionDecl *Conv, 1966 Expr *Src) { 1967 // Make sure that the lambda call operator is marked used. 1968 CXXRecordDecl *Lambda = Conv->getParent(); 1969 CXXMethodDecl *CallOperator 1970 = cast<CXXMethodDecl>( 1971 Lambda->lookup( 1972 Context.DeclarationNames.getCXXOperatorName(OO_Call)).front()); 1973 CallOperator->setReferenced(); 1974 CallOperator->markUsed(Context); 1975 1976 ExprResult Init = PerformCopyInitialization( 1977 InitializedEntity::InitializeLambdaToBlock(ConvLocation, Src->getType(), 1978 /*NRVO=*/false), 1979 CurrentLocation, Src); 1980 if (!Init.isInvalid()) 1981 Init = ActOnFinishFullExpr(Init.get(), /*DiscardedValue*/ false); 1982 1983 if (Init.isInvalid()) 1984 return ExprError(); 1985 1986 // Create the new block to be returned. 1987 BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation); 1988 1989 // Set the type information. 1990 Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo()); 1991 Block->setIsVariadic(CallOperator->isVariadic()); 1992 Block->setBlockMissingReturnType(false); 1993 1994 // Add parameters. 1995 SmallVector<ParmVarDecl *, 4> BlockParams; 1996 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 1997 ParmVarDecl *From = CallOperator->getParamDecl(I); 1998 BlockParams.push_back(ParmVarDecl::Create( 1999 Context, Block, From->getBeginLoc(), From->getLocation(), 2000 From->getIdentifier(), From->getType(), From->getTypeSourceInfo(), 2001 From->getStorageClass(), 2002 /*DefArg=*/nullptr)); 2003 } 2004 Block->setParams(BlockParams); 2005 2006 Block->setIsConversionFromLambda(true); 2007 2008 // Add capture. The capture uses a fake variable, which doesn't correspond 2009 // to any actual memory location. However, the initializer copy-initializes 2010 // the lambda object. 2011 TypeSourceInfo *CapVarTSI = 2012 Context.getTrivialTypeSourceInfo(Src->getType()); 2013 VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation, 2014 ConvLocation, nullptr, 2015 Src->getType(), CapVarTSI, 2016 SC_None); 2017 BlockDecl::Capture Capture(/*variable=*/CapVar, /*byRef=*/false, 2018 /*nested=*/false, /*copy=*/Init.get()); 2019 Block->setCaptures(Context, Capture, /*CapturesCXXThis=*/false); 2020 2021 // Add a fake function body to the block. IR generation is responsible 2022 // for filling in the actual body, which cannot be expressed as an AST. 2023 Block->setBody(new (Context) CompoundStmt(ConvLocation)); 2024 2025 // Create the block literal expression. 2026 Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType()); 2027 ExprCleanupObjects.push_back(Block); 2028 Cleanup.setExprNeedsCleanups(true); 2029 2030 return BuildBlock; 2031 } 2032