1 //===--- SemaLambda.cpp - Semantic Analysis for C++11 Lambdas -------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements semantic analysis for C++ lambda expressions. 11 // 12 //===----------------------------------------------------------------------===// 13 #include "clang/Sema/DeclSpec.h" 14 #include "TypeLocBuilder.h" 15 #include "clang/AST/ASTLambda.h" 16 #include "clang/AST/ExprCXX.h" 17 #include "clang/Basic/TargetInfo.h" 18 #include "clang/Sema/Initialization.h" 19 #include "clang/Sema/Lookup.h" 20 #include "clang/Sema/Scope.h" 21 #include "clang/Sema/ScopeInfo.h" 22 #include "clang/Sema/SemaInternal.h" 23 #include "clang/Sema/SemaLambda.h" 24 using namespace clang; 25 using namespace sema; 26 27 /// \brief 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 assert( 70 isa<clang::sema::LambdaScopeInfo>( 71 FunctionScopes[FunctionScopes.size() - 1]) && 72 "The function on the top of sema's function-info stack must be a lambda"); 73 74 // If VarToCapture is null, we are attempting to capture 'this'. 75 const bool IsCapturingThis = !VarToCapture; 76 const bool IsCapturingVariable = !IsCapturingThis; 77 78 // Start with the current lambda at the top of the stack (highest index). 79 unsigned CurScopeIndex = FunctionScopes.size() - 1; 80 DeclContext *EnclosingDC = 81 cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex])->CallOperator; 82 83 do { 84 const clang::sema::LambdaScopeInfo *LSI = 85 cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]); 86 // IF we have climbed down to an intervening enclosing lambda that contains 87 // the variable declaration - it obviously can/must not capture the 88 // variable. 89 // Since its enclosing DC is dependent, all the lambdas between it and the 90 // innermost nested lambda are dependent (otherwise we wouldn't have 91 // arrived here) - so we don't yet have a lambda that can capture the 92 // variable. 93 if (IsCapturingVariable && 94 VarToCapture->getDeclContext()->Equals(EnclosingDC)) 95 return NoLambdaIsCaptureReady; 96 97 // For an enclosing lambda to be capture ready for an entity, all 98 // intervening lambda's have to be able to capture that entity. If even 99 // one of the intervening lambda's is not capable of capturing the entity 100 // then no enclosing lambda can ever capture that entity. 101 // For e.g. 102 // const int x = 10; 103 // [=](auto a) { #1 104 // [](auto b) { #2 <-- an intervening lambda that can never capture 'x' 105 // [=](auto c) { #3 106 // f(x, c); <-- can not lead to x's speculative capture by #1 or #2 107 // }; }; }; 108 // If they do not have a default implicit capture, check to see 109 // if the entity has already been explicitly captured. 110 // If even a single dependent enclosing lambda lacks the capability 111 // to ever capture this variable, there is no further enclosing 112 // non-dependent lambda that can capture this variable. 113 if (LSI->ImpCaptureStyle == sema::LambdaScopeInfo::ImpCap_None) { 114 if (IsCapturingVariable && !LSI->isCaptured(VarToCapture)) 115 return NoLambdaIsCaptureReady; 116 if (IsCapturingThis && !LSI->isCXXThisCaptured()) 117 return NoLambdaIsCaptureReady; 118 } 119 EnclosingDC = getLambdaAwareParentOfDeclContext(EnclosingDC); 120 121 assert(CurScopeIndex); 122 --CurScopeIndex; 123 } while (!EnclosingDC->isTranslationUnit() && 124 EnclosingDC->isDependentContext() && 125 isLambdaCallOperator(EnclosingDC)); 126 127 assert(CurScopeIndex < (FunctionScopes.size() - 1)); 128 // If the enclosingDC is not dependent, then the immediately nested lambda 129 // (one index above) is capture-ready. 130 if (!EnclosingDC->isDependentContext()) 131 return CurScopeIndex + 1; 132 return NoLambdaIsCaptureReady; 133 } 134 135 /// \brief Examines the FunctionScopeInfo stack to determine the nearest 136 /// enclosing lambda (to the current lambda) that is 'capture-capable' for 137 /// the variable referenced in the current lambda (i.e. \p VarToCapture). 138 /// If successful, returns the index into Sema's FunctionScopeInfo stack 139 /// of the capture-capable lambda's LambdaScopeInfo. 140 /// 141 /// Given the current stack of lambdas being processed by Sema and 142 /// the variable of interest, to identify the nearest enclosing lambda (to the 143 /// current lambda at the top of the stack) that can truly capture 144 /// a variable, it has to have the following two properties: 145 /// a) 'capture-ready' - be the innermost lambda that is 'capture-ready': 146 /// - climb down the stack (i.e. starting from the innermost and examining 147 /// each outer lambda step by step) checking if each enclosing 148 /// lambda can either implicitly or explicitly capture the variable. 149 /// Record the first such lambda that is enclosed in a non-dependent 150 /// context. If no such lambda currently exists return failure. 151 /// b) 'capture-capable' - make sure the 'capture-ready' lambda can truly 152 /// capture the variable by checking all its enclosing lambdas: 153 /// - check if all outer lambdas enclosing the 'capture-ready' lambda 154 /// identified above in 'a' can also capture the variable (this is done 155 /// via tryCaptureVariable for variables and CheckCXXThisCapture for 156 /// 'this' by passing in the index of the Lambda identified in step 'a') 157 /// 158 /// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a 159 /// LambdaScopeInfo inherits from). The current/deepest/innermost lambda 160 /// is at the top of the stack. 161 /// 162 /// \param VarToCapture - the variable to capture. If NULL, capture 'this'. 163 /// 164 /// 165 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains 166 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda 167 /// which is capture-capable. If the return value evaluates to 'false' then 168 /// no lambda is capture-capable for \p VarToCapture. 169 170 Optional<unsigned> clang::getStackIndexOfNearestEnclosingCaptureCapableLambda( 171 ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes, 172 VarDecl *VarToCapture, Sema &S) { 173 174 const Optional<unsigned> NoLambdaIsCaptureCapable; 175 176 const Optional<unsigned> OptionalStackIndex = 177 getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes, 178 VarToCapture); 179 if (!OptionalStackIndex) 180 return NoLambdaIsCaptureCapable; 181 182 const unsigned IndexOfCaptureReadyLambda = OptionalStackIndex.getValue(); 183 assert(((IndexOfCaptureReadyLambda != (FunctionScopes.size() - 1)) || 184 S.getCurGenericLambda()) && 185 "The capture ready lambda for a potential capture can only be the " 186 "current lambda if it is a generic lambda"); 187 188 const sema::LambdaScopeInfo *const CaptureReadyLambdaLSI = 189 cast<sema::LambdaScopeInfo>(FunctionScopes[IndexOfCaptureReadyLambda]); 190 191 // If VarToCapture is null, we are attempting to capture 'this' 192 const bool IsCapturingThis = !VarToCapture; 193 const bool IsCapturingVariable = !IsCapturingThis; 194 195 if (IsCapturingVariable) { 196 // Check if the capture-ready lambda can truly capture the variable, by 197 // checking whether all enclosing lambdas of the capture-ready lambda allow 198 // the capture - i.e. make sure it is capture-capable. 199 QualType CaptureType, DeclRefType; 200 const bool CanCaptureVariable = 201 !S.tryCaptureVariable(VarToCapture, 202 /*ExprVarIsUsedInLoc*/ SourceLocation(), 203 clang::Sema::TryCapture_Implicit, 204 /*EllipsisLoc*/ SourceLocation(), 205 /*BuildAndDiagnose*/ false, CaptureType, 206 DeclRefType, &IndexOfCaptureReadyLambda); 207 if (!CanCaptureVariable) 208 return NoLambdaIsCaptureCapable; 209 } else { 210 // Check if the capture-ready lambda can truly capture 'this' by checking 211 // whether all enclosing lambdas of the capture-ready lambda can capture 212 // 'this'. 213 const bool CanCaptureThis = 214 !S.CheckCXXThisCapture( 215 CaptureReadyLambdaLSI->PotentialThisCaptureLocation, 216 /*Explicit*/ false, /*BuildAndDiagnose*/ false, 217 &IndexOfCaptureReadyLambda); 218 if (!CanCaptureThis) 219 return NoLambdaIsCaptureCapable; 220 } 221 return IndexOfCaptureReadyLambda; 222 } 223 224 static inline TemplateParameterList * 225 getGenericLambdaTemplateParameterList(LambdaScopeInfo *LSI, Sema &SemaRef) { 226 if (LSI->GLTemplateParameterList) 227 return LSI->GLTemplateParameterList; 228 229 if (LSI->AutoTemplateParams.size()) { 230 SourceRange IntroRange = LSI->IntroducerRange; 231 SourceLocation LAngleLoc = IntroRange.getBegin(); 232 SourceLocation RAngleLoc = IntroRange.getEnd(); 233 LSI->GLTemplateParameterList = TemplateParameterList::Create( 234 SemaRef.Context, 235 /*Template kw loc*/ SourceLocation(), LAngleLoc, 236 (NamedDecl **)LSI->AutoTemplateParams.data(), 237 LSI->AutoTemplateParams.size(), RAngleLoc); 238 } 239 return LSI->GLTemplateParameterList; 240 } 241 242 CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange, 243 TypeSourceInfo *Info, 244 bool KnownDependent, 245 LambdaCaptureDefault CaptureDefault) { 246 DeclContext *DC = CurContext; 247 while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext())) 248 DC = DC->getParent(); 249 bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(), 250 *this); 251 // Start constructing the lambda class. 252 CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, Info, 253 IntroducerRange.getBegin(), 254 KnownDependent, 255 IsGenericLambda, 256 CaptureDefault); 257 DC->addDecl(Class); 258 259 return Class; 260 } 261 262 /// \brief Determine whether the given context is or is enclosed in an inline 263 /// function. 264 static bool isInInlineFunction(const DeclContext *DC) { 265 while (!DC->isFileContext()) { 266 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 267 if (FD->isInlined()) 268 return true; 269 270 DC = DC->getLexicalParent(); 271 } 272 273 return false; 274 } 275 276 MangleNumberingContext * 277 Sema::getCurrentMangleNumberContext(const DeclContext *DC, 278 Decl *&ManglingContextDecl) { 279 // Compute the context for allocating mangling numbers in the current 280 // expression, if the ABI requires them. 281 ManglingContextDecl = ExprEvalContexts.back().ManglingContextDecl; 282 283 enum ContextKind { 284 Normal, 285 DefaultArgument, 286 DataMember, 287 StaticDataMember 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 (isa<FieldDecl>(ManglingContextDecl)) { 303 Kind = DataMember; 304 } 305 } 306 307 // Itanium ABI [5.1.7]: 308 // In the following contexts [...] the one-definition rule requires closure 309 // types in different translation units to "correspond": 310 bool IsInNonspecializedTemplate = 311 !ActiveTemplateInstantiations.empty() || CurContext->isDependentContext(); 312 switch (Kind) { 313 case Normal: 314 // -- the bodies of non-exported nonspecialized template functions 315 // -- the bodies of inline functions 316 if ((IsInNonspecializedTemplate && 317 !(ManglingContextDecl && isa<ParmVarDecl>(ManglingContextDecl))) || 318 isInInlineFunction(CurContext)) { 319 ManglingContextDecl = nullptr; 320 return &Context.getManglingNumberContext(DC); 321 } 322 323 ManglingContextDecl = nullptr; 324 return nullptr; 325 326 case StaticDataMember: 327 // -- the initializers of nonspecialized static members of template classes 328 if (!IsInNonspecializedTemplate) { 329 ManglingContextDecl = nullptr; 330 return nullptr; 331 } 332 // Fall through to get the current context. 333 334 case DataMember: 335 // -- the in-class initializers of class members 336 case DefaultArgument: 337 // -- default arguments appearing in class definitions 338 return &ExprEvalContexts.back().getMangleNumberingContext(Context); 339 } 340 341 llvm_unreachable("unexpected context"); 342 } 343 344 MangleNumberingContext & 345 Sema::ExpressionEvaluationContextRecord::getMangleNumberingContext( 346 ASTContext &Ctx) { 347 assert(ManglingContextDecl && "Need to have a context declaration"); 348 if (!MangleNumbering) 349 MangleNumbering = Ctx.createMangleNumberingContext(); 350 return *MangleNumbering; 351 } 352 353 CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class, 354 SourceRange IntroducerRange, 355 TypeSourceInfo *MethodTypeInfo, 356 SourceLocation EndLoc, 357 ArrayRef<ParmVarDecl *> Params) { 358 QualType MethodType = MethodTypeInfo->getType(); 359 TemplateParameterList *TemplateParams = 360 getGenericLambdaTemplateParameterList(getCurLambda(), *this); 361 // If a lambda appears in a dependent context or is a generic lambda (has 362 // template parameters) and has an 'auto' return type, deduce it to a 363 // dependent type. 364 if (Class->isDependentContext() || TemplateParams) { 365 const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>(); 366 QualType Result = FPT->getReturnType(); 367 if (Result->isUndeducedType()) { 368 Result = SubstAutoType(Result, Context.DependentTy); 369 MethodType = Context.getFunctionType(Result, FPT->getParamTypes(), 370 FPT->getExtProtoInfo()); 371 } 372 } 373 374 // C++11 [expr.prim.lambda]p5: 375 // The closure type for a lambda-expression has a public inline function 376 // call operator (13.5.4) whose parameters and return type are described by 377 // the lambda-expression's parameter-declaration-clause and 378 // trailing-return-type respectively. 379 DeclarationName MethodName 380 = Context.DeclarationNames.getCXXOperatorName(OO_Call); 381 DeclarationNameLoc MethodNameLoc; 382 MethodNameLoc.CXXOperatorName.BeginOpNameLoc 383 = IntroducerRange.getBegin().getRawEncoding(); 384 MethodNameLoc.CXXOperatorName.EndOpNameLoc 385 = IntroducerRange.getEnd().getRawEncoding(); 386 CXXMethodDecl *Method 387 = CXXMethodDecl::Create(Context, Class, EndLoc, 388 DeclarationNameInfo(MethodName, 389 IntroducerRange.getBegin(), 390 MethodNameLoc), 391 MethodType, MethodTypeInfo, 392 SC_None, 393 /*isInline=*/true, 394 /*isConstExpr=*/false, 395 EndLoc); 396 Method->setAccess(AS_public); 397 398 // Temporarily set the lexical declaration context to the current 399 // context, so that the Scope stack matches the lexical nesting. 400 Method->setLexicalDeclContext(CurContext); 401 // Create a function template if we have a template parameter list 402 FunctionTemplateDecl *const TemplateMethod = TemplateParams ? 403 FunctionTemplateDecl::Create(Context, Class, 404 Method->getLocation(), MethodName, 405 TemplateParams, 406 Method) : nullptr; 407 if (TemplateMethod) { 408 TemplateMethod->setLexicalDeclContext(CurContext); 409 TemplateMethod->setAccess(AS_public); 410 Method->setDescribedFunctionTemplate(TemplateMethod); 411 } 412 413 // Add parameters. 414 if (!Params.empty()) { 415 Method->setParams(Params); 416 CheckParmsForFunctionDef(const_cast<ParmVarDecl **>(Params.begin()), 417 const_cast<ParmVarDecl **>(Params.end()), 418 /*CheckParameterNames=*/false); 419 420 for (auto P : Method->params()) 421 P->setOwningFunction(Method); 422 } 423 424 Decl *ManglingContextDecl; 425 if (MangleNumberingContext *MCtx = 426 getCurrentMangleNumberContext(Class->getDeclContext(), 427 ManglingContextDecl)) { 428 unsigned ManglingNumber = MCtx->getManglingNumber(Method); 429 Class->setLambdaMangling(ManglingNumber, ManglingContextDecl); 430 } 431 432 return Method; 433 } 434 435 void Sema::buildLambdaScope(LambdaScopeInfo *LSI, 436 CXXMethodDecl *CallOperator, 437 SourceRange IntroducerRange, 438 LambdaCaptureDefault CaptureDefault, 439 SourceLocation CaptureDefaultLoc, 440 bool ExplicitParams, 441 bool ExplicitResultType, 442 bool Mutable) { 443 LSI->CallOperator = CallOperator; 444 CXXRecordDecl *LambdaClass = CallOperator->getParent(); 445 LSI->Lambda = LambdaClass; 446 if (CaptureDefault == LCD_ByCopy) 447 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval; 448 else if (CaptureDefault == LCD_ByRef) 449 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref; 450 LSI->CaptureDefaultLoc = CaptureDefaultLoc; 451 LSI->IntroducerRange = IntroducerRange; 452 LSI->ExplicitParams = ExplicitParams; 453 LSI->Mutable = Mutable; 454 455 if (ExplicitResultType) { 456 LSI->ReturnType = CallOperator->getReturnType(); 457 458 if (!LSI->ReturnType->isDependentType() && 459 !LSI->ReturnType->isVoidType()) { 460 if (RequireCompleteType(CallOperator->getLocStart(), LSI->ReturnType, 461 diag::err_lambda_incomplete_result)) { 462 // Do nothing. 463 } 464 } 465 } else { 466 LSI->HasImplicitReturnType = true; 467 } 468 } 469 470 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) { 471 LSI->finishedExplicitCaptures(); 472 } 473 474 void Sema::addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope) { 475 // Introduce our parameters into the function scope 476 for (unsigned p = 0, NumParams = CallOperator->getNumParams(); 477 p < NumParams; ++p) { 478 ParmVarDecl *Param = CallOperator->getParamDecl(p); 479 480 // If this has an identifier, add it to the scope stack. 481 if (CurScope && Param->getIdentifier()) { 482 CheckShadow(CurScope, Param); 483 484 PushOnScopeChains(Param, CurScope); 485 } 486 } 487 } 488 489 /// If this expression is an enumerator-like expression of some type 490 /// T, return the type T; otherwise, return null. 491 /// 492 /// Pointer comparisons on the result here should always work because 493 /// it's derived from either the parent of an EnumConstantDecl 494 /// (i.e. the definition) or the declaration returned by 495 /// EnumType::getDecl() (i.e. the definition). 496 static EnumDecl *findEnumForBlockReturn(Expr *E) { 497 // An expression is an enumerator-like expression of type T if, 498 // ignoring parens and parens-like expressions: 499 E = E->IgnoreParens(); 500 501 // - it is an enumerator whose enum type is T or 502 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 503 if (EnumConstantDecl *D 504 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 505 return cast<EnumDecl>(D->getDeclContext()); 506 } 507 return nullptr; 508 } 509 510 // - it is a comma expression whose RHS is an enumerator-like 511 // expression of type T or 512 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 513 if (BO->getOpcode() == BO_Comma) 514 return findEnumForBlockReturn(BO->getRHS()); 515 return nullptr; 516 } 517 518 // - it is a statement-expression whose value expression is an 519 // enumerator-like expression of type T or 520 if (StmtExpr *SE = dyn_cast<StmtExpr>(E)) { 521 if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back())) 522 return findEnumForBlockReturn(last); 523 return nullptr; 524 } 525 526 // - it is a ternary conditional operator (not the GNU ?: 527 // extension) whose second and third operands are 528 // enumerator-like expressions of type T or 529 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 530 if (EnumDecl *ED = findEnumForBlockReturn(CO->getTrueExpr())) 531 if (ED == findEnumForBlockReturn(CO->getFalseExpr())) 532 return ED; 533 return nullptr; 534 } 535 536 // (implicitly:) 537 // - it is an implicit integral conversion applied to an 538 // enumerator-like expression of type T or 539 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 540 // We can sometimes see integral conversions in valid 541 // enumerator-like expressions. 542 if (ICE->getCastKind() == CK_IntegralCast) 543 return findEnumForBlockReturn(ICE->getSubExpr()); 544 545 // Otherwise, just rely on the type. 546 } 547 548 // - it is an expression of that formal enum type. 549 if (const EnumType *ET = E->getType()->getAs<EnumType>()) { 550 return ET->getDecl(); 551 } 552 553 // Otherwise, nope. 554 return nullptr; 555 } 556 557 /// Attempt to find a type T for which the returned expression of the 558 /// given statement is an enumerator-like expression of that type. 559 static EnumDecl *findEnumForBlockReturn(ReturnStmt *ret) { 560 if (Expr *retValue = ret->getRetValue()) 561 return findEnumForBlockReturn(retValue); 562 return nullptr; 563 } 564 565 /// Attempt to find a common type T for which all of the returned 566 /// expressions in a block are enumerator-like expressions of that 567 /// type. 568 static EnumDecl *findCommonEnumForBlockReturns(ArrayRef<ReturnStmt*> returns) { 569 ArrayRef<ReturnStmt*>::iterator i = returns.begin(), e = returns.end(); 570 571 // Try to find one for the first return. 572 EnumDecl *ED = findEnumForBlockReturn(*i); 573 if (!ED) return nullptr; 574 575 // Check that the rest of the returns have the same enum. 576 for (++i; i != e; ++i) { 577 if (findEnumForBlockReturn(*i) != ED) 578 return nullptr; 579 } 580 581 // Never infer an anonymous enum type. 582 if (!ED->hasNameForLinkage()) return nullptr; 583 584 return ED; 585 } 586 587 /// Adjust the given return statements so that they formally return 588 /// the given type. It should require, at most, an IntegralCast. 589 static void adjustBlockReturnsToEnum(Sema &S, ArrayRef<ReturnStmt*> returns, 590 QualType returnType) { 591 for (ArrayRef<ReturnStmt*>::iterator 592 i = returns.begin(), e = returns.end(); i != e; ++i) { 593 ReturnStmt *ret = *i; 594 Expr *retValue = ret->getRetValue(); 595 if (S.Context.hasSameType(retValue->getType(), returnType)) 596 continue; 597 598 // Right now we only support integral fixup casts. 599 assert(returnType->isIntegralOrUnscopedEnumerationType()); 600 assert(retValue->getType()->isIntegralOrUnscopedEnumerationType()); 601 602 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(retValue); 603 604 Expr *E = (cleanups ? cleanups->getSubExpr() : retValue); 605 E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast, 606 E, /*base path*/ nullptr, VK_RValue); 607 if (cleanups) { 608 cleanups->setSubExpr(E); 609 } else { 610 ret->setRetValue(E); 611 } 612 } 613 } 614 615 void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) { 616 assert(CSI.HasImplicitReturnType); 617 // If it was ever a placeholder, it had to been deduced to DependentTy. 618 assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType()); 619 620 // C++ core issue 975: 621 // If a lambda-expression does not include a trailing-return-type, 622 // it is as if the trailing-return-type denotes the following type: 623 // - if there are no return statements in the compound-statement, 624 // or all return statements return either an expression of type 625 // void or no expression or braced-init-list, the type void; 626 // - otherwise, if all return statements return an expression 627 // and the types of the returned expressions after 628 // lvalue-to-rvalue conversion (4.1 [conv.lval]), 629 // array-to-pointer conversion (4.2 [conv.array]), and 630 // function-to-pointer conversion (4.3 [conv.func]) are the 631 // same, that common type; 632 // - otherwise, the program is ill-formed. 633 // 634 // C++ core issue 1048 additionally removes top-level cv-qualifiers 635 // from the types of returned expressions to match the C++14 auto 636 // deduction rules. 637 // 638 // In addition, in blocks in non-C++ modes, if all of the return 639 // statements are enumerator-like expressions of some type T, where 640 // T has a name for linkage, then we infer the return type of the 641 // block to be that type. 642 643 // First case: no return statements, implicit void return type. 644 ASTContext &Ctx = getASTContext(); 645 if (CSI.Returns.empty()) { 646 // It's possible there were simply no /valid/ return statements. 647 // In this case, the first one we found may have at least given us a type. 648 if (CSI.ReturnType.isNull()) 649 CSI.ReturnType = Ctx.VoidTy; 650 return; 651 } 652 653 // Second case: at least one return statement has dependent type. 654 // Delay type checking until instantiation. 655 assert(!CSI.ReturnType.isNull() && "We should have a tentative return type."); 656 if (CSI.ReturnType->isDependentType()) 657 return; 658 659 // Try to apply the enum-fuzz rule. 660 if (!getLangOpts().CPlusPlus) { 661 assert(isa<BlockScopeInfo>(CSI)); 662 const EnumDecl *ED = findCommonEnumForBlockReturns(CSI.Returns); 663 if (ED) { 664 CSI.ReturnType = Context.getTypeDeclType(ED); 665 adjustBlockReturnsToEnum(*this, CSI.Returns, CSI.ReturnType); 666 return; 667 } 668 } 669 670 // Third case: only one return statement. Don't bother doing extra work! 671 SmallVectorImpl<ReturnStmt*>::iterator I = CSI.Returns.begin(), 672 E = CSI.Returns.end(); 673 if (I+1 == E) 674 return; 675 676 // General case: many return statements. 677 // Check that they all have compatible return types. 678 679 // We require the return types to strictly match here. 680 // Note that we've already done the required promotions as part of 681 // processing the return statement. 682 for (; I != E; ++I) { 683 const ReturnStmt *RS = *I; 684 const Expr *RetE = RS->getRetValue(); 685 686 QualType ReturnType = 687 (RetE ? RetE->getType() : Context.VoidTy).getUnqualifiedType(); 688 if (Context.hasSameType(ReturnType, CSI.ReturnType)) 689 continue; 690 691 // FIXME: This is a poor diagnostic for ReturnStmts without expressions. 692 // TODO: It's possible that the *first* return is the divergent one. 693 Diag(RS->getLocStart(), 694 diag::err_typecheck_missing_return_type_incompatible) 695 << ReturnType << CSI.ReturnType 696 << isa<LambdaScopeInfo>(CSI); 697 // Continue iterating so that we keep emitting diagnostics. 698 } 699 } 700 701 QualType Sema::performLambdaInitCaptureInitialization(SourceLocation Loc, 702 bool ByRef, 703 IdentifierInfo *Id, 704 Expr *&Init) { 705 706 // We do not need to distinguish between direct-list-initialization 707 // and copy-list-initialization here, because we will always deduce 708 // std::initializer_list<T>, and direct- and copy-list-initialization 709 // always behave the same for such a type. 710 // FIXME: We should model whether an '=' was present. 711 const bool IsDirectInit = isa<ParenListExpr>(Init) || isa<InitListExpr>(Init); 712 713 // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to 714 // deduce against. 715 QualType DeductType = Context.getAutoDeductType(); 716 TypeLocBuilder TLB; 717 TLB.pushTypeSpec(DeductType).setNameLoc(Loc); 718 if (ByRef) { 719 DeductType = BuildReferenceType(DeductType, true, Loc, Id); 720 assert(!DeductType.isNull() && "can't build reference to auto"); 721 TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc); 722 } 723 TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType); 724 725 // Are we a non-list direct initialization? 726 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 727 728 Expr *DeduceInit = Init; 729 // Initializer could be a C++ direct-initializer. Deduction only works if it 730 // contains exactly one expression. 731 if (CXXDirectInit) { 732 if (CXXDirectInit->getNumExprs() == 0) { 733 Diag(CXXDirectInit->getLocStart(), diag::err_init_capture_no_expression) 734 << DeclarationName(Id) << TSI->getType() << Loc; 735 return QualType(); 736 } else if (CXXDirectInit->getNumExprs() > 1) { 737 Diag(CXXDirectInit->getExpr(1)->getLocStart(), 738 diag::err_init_capture_multiple_expressions) 739 << DeclarationName(Id) << TSI->getType() << Loc; 740 return QualType(); 741 } else { 742 DeduceInit = CXXDirectInit->getExpr(0); 743 if (isa<InitListExpr>(DeduceInit)) 744 Diag(CXXDirectInit->getLocStart(), diag::err_init_capture_paren_braces) 745 << DeclarationName(Id) << Loc; 746 } 747 } 748 749 // Now deduce against the initialization expression and store the deduced 750 // type below. 751 QualType DeducedType; 752 if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) { 753 if (isa<InitListExpr>(Init)) 754 Diag(Loc, diag::err_init_capture_deduction_failure_from_init_list) 755 << DeclarationName(Id) 756 << (DeduceInit->getType().isNull() ? TSI->getType() 757 : DeduceInit->getType()) 758 << DeduceInit->getSourceRange(); 759 else 760 Diag(Loc, diag::err_init_capture_deduction_failure) 761 << DeclarationName(Id) << TSI->getType() 762 << (DeduceInit->getType().isNull() ? TSI->getType() 763 : DeduceInit->getType()) 764 << DeduceInit->getSourceRange(); 765 } 766 if (DeducedType.isNull()) 767 return QualType(); 768 769 // Perform initialization analysis and ensure any implicit conversions 770 // (such as lvalue-to-rvalue) are enforced. 771 InitializedEntity Entity = 772 InitializedEntity::InitializeLambdaCapture(Id, DeducedType, Loc); 773 InitializationKind Kind = 774 IsDirectInit 775 ? (CXXDirectInit ? InitializationKind::CreateDirect( 776 Loc, Init->getLocStart(), Init->getLocEnd()) 777 : InitializationKind::CreateDirectList(Loc)) 778 : InitializationKind::CreateCopy(Loc, Init->getLocStart()); 779 780 MultiExprArg Args = Init; 781 if (CXXDirectInit) 782 Args = 783 MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs()); 784 QualType DclT; 785 InitializationSequence InitSeq(*this, Entity, Kind, Args); 786 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 787 788 if (Result.isInvalid()) 789 return QualType(); 790 Init = Result.getAs<Expr>(); 791 792 // The init-capture initialization is a full-expression that must be 793 // processed as one before we enter the declcontext of the lambda's 794 // call-operator. 795 Result = ActOnFinishFullExpr(Init, Loc, /*DiscardedValue*/ false, 796 /*IsConstexpr*/ false, 797 /*IsLambdaInitCaptureInitalizer*/ true); 798 if (Result.isInvalid()) 799 return QualType(); 800 801 Init = Result.getAs<Expr>(); 802 return DeducedType; 803 } 804 805 VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc, 806 QualType InitCaptureType, IdentifierInfo *Id, Expr *Init) { 807 808 TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType, 809 Loc); 810 // Create a dummy variable representing the init-capture. This is not actually 811 // used as a variable, and only exists as a way to name and refer to the 812 // init-capture. 813 // FIXME: Pass in separate source locations for '&' and identifier. 814 VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc, 815 Loc, Id, InitCaptureType, TSI, SC_Auto); 816 NewVD->setInitCapture(true); 817 NewVD->setReferenced(true); 818 NewVD->markUsed(Context); 819 NewVD->setInit(Init); 820 return NewVD; 821 822 } 823 824 FieldDecl *Sema::buildInitCaptureField(LambdaScopeInfo *LSI, VarDecl *Var) { 825 FieldDecl *Field = FieldDecl::Create( 826 Context, LSI->Lambda, Var->getLocation(), Var->getLocation(), 827 nullptr, Var->getType(), Var->getTypeSourceInfo(), nullptr, false, 828 ICIS_NoInit); 829 Field->setImplicit(true); 830 Field->setAccess(AS_private); 831 LSI->Lambda->addDecl(Field); 832 833 LSI->addCapture(Var, /*isBlock*/false, Var->getType()->isReferenceType(), 834 /*isNested*/false, Var->getLocation(), SourceLocation(), 835 Var->getType(), Var->getInit()); 836 return Field; 837 } 838 839 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, 840 Declarator &ParamInfo, Scope *CurScope) { 841 // Determine if we're within a context where we know that the lambda will 842 // be dependent, because there are template parameters in scope. 843 bool KnownDependent = false; 844 LambdaScopeInfo *const LSI = getCurLambda(); 845 assert(LSI && "LambdaScopeInfo should be on stack!"); 846 TemplateParameterList *TemplateParams = 847 getGenericLambdaTemplateParameterList(LSI, *this); 848 849 if (Scope *TmplScope = CurScope->getTemplateParamParent()) { 850 // Since we have our own TemplateParams, so check if an outer scope 851 // has template params, only then are we in a dependent scope. 852 if (TemplateParams) { 853 TmplScope = TmplScope->getParent(); 854 TmplScope = TmplScope ? TmplScope->getTemplateParamParent() : nullptr; 855 } 856 if (TmplScope && !TmplScope->decl_empty()) 857 KnownDependent = true; 858 } 859 // Determine the signature of the call operator. 860 TypeSourceInfo *MethodTyInfo; 861 bool ExplicitParams = true; 862 bool ExplicitResultType = true; 863 bool ContainsUnexpandedParameterPack = false; 864 SourceLocation EndLoc; 865 SmallVector<ParmVarDecl *, 8> Params; 866 if (ParamInfo.getNumTypeObjects() == 0) { 867 // C++11 [expr.prim.lambda]p4: 868 // If a lambda-expression does not include a lambda-declarator, it is as 869 // if the lambda-declarator were (). 870 FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention( 871 /*IsVariadic=*/false, /*IsCXXMethod=*/true)); 872 EPI.HasTrailingReturn = true; 873 EPI.TypeQuals |= DeclSpec::TQ_const; 874 // C++1y [expr.prim.lambda]: 875 // The lambda return type is 'auto', which is replaced by the 876 // trailing-return type if provided and/or deduced from 'return' 877 // statements 878 // We don't do this before C++1y, because we don't support deduced return 879 // types there. 880 QualType DefaultTypeForNoTrailingReturn = 881 getLangOpts().CPlusPlus14 ? Context.getAutoDeductType() 882 : Context.DependentTy; 883 QualType MethodTy = 884 Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI); 885 MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy); 886 ExplicitParams = false; 887 ExplicitResultType = false; 888 EndLoc = Intro.Range.getEnd(); 889 } else { 890 assert(ParamInfo.isFunctionDeclarator() && 891 "lambda-declarator is a function"); 892 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo(); 893 894 // C++11 [expr.prim.lambda]p5: 895 // This function call operator is declared const (9.3.1) if and only if 896 // the lambda-expression's parameter-declaration-clause is not followed 897 // by mutable. It is neither virtual nor declared volatile. [...] 898 if (!FTI.hasMutableQualifier()) 899 FTI.TypeQuals |= DeclSpec::TQ_const; 900 901 MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope); 902 assert(MethodTyInfo && "no type from lambda-declarator"); 903 EndLoc = ParamInfo.getSourceRange().getEnd(); 904 905 ExplicitResultType = FTI.hasTrailingReturnType(); 906 907 if (FTIHasNonVoidParameters(FTI)) { 908 Params.reserve(FTI.NumParams); 909 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) 910 Params.push_back(cast<ParmVarDecl>(FTI.Params[i].Param)); 911 } 912 913 // Check for unexpanded parameter packs in the method type. 914 if (MethodTyInfo->getType()->containsUnexpandedParameterPack()) 915 ContainsUnexpandedParameterPack = true; 916 } 917 918 CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo, 919 KnownDependent, Intro.Default); 920 921 CXXMethodDecl *Method = startLambdaDefinition(Class, Intro.Range, 922 MethodTyInfo, EndLoc, Params); 923 if (ExplicitParams) 924 CheckCXXDefaultArguments(Method); 925 926 // Attributes on the lambda apply to the method. 927 ProcessDeclAttributes(CurScope, Method, ParamInfo); 928 929 // Introduce the function call operator as the current declaration context. 930 PushDeclContext(CurScope, Method); 931 932 // Build the lambda scope. 933 buildLambdaScope(LSI, Method, 934 Intro.Range, 935 Intro.Default, Intro.DefaultLoc, 936 ExplicitParams, 937 ExplicitResultType, 938 !Method->isConst()); 939 940 // C++11 [expr.prim.lambda]p9: 941 // A lambda-expression whose smallest enclosing scope is a block scope is a 942 // local lambda expression; any other lambda expression shall not have a 943 // capture-default or simple-capture in its lambda-introducer. 944 // 945 // For simple-captures, this is covered by the check below that any named 946 // entity is a variable that can be captured. 947 // 948 // For DR1632, we also allow a capture-default in any context where we can 949 // odr-use 'this' (in particular, in a default initializer for a non-static 950 // data member). 951 if (Intro.Default != LCD_None && !Class->getParent()->isFunctionOrMethod() && 952 (getCurrentThisType().isNull() || 953 CheckCXXThisCapture(SourceLocation(), /*Explicit*/true, 954 /*BuildAndDiagnose*/false))) 955 Diag(Intro.DefaultLoc, diag::err_capture_default_non_local); 956 957 // Distinct capture names, for diagnostics. 958 llvm::SmallSet<IdentifierInfo*, 8> CaptureNames; 959 960 // Handle explicit captures. 961 SourceLocation PrevCaptureLoc 962 = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc; 963 for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; 964 PrevCaptureLoc = C->Loc, ++C) { 965 if (C->Kind == LCK_This) { 966 // C++11 [expr.prim.lambda]p8: 967 // An identifier or this shall not appear more than once in a 968 // lambda-capture. 969 if (LSI->isCXXThisCaptured()) { 970 Diag(C->Loc, diag::err_capture_more_than_once) 971 << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation()) 972 << FixItHint::CreateRemoval( 973 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 974 continue; 975 } 976 977 // C++11 [expr.prim.lambda]p8: 978 // If a lambda-capture includes a capture-default that is =, the 979 // lambda-capture shall not contain this [...]. 980 if (Intro.Default == LCD_ByCopy) { 981 Diag(C->Loc, diag::err_this_capture_with_copy_default) 982 << FixItHint::CreateRemoval( 983 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 984 continue; 985 } 986 987 // C++11 [expr.prim.lambda]p12: 988 // If this is captured by a local lambda expression, its nearest 989 // enclosing function shall be a non-static member function. 990 QualType ThisCaptureType = getCurrentThisType(); 991 if (ThisCaptureType.isNull()) { 992 Diag(C->Loc, diag::err_this_capture) << true; 993 continue; 994 } 995 996 CheckCXXThisCapture(C->Loc, /*Explicit=*/true); 997 continue; 998 } 999 1000 assert(C->Id && "missing identifier for capture"); 1001 1002 if (C->Init.isInvalid()) 1003 continue; 1004 1005 VarDecl *Var = nullptr; 1006 if (C->Init.isUsable()) { 1007 Diag(C->Loc, getLangOpts().CPlusPlus14 1008 ? diag::warn_cxx11_compat_init_capture 1009 : diag::ext_init_capture); 1010 1011 if (C->Init.get()->containsUnexpandedParameterPack()) 1012 ContainsUnexpandedParameterPack = true; 1013 // If the initializer expression is usable, but the InitCaptureType 1014 // is not, then an error has occurred - so ignore the capture for now. 1015 // for e.g., [n{0}] { }; <-- if no <initializer_list> is included. 1016 // FIXME: we should create the init capture variable and mark it invalid 1017 // in this case. 1018 if (C->InitCaptureType.get().isNull()) 1019 continue; 1020 Var = createLambdaInitCaptureVarDecl(C->Loc, C->InitCaptureType.get(), 1021 C->Id, C->Init.get()); 1022 // C++1y [expr.prim.lambda]p11: 1023 // An init-capture behaves as if it declares and explicitly 1024 // captures a variable [...] whose declarative region is the 1025 // lambda-expression's compound-statement 1026 if (Var) 1027 PushOnScopeChains(Var, CurScope, false); 1028 } else { 1029 // C++11 [expr.prim.lambda]p8: 1030 // If a lambda-capture includes a capture-default that is &, the 1031 // identifiers in the lambda-capture shall not be preceded by &. 1032 // If a lambda-capture includes a capture-default that is =, [...] 1033 // each identifier it contains shall be preceded by &. 1034 if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) { 1035 Diag(C->Loc, diag::err_reference_capture_with_reference_default) 1036 << FixItHint::CreateRemoval( 1037 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1038 continue; 1039 } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) { 1040 Diag(C->Loc, diag::err_copy_capture_with_copy_default) 1041 << FixItHint::CreateRemoval( 1042 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1043 continue; 1044 } 1045 1046 // C++11 [expr.prim.lambda]p10: 1047 // The identifiers in a capture-list are looked up using the usual 1048 // rules for unqualified name lookup (3.4.1) 1049 DeclarationNameInfo Name(C->Id, C->Loc); 1050 LookupResult R(*this, Name, LookupOrdinaryName); 1051 LookupName(R, CurScope); 1052 if (R.isAmbiguous()) 1053 continue; 1054 if (R.empty()) { 1055 // FIXME: Disable corrections that would add qualification? 1056 CXXScopeSpec ScopeSpec; 1057 if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R, 1058 llvm::make_unique<DeclFilterCCC<VarDecl>>())) 1059 continue; 1060 } 1061 1062 Var = R.getAsSingle<VarDecl>(); 1063 if (Var && DiagnoseUseOfDecl(Var, C->Loc)) 1064 continue; 1065 } 1066 1067 // C++11 [expr.prim.lambda]p8: 1068 // An identifier or this shall not appear more than once in a 1069 // lambda-capture. 1070 if (!CaptureNames.insert(C->Id).second) { 1071 if (Var && LSI->isCaptured(Var)) { 1072 Diag(C->Loc, diag::err_capture_more_than_once) 1073 << C->Id << SourceRange(LSI->getCapture(Var).getLocation()) 1074 << FixItHint::CreateRemoval( 1075 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 1076 } else 1077 // Previous capture captured something different (one or both was 1078 // an init-cpature): no fixit. 1079 Diag(C->Loc, diag::err_capture_more_than_once) << C->Id; 1080 continue; 1081 } 1082 1083 // C++11 [expr.prim.lambda]p10: 1084 // [...] each such lookup shall find a variable with automatic storage 1085 // duration declared in the reaching scope of the local lambda expression. 1086 // Note that the 'reaching scope' check happens in tryCaptureVariable(). 1087 if (!Var) { 1088 Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id; 1089 continue; 1090 } 1091 1092 // Ignore invalid decls; they'll just confuse the code later. 1093 if (Var->isInvalidDecl()) 1094 continue; 1095 1096 if (!Var->hasLocalStorage()) { 1097 Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id; 1098 Diag(Var->getLocation(), diag::note_previous_decl) << C->Id; 1099 continue; 1100 } 1101 1102 // C++11 [expr.prim.lambda]p23: 1103 // A capture followed by an ellipsis is a pack expansion (14.5.3). 1104 SourceLocation EllipsisLoc; 1105 if (C->EllipsisLoc.isValid()) { 1106 if (Var->isParameterPack()) { 1107 EllipsisLoc = C->EllipsisLoc; 1108 } else { 1109 Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 1110 << SourceRange(C->Loc); 1111 1112 // Just ignore the ellipsis. 1113 } 1114 } else if (Var->isParameterPack()) { 1115 ContainsUnexpandedParameterPack = true; 1116 } 1117 1118 if (C->Init.isUsable()) { 1119 buildInitCaptureField(LSI, Var); 1120 } else { 1121 TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef : 1122 TryCapture_ExplicitByVal; 1123 tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc); 1124 } 1125 } 1126 finishLambdaExplicitCaptures(LSI); 1127 1128 LSI->ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 1129 1130 // Add lambda parameters into scope. 1131 addLambdaParameters(Method, CurScope); 1132 1133 // Enter a new evaluation context to insulate the lambda from any 1134 // cleanups from the enclosing full-expression. 1135 PushExpressionEvaluationContext(PotentiallyEvaluated); 1136 } 1137 1138 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, 1139 bool IsInstantiation) { 1140 LambdaScopeInfo *LSI = getCurLambda(); 1141 1142 // Leave the expression-evaluation context. 1143 DiscardCleanupsInEvaluationContext(); 1144 PopExpressionEvaluationContext(); 1145 1146 // Leave the context of the lambda. 1147 if (!IsInstantiation) 1148 PopDeclContext(); 1149 1150 // Finalize the lambda. 1151 CXXRecordDecl *Class = LSI->Lambda; 1152 Class->setInvalidDecl(); 1153 SmallVector<Decl*, 4> Fields(Class->fields()); 1154 ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(), 1155 SourceLocation(), nullptr); 1156 CheckCompletedCXXClass(Class); 1157 1158 PopFunctionScopeInfo(); 1159 } 1160 1161 /// \brief Add a lambda's conversion to function pointer, as described in 1162 /// C++11 [expr.prim.lambda]p6. 1163 static void addFunctionPointerConversion(Sema &S, 1164 SourceRange IntroducerRange, 1165 CXXRecordDecl *Class, 1166 CXXMethodDecl *CallOperator) { 1167 // Add the conversion to function pointer. 1168 const FunctionProtoType *CallOpProto = 1169 CallOperator->getType()->getAs<FunctionProtoType>(); 1170 const FunctionProtoType::ExtProtoInfo CallOpExtInfo = 1171 CallOpProto->getExtProtoInfo(); 1172 QualType PtrToFunctionTy; 1173 QualType InvokerFunctionTy; 1174 { 1175 FunctionProtoType::ExtProtoInfo InvokerExtInfo = CallOpExtInfo; 1176 CallingConv CC = S.Context.getDefaultCallingConvention( 1177 CallOpProto->isVariadic(), /*IsCXXMethod=*/false); 1178 InvokerExtInfo.ExtInfo = InvokerExtInfo.ExtInfo.withCallingConv(CC); 1179 InvokerExtInfo.TypeQuals = 0; 1180 assert(InvokerExtInfo.RefQualifier == RQ_None && 1181 "Lambda's call operator should not have a reference qualifier"); 1182 InvokerFunctionTy = 1183 S.Context.getFunctionType(CallOpProto->getReturnType(), 1184 CallOpProto->getParamTypes(), InvokerExtInfo); 1185 PtrToFunctionTy = S.Context.getPointerType(InvokerFunctionTy); 1186 } 1187 1188 // Create the type of the conversion function. 1189 FunctionProtoType::ExtProtoInfo ConvExtInfo( 1190 S.Context.getDefaultCallingConvention( 1191 /*IsVariadic=*/false, /*IsCXXMethod=*/true)); 1192 // The conversion function is always const. 1193 ConvExtInfo.TypeQuals = Qualifiers::Const; 1194 QualType ConvTy = 1195 S.Context.getFunctionType(PtrToFunctionTy, None, ConvExtInfo); 1196 1197 SourceLocation Loc = IntroducerRange.getBegin(); 1198 DeclarationName ConversionName 1199 = S.Context.DeclarationNames.getCXXConversionFunctionName( 1200 S.Context.getCanonicalType(PtrToFunctionTy)); 1201 DeclarationNameLoc ConvNameLoc; 1202 // Construct a TypeSourceInfo for the conversion function, and wire 1203 // all the parameters appropriately for the FunctionProtoTypeLoc 1204 // so that everything works during transformation/instantiation of 1205 // generic lambdas. 1206 // The main reason for wiring up the parameters of the conversion 1207 // function with that of the call operator is so that constructs 1208 // like the following work: 1209 // auto L = [](auto b) { <-- 1 1210 // return [](auto a) -> decltype(a) { <-- 2 1211 // return a; 1212 // }; 1213 // }; 1214 // int (*fp)(int) = L(5); 1215 // Because the trailing return type can contain DeclRefExprs that refer 1216 // to the original call operator's variables, we hijack the call 1217 // operators ParmVarDecls below. 1218 TypeSourceInfo *ConvNamePtrToFunctionTSI = 1219 S.Context.getTrivialTypeSourceInfo(PtrToFunctionTy, Loc); 1220 ConvNameLoc.NamedType.TInfo = ConvNamePtrToFunctionTSI; 1221 1222 // The conversion function is a conversion to a pointer-to-function. 1223 TypeSourceInfo *ConvTSI = S.Context.getTrivialTypeSourceInfo(ConvTy, Loc); 1224 FunctionProtoTypeLoc ConvTL = 1225 ConvTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>(); 1226 // Get the result of the conversion function which is a pointer-to-function. 1227 PointerTypeLoc PtrToFunctionTL = 1228 ConvTL.getReturnLoc().getAs<PointerTypeLoc>(); 1229 // Do the same for the TypeSourceInfo that is used to name the conversion 1230 // operator. 1231 PointerTypeLoc ConvNamePtrToFunctionTL = 1232 ConvNamePtrToFunctionTSI->getTypeLoc().getAs<PointerTypeLoc>(); 1233 1234 // Get the underlying function types that the conversion function will 1235 // be converting to (should match the type of the call operator). 1236 FunctionProtoTypeLoc CallOpConvTL = 1237 PtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>(); 1238 FunctionProtoTypeLoc CallOpConvNameTL = 1239 ConvNamePtrToFunctionTL.getPointeeLoc().getAs<FunctionProtoTypeLoc>(); 1240 1241 // Wire up the FunctionProtoTypeLocs with the call operator's parameters. 1242 // These parameter's are essentially used to transform the name and 1243 // the type of the conversion operator. By using the same parameters 1244 // as the call operator's we don't have to fix any back references that 1245 // the trailing return type of the call operator's uses (such as 1246 // decltype(some_type<decltype(a)>::type{} + decltype(a){}) etc.) 1247 // - we can simply use the return type of the call operator, and 1248 // everything should work. 1249 SmallVector<ParmVarDecl *, 4> InvokerParams; 1250 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 1251 ParmVarDecl *From = CallOperator->getParamDecl(I); 1252 1253 InvokerParams.push_back(ParmVarDecl::Create(S.Context, 1254 // Temporarily add to the TU. This is set to the invoker below. 1255 S.Context.getTranslationUnitDecl(), 1256 From->getLocStart(), 1257 From->getLocation(), 1258 From->getIdentifier(), 1259 From->getType(), 1260 From->getTypeSourceInfo(), 1261 From->getStorageClass(), 1262 /*DefaultArg=*/nullptr)); 1263 CallOpConvTL.setParam(I, From); 1264 CallOpConvNameTL.setParam(I, From); 1265 } 1266 1267 CXXConversionDecl *Conversion 1268 = CXXConversionDecl::Create(S.Context, Class, Loc, 1269 DeclarationNameInfo(ConversionName, 1270 Loc, ConvNameLoc), 1271 ConvTy, 1272 ConvTSI, 1273 /*isInline=*/true, /*isExplicit=*/false, 1274 /*isConstexpr=*/false, 1275 CallOperator->getBody()->getLocEnd()); 1276 Conversion->setAccess(AS_public); 1277 Conversion->setImplicit(true); 1278 1279 if (Class->isGenericLambda()) { 1280 // Create a template version of the conversion operator, using the template 1281 // parameter list of the function call operator. 1282 FunctionTemplateDecl *TemplateCallOperator = 1283 CallOperator->getDescribedFunctionTemplate(); 1284 FunctionTemplateDecl *ConversionTemplate = 1285 FunctionTemplateDecl::Create(S.Context, Class, 1286 Loc, ConversionName, 1287 TemplateCallOperator->getTemplateParameters(), 1288 Conversion); 1289 ConversionTemplate->setAccess(AS_public); 1290 ConversionTemplate->setImplicit(true); 1291 Conversion->setDescribedFunctionTemplate(ConversionTemplate); 1292 Class->addDecl(ConversionTemplate); 1293 } else 1294 Class->addDecl(Conversion); 1295 // Add a non-static member function that will be the result of 1296 // the conversion with a certain unique ID. 1297 DeclarationName InvokerName = &S.Context.Idents.get( 1298 getLambdaStaticInvokerName()); 1299 // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo() 1300 // we should get a prebuilt TrivialTypeSourceInfo from Context 1301 // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc 1302 // then rewire the parameters accordingly, by hoisting up the InvokeParams 1303 // loop below and then use its Params to set Invoke->setParams(...) below. 1304 // This would avoid the 'const' qualifier of the calloperator from 1305 // contaminating the type of the invoker, which is currently adjusted 1306 // in SemaTemplateDeduction.cpp:DeduceTemplateArguments. Fixing the 1307 // trailing return type of the invoker would require a visitor to rebuild 1308 // the trailing return type and adjusting all back DeclRefExpr's to refer 1309 // to the new static invoker parameters - not the call operator's. 1310 CXXMethodDecl *Invoke 1311 = CXXMethodDecl::Create(S.Context, Class, Loc, 1312 DeclarationNameInfo(InvokerName, Loc), 1313 InvokerFunctionTy, 1314 CallOperator->getTypeSourceInfo(), 1315 SC_Static, /*IsInline=*/true, 1316 /*IsConstexpr=*/false, 1317 CallOperator->getBody()->getLocEnd()); 1318 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) 1319 InvokerParams[I]->setOwningFunction(Invoke); 1320 Invoke->setParams(InvokerParams); 1321 Invoke->setAccess(AS_private); 1322 Invoke->setImplicit(true); 1323 if (Class->isGenericLambda()) { 1324 FunctionTemplateDecl *TemplateCallOperator = 1325 CallOperator->getDescribedFunctionTemplate(); 1326 FunctionTemplateDecl *StaticInvokerTemplate = FunctionTemplateDecl::Create( 1327 S.Context, Class, Loc, InvokerName, 1328 TemplateCallOperator->getTemplateParameters(), 1329 Invoke); 1330 StaticInvokerTemplate->setAccess(AS_private); 1331 StaticInvokerTemplate->setImplicit(true); 1332 Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate); 1333 Class->addDecl(StaticInvokerTemplate); 1334 } else 1335 Class->addDecl(Invoke); 1336 } 1337 1338 /// \brief Add a lambda's conversion to block pointer. 1339 static void addBlockPointerConversion(Sema &S, 1340 SourceRange IntroducerRange, 1341 CXXRecordDecl *Class, 1342 CXXMethodDecl *CallOperator) { 1343 const FunctionProtoType *Proto = 1344 CallOperator->getType()->getAs<FunctionProtoType>(); 1345 1346 // The function type inside the block pointer type is the same as the call 1347 // operator with some tweaks. The calling convention is the default free 1348 // function convention, and the type qualifications are lost. 1349 FunctionProtoType::ExtProtoInfo BlockEPI = Proto->getExtProtoInfo(); 1350 BlockEPI.ExtInfo = 1351 BlockEPI.ExtInfo.withCallingConv(S.Context.getDefaultCallingConvention( 1352 Proto->isVariadic(), /*IsCXXMethod=*/false)); 1353 BlockEPI.TypeQuals = 0; 1354 QualType FunctionTy = S.Context.getFunctionType( 1355 Proto->getReturnType(), Proto->getParamTypes(), BlockEPI); 1356 QualType BlockPtrTy = S.Context.getBlockPointerType(FunctionTy); 1357 1358 FunctionProtoType::ExtProtoInfo ConversionEPI( 1359 S.Context.getDefaultCallingConvention( 1360 /*IsVariadic=*/false, /*IsCXXMethod=*/true)); 1361 ConversionEPI.TypeQuals = Qualifiers::Const; 1362 QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, None, ConversionEPI); 1363 1364 SourceLocation Loc = IntroducerRange.getBegin(); 1365 DeclarationName Name 1366 = S.Context.DeclarationNames.getCXXConversionFunctionName( 1367 S.Context.getCanonicalType(BlockPtrTy)); 1368 DeclarationNameLoc NameLoc; 1369 NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc); 1370 CXXConversionDecl *Conversion 1371 = CXXConversionDecl::Create(S.Context, Class, Loc, 1372 DeclarationNameInfo(Name, Loc, NameLoc), 1373 ConvTy, 1374 S.Context.getTrivialTypeSourceInfo(ConvTy, Loc), 1375 /*isInline=*/true, /*isExplicit=*/false, 1376 /*isConstexpr=*/false, 1377 CallOperator->getBody()->getLocEnd()); 1378 Conversion->setAccess(AS_public); 1379 Conversion->setImplicit(true); 1380 Class->addDecl(Conversion); 1381 } 1382 1383 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, 1384 Scope *CurScope, 1385 bool IsInstantiation) { 1386 // Collect information from the lambda scope. 1387 SmallVector<LambdaCapture, 4> Captures; 1388 SmallVector<Expr *, 4> CaptureInits; 1389 LambdaCaptureDefault CaptureDefault; 1390 SourceLocation CaptureDefaultLoc; 1391 CXXRecordDecl *Class; 1392 CXXMethodDecl *CallOperator; 1393 SourceRange IntroducerRange; 1394 bool ExplicitParams; 1395 bool ExplicitResultType; 1396 bool LambdaExprNeedsCleanups; 1397 bool ContainsUnexpandedParameterPack; 1398 SmallVector<VarDecl *, 4> ArrayIndexVars; 1399 SmallVector<unsigned, 4> ArrayIndexStarts; 1400 { 1401 LambdaScopeInfo *LSI = getCurLambda(); 1402 CallOperator = LSI->CallOperator; 1403 Class = LSI->Lambda; 1404 IntroducerRange = LSI->IntroducerRange; 1405 ExplicitParams = LSI->ExplicitParams; 1406 ExplicitResultType = !LSI->HasImplicitReturnType; 1407 LambdaExprNeedsCleanups = LSI->ExprNeedsCleanups; 1408 ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack; 1409 ArrayIndexVars.swap(LSI->ArrayIndexVars); 1410 ArrayIndexStarts.swap(LSI->ArrayIndexStarts); 1411 1412 // Translate captures. 1413 for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) { 1414 LambdaScopeInfo::Capture From = LSI->Captures[I]; 1415 assert(!From.isBlockCapture() && "Cannot capture __block variables"); 1416 bool IsImplicit = I >= LSI->NumExplicitCaptures; 1417 1418 // Handle 'this' capture. 1419 if (From.isThisCapture()) { 1420 Captures.push_back( 1421 LambdaCapture(From.getLocation(), IsImplicit, LCK_This)); 1422 CaptureInits.push_back(new (Context) CXXThisExpr(From.getLocation(), 1423 getCurrentThisType(), 1424 /*isImplicit=*/true)); 1425 continue; 1426 } 1427 if (From.isVLATypeCapture()) { 1428 Captures.push_back( 1429 LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType)); 1430 CaptureInits.push_back(nullptr); 1431 continue; 1432 } 1433 1434 VarDecl *Var = From.getVariable(); 1435 LambdaCaptureKind Kind = From.isCopyCapture()? LCK_ByCopy : LCK_ByRef; 1436 Captures.push_back(LambdaCapture(From.getLocation(), IsImplicit, Kind, 1437 Var, From.getEllipsisLoc())); 1438 CaptureInits.push_back(From.getInitExpr()); 1439 } 1440 1441 switch (LSI->ImpCaptureStyle) { 1442 case CapturingScopeInfo::ImpCap_None: 1443 CaptureDefault = LCD_None; 1444 break; 1445 1446 case CapturingScopeInfo::ImpCap_LambdaByval: 1447 CaptureDefault = LCD_ByCopy; 1448 break; 1449 1450 case CapturingScopeInfo::ImpCap_CapturedRegion: 1451 case CapturingScopeInfo::ImpCap_LambdaByref: 1452 CaptureDefault = LCD_ByRef; 1453 break; 1454 1455 case CapturingScopeInfo::ImpCap_Block: 1456 llvm_unreachable("block capture in lambda"); 1457 break; 1458 } 1459 CaptureDefaultLoc = LSI->CaptureDefaultLoc; 1460 1461 // C++11 [expr.prim.lambda]p4: 1462 // If a lambda-expression does not include a 1463 // trailing-return-type, it is as if the trailing-return-type 1464 // denotes the following type: 1465 // 1466 // Skip for C++1y return type deduction semantics which uses 1467 // different machinery. 1468 // FIXME: Refactor and Merge the return type deduction machinery. 1469 // FIXME: Assumes current resolution to core issue 975. 1470 if (LSI->HasImplicitReturnType && !getLangOpts().CPlusPlus14) { 1471 deduceClosureReturnType(*LSI); 1472 1473 // - if there are no return statements in the 1474 // compound-statement, or all return statements return 1475 // either an expression of type void or no expression or 1476 // braced-init-list, the type void; 1477 if (LSI->ReturnType.isNull()) { 1478 LSI->ReturnType = Context.VoidTy; 1479 } 1480 1481 // Create a function type with the inferred return type. 1482 const FunctionProtoType *Proto 1483 = CallOperator->getType()->getAs<FunctionProtoType>(); 1484 QualType FunctionTy = Context.getFunctionType( 1485 LSI->ReturnType, Proto->getParamTypes(), Proto->getExtProtoInfo()); 1486 CallOperator->setType(FunctionTy); 1487 } 1488 // C++ [expr.prim.lambda]p7: 1489 // The lambda-expression's compound-statement yields the 1490 // function-body (8.4) of the function call operator [...]. 1491 ActOnFinishFunctionBody(CallOperator, Body, IsInstantiation); 1492 CallOperator->setLexicalDeclContext(Class); 1493 Decl *TemplateOrNonTemplateCallOperatorDecl = 1494 CallOperator->getDescribedFunctionTemplate() 1495 ? CallOperator->getDescribedFunctionTemplate() 1496 : cast<Decl>(CallOperator); 1497 1498 TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class); 1499 Class->addDecl(TemplateOrNonTemplateCallOperatorDecl); 1500 1501 PopExpressionEvaluationContext(); 1502 1503 // C++11 [expr.prim.lambda]p6: 1504 // The closure type for a lambda-expression with no lambda-capture 1505 // has a public non-virtual non-explicit const conversion function 1506 // to pointer to function having the same parameter and return 1507 // types as the closure type's function call operator. 1508 if (Captures.empty() && CaptureDefault == LCD_None) 1509 addFunctionPointerConversion(*this, IntroducerRange, Class, 1510 CallOperator); 1511 1512 // Objective-C++: 1513 // The closure type for a lambda-expression has a public non-virtual 1514 // non-explicit const conversion function to a block pointer having the 1515 // same parameter and return types as the closure type's function call 1516 // operator. 1517 // FIXME: Fix generic lambda to block conversions. 1518 if (getLangOpts().Blocks && getLangOpts().ObjC1 && 1519 !Class->isGenericLambda()) 1520 addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator); 1521 1522 // Finalize the lambda class. 1523 SmallVector<Decl*, 4> Fields(Class->fields()); 1524 ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(), 1525 SourceLocation(), nullptr); 1526 CheckCompletedCXXClass(Class); 1527 } 1528 1529 if (LambdaExprNeedsCleanups) 1530 ExprNeedsCleanups = true; 1531 1532 LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange, 1533 CaptureDefault, CaptureDefaultLoc, 1534 Captures, 1535 ExplicitParams, ExplicitResultType, 1536 CaptureInits, ArrayIndexVars, 1537 ArrayIndexStarts, Body->getLocEnd(), 1538 ContainsUnexpandedParameterPack); 1539 1540 if (!CurContext->isDependentContext()) { 1541 switch (ExprEvalContexts.back().Context) { 1542 // C++11 [expr.prim.lambda]p2: 1543 // A lambda-expression shall not appear in an unevaluated operand 1544 // (Clause 5). 1545 case Unevaluated: 1546 case UnevaluatedAbstract: 1547 // C++1y [expr.const]p2: 1548 // A conditional-expression e is a core constant expression unless the 1549 // evaluation of e, following the rules of the abstract machine, would 1550 // evaluate [...] a lambda-expression. 1551 // 1552 // This is technically incorrect, there are some constant evaluated contexts 1553 // where this should be allowed. We should probably fix this when DR1607 is 1554 // ratified, it lays out the exact set of conditions where we shouldn't 1555 // allow a lambda-expression. 1556 case ConstantEvaluated: 1557 // We don't actually diagnose this case immediately, because we 1558 // could be within a context where we might find out later that 1559 // the expression is potentially evaluated (e.g., for typeid). 1560 ExprEvalContexts.back().Lambdas.push_back(Lambda); 1561 break; 1562 1563 case PotentiallyEvaluated: 1564 case PotentiallyEvaluatedIfUsed: 1565 break; 1566 } 1567 } 1568 1569 return MaybeBindToTemporary(Lambda); 1570 } 1571 1572 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation, 1573 SourceLocation ConvLocation, 1574 CXXConversionDecl *Conv, 1575 Expr *Src) { 1576 // Make sure that the lambda call operator is marked used. 1577 CXXRecordDecl *Lambda = Conv->getParent(); 1578 CXXMethodDecl *CallOperator 1579 = cast<CXXMethodDecl>( 1580 Lambda->lookup( 1581 Context.DeclarationNames.getCXXOperatorName(OO_Call)).front()); 1582 CallOperator->setReferenced(); 1583 CallOperator->markUsed(Context); 1584 1585 ExprResult Init = PerformCopyInitialization( 1586 InitializedEntity::InitializeBlock(ConvLocation, 1587 Src->getType(), 1588 /*NRVO=*/false), 1589 CurrentLocation, Src); 1590 if (!Init.isInvalid()) 1591 Init = ActOnFinishFullExpr(Init.get()); 1592 1593 if (Init.isInvalid()) 1594 return ExprError(); 1595 1596 // Create the new block to be returned. 1597 BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation); 1598 1599 // Set the type information. 1600 Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo()); 1601 Block->setIsVariadic(CallOperator->isVariadic()); 1602 Block->setBlockMissingReturnType(false); 1603 1604 // Add parameters. 1605 SmallVector<ParmVarDecl *, 4> BlockParams; 1606 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 1607 ParmVarDecl *From = CallOperator->getParamDecl(I); 1608 BlockParams.push_back(ParmVarDecl::Create(Context, Block, 1609 From->getLocStart(), 1610 From->getLocation(), 1611 From->getIdentifier(), 1612 From->getType(), 1613 From->getTypeSourceInfo(), 1614 From->getStorageClass(), 1615 /*DefaultArg=*/nullptr)); 1616 } 1617 Block->setParams(BlockParams); 1618 1619 Block->setIsConversionFromLambda(true); 1620 1621 // Add capture. The capture uses a fake variable, which doesn't correspond 1622 // to any actual memory location. However, the initializer copy-initializes 1623 // the lambda object. 1624 TypeSourceInfo *CapVarTSI = 1625 Context.getTrivialTypeSourceInfo(Src->getType()); 1626 VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation, 1627 ConvLocation, nullptr, 1628 Src->getType(), CapVarTSI, 1629 SC_None); 1630 BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false, 1631 /*Nested=*/false, /*Copy=*/Init.get()); 1632 Block->setCaptures(Context, &Capture, &Capture + 1, 1633 /*CapturesCXXThis=*/false); 1634 1635 // Add a fake function body to the block. IR generation is responsible 1636 // for filling in the actual body, which cannot be expressed as an AST. 1637 Block->setBody(new (Context) CompoundStmt(ConvLocation)); 1638 1639 // Create the block literal expression. 1640 Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType()); 1641 ExprCleanupObjects.push_back(Block); 1642 ExprNeedsCleanups = true; 1643 1644 return BuildBlock; 1645 } 1646