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 "clang/Sema/Initialization.h" 15 #include "clang/Sema/Lookup.h" 16 #include "clang/Sema/Scope.h" 17 #include "clang/Sema/ScopeInfo.h" 18 #include "clang/Sema/SemaInternal.h" 19 #include "clang/Lex/Preprocessor.h" 20 #include "clang/AST/ExprCXX.h" 21 using namespace clang; 22 using namespace sema; 23 24 CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange, 25 bool KnownDependent) { 26 DeclContext *DC = CurContext; 27 while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext())) 28 DC = DC->getParent(); 29 30 // Start constructing the lambda class. 31 CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, 32 IntroducerRange.getBegin(), 33 KnownDependent); 34 DC->addDecl(Class); 35 36 return Class; 37 } 38 39 /// \brief Determine whether the given context is or is enclosed in an inline 40 /// function. 41 static bool isInInlineFunction(const DeclContext *DC) { 42 while (!DC->isFileContext()) { 43 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 44 if (FD->isInlined()) 45 return true; 46 47 DC = DC->getLexicalParent(); 48 } 49 50 return false; 51 } 52 53 CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class, 54 SourceRange IntroducerRange, 55 TypeSourceInfo *MethodType, 56 SourceLocation EndLoc, 57 llvm::ArrayRef<ParmVarDecl *> Params, 58 llvm::Optional<unsigned> ManglingNumber, 59 Decl *ContextDecl) { 60 // C++11 [expr.prim.lambda]p5: 61 // The closure type for a lambda-expression has a public inline function 62 // call operator (13.5.4) whose parameters and return type are described by 63 // the lambda-expression's parameter-declaration-clause and 64 // trailing-return-type respectively. 65 DeclarationName MethodName 66 = Context.DeclarationNames.getCXXOperatorName(OO_Call); 67 DeclarationNameLoc MethodNameLoc; 68 MethodNameLoc.CXXOperatorName.BeginOpNameLoc 69 = IntroducerRange.getBegin().getRawEncoding(); 70 MethodNameLoc.CXXOperatorName.EndOpNameLoc 71 = IntroducerRange.getEnd().getRawEncoding(); 72 CXXMethodDecl *Method 73 = CXXMethodDecl::Create(Context, Class, EndLoc, 74 DeclarationNameInfo(MethodName, 75 IntroducerRange.getBegin(), 76 MethodNameLoc), 77 MethodType->getType(), MethodType, 78 /*isStatic=*/false, 79 SC_None, 80 /*isInline=*/true, 81 /*isConstExpr=*/false, 82 EndLoc); 83 Method->setAccess(AS_public); 84 85 // Temporarily set the lexical declaration context to the current 86 // context, so that the Scope stack matches the lexical nesting. 87 Method->setLexicalDeclContext(CurContext); 88 89 // Add parameters. 90 if (!Params.empty()) { 91 Method->setParams(Params); 92 CheckParmsForFunctionDef(const_cast<ParmVarDecl **>(Params.begin()), 93 const_cast<ParmVarDecl **>(Params.end()), 94 /*CheckParameterNames=*/false); 95 96 for (CXXMethodDecl::param_iterator P = Method->param_begin(), 97 PEnd = Method->param_end(); 98 P != PEnd; ++P) 99 (*P)->setOwningFunction(Method); 100 } 101 102 // If we don't already have a mangling number for this lambda expression, 103 // allocate one now. 104 if (!ManglingNumber) { 105 ContextDecl = ExprEvalContexts.back().LambdaContextDecl; 106 107 enum ContextKind { 108 Normal, 109 DefaultArgument, 110 DataMember, 111 StaticDataMember 112 } Kind = Normal; 113 114 // Default arguments of member function parameters that appear in a class 115 // definition, as well as the initializers of data members, receive special 116 // treatment. Identify them. 117 if (ContextDecl) { 118 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ContextDecl)) { 119 if (const DeclContext *LexicalDC 120 = Param->getDeclContext()->getLexicalParent()) 121 if (LexicalDC->isRecord()) 122 Kind = DefaultArgument; 123 } else if (VarDecl *Var = dyn_cast<VarDecl>(ContextDecl)) { 124 if (Var->getDeclContext()->isRecord()) 125 Kind = StaticDataMember; 126 } else if (isa<FieldDecl>(ContextDecl)) { 127 Kind = DataMember; 128 } 129 } 130 131 switch (Kind) { 132 case Normal: 133 if (CurContext->isDependentContext() || isInInlineFunction(CurContext)) 134 ManglingNumber = Context.getLambdaManglingNumber(Method); 135 else 136 ManglingNumber = 0; 137 138 // There is no special context for this lambda. 139 ContextDecl = 0; 140 break; 141 142 case StaticDataMember: 143 if (!CurContext->isDependentContext()) { 144 ManglingNumber = 0; 145 ContextDecl = 0; 146 break; 147 } 148 // Fall through to assign a mangling number. 149 150 case DataMember: 151 case DefaultArgument: 152 ManglingNumber = ExprEvalContexts.back().getLambdaMangleContext() 153 .getManglingNumber(Method); 154 break; 155 } 156 } 157 158 Class->setLambdaMangling(*ManglingNumber, ContextDecl); 159 return Method; 160 } 161 162 LambdaScopeInfo *Sema::enterLambdaScope(CXXMethodDecl *CallOperator, 163 SourceRange IntroducerRange, 164 LambdaCaptureDefault CaptureDefault, 165 bool ExplicitParams, 166 bool ExplicitResultType, 167 bool Mutable) { 168 PushLambdaScope(CallOperator->getParent(), CallOperator); 169 LambdaScopeInfo *LSI = getCurLambda(); 170 if (CaptureDefault == LCD_ByCopy) 171 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval; 172 else if (CaptureDefault == LCD_ByRef) 173 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref; 174 LSI->IntroducerRange = IntroducerRange; 175 LSI->ExplicitParams = ExplicitParams; 176 LSI->Mutable = Mutable; 177 178 if (ExplicitResultType) { 179 LSI->ReturnType = CallOperator->getResultType(); 180 181 if (!LSI->ReturnType->isDependentType() && 182 !LSI->ReturnType->isVoidType()) { 183 if (RequireCompleteType(CallOperator->getLocStart(), LSI->ReturnType, 184 diag::err_lambda_incomplete_result)) { 185 // Do nothing. 186 } else if (LSI->ReturnType->isObjCObjectOrInterfaceType()) { 187 Diag(CallOperator->getLocStart(), diag::err_lambda_objc_object_result) 188 << LSI->ReturnType; 189 } 190 } 191 } else { 192 LSI->HasImplicitReturnType = true; 193 } 194 195 return LSI; 196 } 197 198 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) { 199 LSI->finishedExplicitCaptures(); 200 } 201 202 void Sema::addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope) { 203 // Introduce our parameters into the function scope 204 for (unsigned p = 0, NumParams = CallOperator->getNumParams(); 205 p < NumParams; ++p) { 206 ParmVarDecl *Param = CallOperator->getParamDecl(p); 207 208 // If this has an identifier, add it to the scope stack. 209 if (CurScope && Param->getIdentifier()) { 210 CheckShadow(CurScope, Param); 211 212 PushOnScopeChains(Param, CurScope); 213 } 214 } 215 } 216 217 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, 218 Declarator &ParamInfo, 219 Scope *CurScope) { 220 // Determine if we're within a context where we know that the lambda will 221 // be dependent, because there are template parameters in scope. 222 bool KnownDependent = false; 223 if (Scope *TmplScope = CurScope->getTemplateParamParent()) 224 if (!TmplScope->decl_empty()) 225 KnownDependent = true; 226 227 CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, KnownDependent); 228 229 // Determine the signature of the call operator. 230 TypeSourceInfo *MethodTyInfo; 231 bool ExplicitParams = true; 232 bool ExplicitResultType = true; 233 SourceLocation EndLoc; 234 llvm::ArrayRef<ParmVarDecl *> Params; 235 if (ParamInfo.getNumTypeObjects() == 0) { 236 // C++11 [expr.prim.lambda]p4: 237 // If a lambda-expression does not include a lambda-declarator, it is as 238 // if the lambda-declarator were (). 239 FunctionProtoType::ExtProtoInfo EPI; 240 EPI.HasTrailingReturn = true; 241 EPI.TypeQuals |= DeclSpec::TQ_const; 242 QualType MethodTy = Context.getFunctionType(Context.DependentTy, 243 /*Args=*/0, /*NumArgs=*/0, EPI); 244 MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy); 245 ExplicitParams = false; 246 ExplicitResultType = false; 247 EndLoc = Intro.Range.getEnd(); 248 } else { 249 assert(ParamInfo.isFunctionDeclarator() && 250 "lambda-declarator is a function"); 251 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo(); 252 253 // C++11 [expr.prim.lambda]p5: 254 // This function call operator is declared const (9.3.1) if and only if 255 // the lambda-expression's parameter-declaration-clause is not followed 256 // by mutable. It is neither virtual nor declared volatile. [...] 257 if (!FTI.hasMutableQualifier()) 258 FTI.TypeQuals |= DeclSpec::TQ_const; 259 260 MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope); 261 assert(MethodTyInfo && "no type from lambda-declarator"); 262 EndLoc = ParamInfo.getSourceRange().getEnd(); 263 264 ExplicitResultType 265 = MethodTyInfo->getType()->getAs<FunctionType>()->getResultType() 266 != Context.DependentTy; 267 268 TypeLoc TL = MethodTyInfo->getTypeLoc(); 269 FunctionProtoTypeLoc Proto = cast<FunctionProtoTypeLoc>(TL); 270 Params = llvm::ArrayRef<ParmVarDecl *>(Proto.getParmArray(), 271 Proto.getNumArgs()); 272 } 273 274 CXXMethodDecl *Method = startLambdaDefinition(Class, Intro.Range, 275 MethodTyInfo, EndLoc, Params); 276 277 if (ExplicitParams) 278 CheckCXXDefaultArguments(Method); 279 280 // Attributes on the lambda apply to the method. 281 ProcessDeclAttributes(CurScope, Method, ParamInfo); 282 283 // Introduce the function call operator as the current declaration context. 284 PushDeclContext(CurScope, Method); 285 286 // Introduce the lambda scope. 287 LambdaScopeInfo *LSI 288 = enterLambdaScope(Method, Intro.Range, Intro.Default, ExplicitParams, 289 ExplicitResultType, 290 (Method->getTypeQualifiers() & Qualifiers::Const) == 0); 291 292 // Handle explicit captures. 293 SourceLocation PrevCaptureLoc 294 = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc; 295 for (llvm::SmallVector<LambdaCapture, 4>::const_iterator 296 C = Intro.Captures.begin(), 297 E = Intro.Captures.end(); 298 C != E; 299 PrevCaptureLoc = C->Loc, ++C) { 300 if (C->Kind == LCK_This) { 301 // C++11 [expr.prim.lambda]p8: 302 // An identifier or this shall not appear more than once in a 303 // lambda-capture. 304 if (LSI->isCXXThisCaptured()) { 305 Diag(C->Loc, diag::err_capture_more_than_once) 306 << "'this'" 307 << SourceRange(LSI->getCXXThisCapture().getLocation()) 308 << FixItHint::CreateRemoval( 309 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 310 continue; 311 } 312 313 // C++11 [expr.prim.lambda]p8: 314 // If a lambda-capture includes a capture-default that is =, the 315 // lambda-capture shall not contain this [...]. 316 if (Intro.Default == LCD_ByCopy) { 317 Diag(C->Loc, diag::err_this_capture_with_copy_default) 318 << FixItHint::CreateRemoval( 319 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 320 continue; 321 } 322 323 // C++11 [expr.prim.lambda]p12: 324 // If this is captured by a local lambda expression, its nearest 325 // enclosing function shall be a non-static member function. 326 QualType ThisCaptureType = getCurrentThisType(); 327 if (ThisCaptureType.isNull()) { 328 Diag(C->Loc, diag::err_this_capture) << true; 329 continue; 330 } 331 332 CheckCXXThisCapture(C->Loc, /*Explicit=*/true); 333 continue; 334 } 335 336 assert(C->Id && "missing identifier for capture"); 337 338 // C++11 [expr.prim.lambda]p8: 339 // If a lambda-capture includes a capture-default that is &, the 340 // identifiers in the lambda-capture shall not be preceded by &. 341 // If a lambda-capture includes a capture-default that is =, [...] 342 // each identifier it contains shall be preceded by &. 343 if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) { 344 Diag(C->Loc, diag::err_reference_capture_with_reference_default) 345 << FixItHint::CreateRemoval( 346 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 347 continue; 348 } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) { 349 Diag(C->Loc, diag::err_copy_capture_with_copy_default) 350 << FixItHint::CreateRemoval( 351 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 352 continue; 353 } 354 355 DeclarationNameInfo Name(C->Id, C->Loc); 356 LookupResult R(*this, Name, LookupOrdinaryName); 357 LookupName(R, CurScope); 358 if (R.isAmbiguous()) 359 continue; 360 if (R.empty()) { 361 // FIXME: Disable corrections that would add qualification? 362 CXXScopeSpec ScopeSpec; 363 DeclFilterCCC<VarDecl> Validator; 364 if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R, Validator)) 365 continue; 366 } 367 368 // C++11 [expr.prim.lambda]p10: 369 // The identifiers in a capture-list are looked up using the usual rules 370 // for unqualified name lookup (3.4.1); each such lookup shall find a 371 // variable with automatic storage duration declared in the reaching 372 // scope of the local lambda expression. 373 // 374 // Note that the 'reaching scope' check happens in tryCaptureVariable(). 375 VarDecl *Var = R.getAsSingle<VarDecl>(); 376 if (!Var) { 377 Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id; 378 continue; 379 } 380 381 if (!Var->hasLocalStorage()) { 382 Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id; 383 Diag(Var->getLocation(), diag::note_previous_decl) << C->Id; 384 continue; 385 } 386 387 // C++11 [expr.prim.lambda]p8: 388 // An identifier or this shall not appear more than once in a 389 // lambda-capture. 390 if (LSI->isCaptured(Var)) { 391 Diag(C->Loc, diag::err_capture_more_than_once) 392 << C->Id 393 << SourceRange(LSI->getCapture(Var).getLocation()) 394 << FixItHint::CreateRemoval( 395 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 396 continue; 397 } 398 399 // C++11 [expr.prim.lambda]p23: 400 // A capture followed by an ellipsis is a pack expansion (14.5.3). 401 SourceLocation EllipsisLoc; 402 if (C->EllipsisLoc.isValid()) { 403 if (Var->isParameterPack()) { 404 EllipsisLoc = C->EllipsisLoc; 405 } else { 406 Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 407 << SourceRange(C->Loc); 408 409 // Just ignore the ellipsis. 410 } 411 } else if (Var->isParameterPack()) { 412 Diag(C->Loc, diag::err_lambda_unexpanded_pack); 413 continue; 414 } 415 416 TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef : 417 TryCapture_ExplicitByVal; 418 tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc); 419 } 420 finishLambdaExplicitCaptures(LSI); 421 422 // Add lambda parameters into scope. 423 addLambdaParameters(Method, CurScope); 424 425 // Enter a new evaluation context to insulate the lambda from any 426 // cleanups from the enclosing full-expression. 427 PushExpressionEvaluationContext(PotentiallyEvaluated); 428 } 429 430 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, 431 bool IsInstantiation) { 432 // Leave the expression-evaluation context. 433 DiscardCleanupsInEvaluationContext(); 434 PopExpressionEvaluationContext(); 435 436 // Leave the context of the lambda. 437 if (!IsInstantiation) 438 PopDeclContext(); 439 440 // Finalize the lambda. 441 LambdaScopeInfo *LSI = getCurLambda(); 442 CXXRecordDecl *Class = LSI->Lambda; 443 Class->setInvalidDecl(); 444 SmallVector<Decl*, 4> Fields(Class->field_begin(), Class->field_end()); 445 ActOnFields(0, Class->getLocation(), Class, Fields, 446 SourceLocation(), SourceLocation(), 0); 447 CheckCompletedCXXClass(Class); 448 449 PopFunctionScopeInfo(); 450 } 451 452 /// \brief Add a lambda's conversion to function pointer, as described in 453 /// C++11 [expr.prim.lambda]p6. 454 static void addFunctionPointerConversion(Sema &S, 455 SourceRange IntroducerRange, 456 CXXRecordDecl *Class, 457 CXXMethodDecl *CallOperator) { 458 // Add the conversion to function pointer. 459 const FunctionProtoType *Proto 460 = CallOperator->getType()->getAs<FunctionProtoType>(); 461 QualType FunctionPtrTy; 462 QualType FunctionTy; 463 { 464 FunctionProtoType::ExtProtoInfo ExtInfo = Proto->getExtProtoInfo(); 465 ExtInfo.TypeQuals = 0; 466 FunctionTy = S.Context.getFunctionType(Proto->getResultType(), 467 Proto->arg_type_begin(), 468 Proto->getNumArgs(), 469 ExtInfo); 470 FunctionPtrTy = S.Context.getPointerType(FunctionTy); 471 } 472 473 FunctionProtoType::ExtProtoInfo ExtInfo; 474 ExtInfo.TypeQuals = Qualifiers::Const; 475 QualType ConvTy = S.Context.getFunctionType(FunctionPtrTy, 0, 0, ExtInfo); 476 477 SourceLocation Loc = IntroducerRange.getBegin(); 478 DeclarationName Name 479 = S.Context.DeclarationNames.getCXXConversionFunctionName( 480 S.Context.getCanonicalType(FunctionPtrTy)); 481 DeclarationNameLoc NameLoc; 482 NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(FunctionPtrTy, 483 Loc); 484 CXXConversionDecl *Conversion 485 = CXXConversionDecl::Create(S.Context, Class, Loc, 486 DeclarationNameInfo(Name, Loc, NameLoc), 487 ConvTy, 488 S.Context.getTrivialTypeSourceInfo(ConvTy, 489 Loc), 490 /*isInline=*/false, /*isExplicit=*/false, 491 /*isConstexpr=*/false, 492 CallOperator->getBody()->getLocEnd()); 493 Conversion->setAccess(AS_public); 494 Conversion->setImplicit(true); 495 Class->addDecl(Conversion); 496 497 // Add a non-static member function "__invoke" that will be the result of 498 // the conversion. 499 Name = &S.Context.Idents.get("__invoke"); 500 CXXMethodDecl *Invoke 501 = CXXMethodDecl::Create(S.Context, Class, Loc, 502 DeclarationNameInfo(Name, Loc), FunctionTy, 503 CallOperator->getTypeSourceInfo(), 504 /*IsStatic=*/true, SC_Static, /*IsInline=*/true, 505 /*IsConstexpr=*/false, 506 CallOperator->getBody()->getLocEnd()); 507 SmallVector<ParmVarDecl *, 4> InvokeParams; 508 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 509 ParmVarDecl *From = CallOperator->getParamDecl(I); 510 InvokeParams.push_back(ParmVarDecl::Create(S.Context, Invoke, 511 From->getLocStart(), 512 From->getLocation(), 513 From->getIdentifier(), 514 From->getType(), 515 From->getTypeSourceInfo(), 516 From->getStorageClass(), 517 From->getStorageClassAsWritten(), 518 /*DefaultArg=*/0)); 519 } 520 Invoke->setParams(InvokeParams); 521 Invoke->setAccess(AS_private); 522 Invoke->setImplicit(true); 523 Class->addDecl(Invoke); 524 } 525 526 /// \brief Add a lambda's conversion to block pointer. 527 static void addBlockPointerConversion(Sema &S, 528 SourceRange IntroducerRange, 529 CXXRecordDecl *Class, 530 CXXMethodDecl *CallOperator) { 531 const FunctionProtoType *Proto 532 = CallOperator->getType()->getAs<FunctionProtoType>(); 533 QualType BlockPtrTy; 534 { 535 FunctionProtoType::ExtProtoInfo ExtInfo = Proto->getExtProtoInfo(); 536 ExtInfo.TypeQuals = 0; 537 QualType FunctionTy 538 = S.Context.getFunctionType(Proto->getResultType(), 539 Proto->arg_type_begin(), 540 Proto->getNumArgs(), 541 ExtInfo); 542 BlockPtrTy = S.Context.getBlockPointerType(FunctionTy); 543 } 544 545 FunctionProtoType::ExtProtoInfo ExtInfo; 546 ExtInfo.TypeQuals = Qualifiers::Const; 547 QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, 0, 0, ExtInfo); 548 549 SourceLocation Loc = IntroducerRange.getBegin(); 550 DeclarationName Name 551 = S.Context.DeclarationNames.getCXXConversionFunctionName( 552 S.Context.getCanonicalType(BlockPtrTy)); 553 DeclarationNameLoc NameLoc; 554 NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc); 555 CXXConversionDecl *Conversion 556 = CXXConversionDecl::Create(S.Context, Class, Loc, 557 DeclarationNameInfo(Name, Loc, NameLoc), 558 ConvTy, 559 S.Context.getTrivialTypeSourceInfo(ConvTy, Loc), 560 /*isInline=*/false, /*isExplicit=*/false, 561 /*isConstexpr=*/false, 562 CallOperator->getBody()->getLocEnd()); 563 Conversion->setAccess(AS_public); 564 Conversion->setImplicit(true); 565 Class->addDecl(Conversion); 566 } 567 568 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, 569 Scope *CurScope, 570 bool IsInstantiation) { 571 // Collect information from the lambda scope. 572 llvm::SmallVector<LambdaExpr::Capture, 4> Captures; 573 llvm::SmallVector<Expr *, 4> CaptureInits; 574 LambdaCaptureDefault CaptureDefault; 575 CXXRecordDecl *Class; 576 CXXMethodDecl *CallOperator; 577 SourceRange IntroducerRange; 578 bool ExplicitParams; 579 bool ExplicitResultType; 580 bool LambdaExprNeedsCleanups; 581 llvm::SmallVector<VarDecl *, 4> ArrayIndexVars; 582 llvm::SmallVector<unsigned, 4> ArrayIndexStarts; 583 { 584 LambdaScopeInfo *LSI = getCurLambda(); 585 CallOperator = LSI->CallOperator; 586 Class = LSI->Lambda; 587 IntroducerRange = LSI->IntroducerRange; 588 ExplicitParams = LSI->ExplicitParams; 589 ExplicitResultType = !LSI->HasImplicitReturnType; 590 LambdaExprNeedsCleanups = LSI->ExprNeedsCleanups; 591 ArrayIndexVars.swap(LSI->ArrayIndexVars); 592 ArrayIndexStarts.swap(LSI->ArrayIndexStarts); 593 594 // Translate captures. 595 for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) { 596 LambdaScopeInfo::Capture From = LSI->Captures[I]; 597 assert(!From.isBlockCapture() && "Cannot capture __block variables"); 598 bool IsImplicit = I >= LSI->NumExplicitCaptures; 599 600 // Handle 'this' capture. 601 if (From.isThisCapture()) { 602 Captures.push_back(LambdaExpr::Capture(From.getLocation(), 603 IsImplicit, 604 LCK_This)); 605 CaptureInits.push_back(new (Context) CXXThisExpr(From.getLocation(), 606 getCurrentThisType(), 607 /*isImplicit=*/true)); 608 continue; 609 } 610 611 VarDecl *Var = From.getVariable(); 612 LambdaCaptureKind Kind = From.isCopyCapture()? LCK_ByCopy : LCK_ByRef; 613 Captures.push_back(LambdaExpr::Capture(From.getLocation(), IsImplicit, 614 Kind, Var, From.getEllipsisLoc())); 615 CaptureInits.push_back(From.getCopyExpr()); 616 } 617 618 switch (LSI->ImpCaptureStyle) { 619 case CapturingScopeInfo::ImpCap_None: 620 CaptureDefault = LCD_None; 621 break; 622 623 case CapturingScopeInfo::ImpCap_LambdaByval: 624 CaptureDefault = LCD_ByCopy; 625 break; 626 627 case CapturingScopeInfo::ImpCap_LambdaByref: 628 CaptureDefault = LCD_ByRef; 629 break; 630 631 case CapturingScopeInfo::ImpCap_Block: 632 llvm_unreachable("block capture in lambda"); 633 break; 634 } 635 636 // C++11 [expr.prim.lambda]p4: 637 // If a lambda-expression does not include a 638 // trailing-return-type, it is as if the trailing-return-type 639 // denotes the following type: 640 // FIXME: Assumes current resolution to core issue 975. 641 if (LSI->HasImplicitReturnType) { 642 // - if there are no return statements in the 643 // compound-statement, or all return statements return 644 // either an expression of type void or no expression or 645 // braced-init-list, the type void; 646 if (LSI->ReturnType.isNull()) { 647 LSI->ReturnType = Context.VoidTy; 648 } else { 649 // C++11 [expr.prim.lambda]p4: 650 // - if the compound-statement is of the form 651 // 652 // { attribute-specifier-seq[opt] return expression ; } 653 // 654 // the type of the returned expression after 655 // lvalue-to-rvalue conversion (4.1), array-to-pointer 656 // conver- sion (4.2), and function-to-pointer conversion 657 // (4.3); 658 // 659 // Since we're accepting the resolution to a post-C++11 core 660 // issue with a non-trivial extension, provide a warning (by 661 // default). 662 CompoundStmt *CompoundBody = cast<CompoundStmt>(Body); 663 if (!(CompoundBody->size() == 1 && 664 isa<ReturnStmt>(*CompoundBody->body_begin())) && 665 !Context.hasSameType(LSI->ReturnType, Context.VoidTy)) 666 Diag(IntroducerRange.getBegin(), 667 diag::ext_lambda_implies_void_return); 668 } 669 670 // Create a function type with the inferred return type. 671 const FunctionProtoType *Proto 672 = CallOperator->getType()->getAs<FunctionProtoType>(); 673 QualType FunctionTy 674 = Context.getFunctionType(LSI->ReturnType, 675 Proto->arg_type_begin(), 676 Proto->getNumArgs(), 677 Proto->getExtProtoInfo()); 678 CallOperator->setType(FunctionTy); 679 } 680 681 // C++ [expr.prim.lambda]p7: 682 // The lambda-expression's compound-statement yields the 683 // function-body (8.4) of the function call operator [...]. 684 ActOnFinishFunctionBody(CallOperator, Body, IsInstantiation); 685 CallOperator->setLexicalDeclContext(Class); 686 Class->addDecl(CallOperator); 687 PopExpressionEvaluationContext(); 688 689 // C++11 [expr.prim.lambda]p6: 690 // The closure type for a lambda-expression with no lambda-capture 691 // has a public non-virtual non-explicit const conversion function 692 // to pointer to function having the same parameter and return 693 // types as the closure type's function call operator. 694 if (Captures.empty() && CaptureDefault == LCD_None) 695 addFunctionPointerConversion(*this, IntroducerRange, Class, 696 CallOperator); 697 698 // Objective-C++: 699 // The closure type for a lambda-expression has a public non-virtual 700 // non-explicit const conversion function to a block pointer having the 701 // same parameter and return types as the closure type's function call 702 // operator. 703 if (getLangOpts().Blocks && getLangOpts().ObjC1) 704 addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator); 705 706 // Finalize the lambda class. 707 SmallVector<Decl*, 4> Fields(Class->field_begin(), Class->field_end()); 708 ActOnFields(0, Class->getLocation(), Class, Fields, 709 SourceLocation(), SourceLocation(), 0); 710 CheckCompletedCXXClass(Class); 711 } 712 713 if (LambdaExprNeedsCleanups) 714 ExprNeedsCleanups = true; 715 716 LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange, 717 CaptureDefault, Captures, 718 ExplicitParams, ExplicitResultType, 719 CaptureInits, ArrayIndexVars, 720 ArrayIndexStarts, Body->getLocEnd()); 721 722 // C++11 [expr.prim.lambda]p2: 723 // A lambda-expression shall not appear in an unevaluated operand 724 // (Clause 5). 725 if (!CurContext->isDependentContext()) { 726 switch (ExprEvalContexts.back().Context) { 727 case Unevaluated: 728 // We don't actually diagnose this case immediately, because we 729 // could be within a context where we might find out later that 730 // the expression is potentially evaluated (e.g., for typeid). 731 ExprEvalContexts.back().Lambdas.push_back(Lambda); 732 break; 733 734 case ConstantEvaluated: 735 case PotentiallyEvaluated: 736 case PotentiallyEvaluatedIfUsed: 737 break; 738 } 739 } 740 741 return MaybeBindToTemporary(Lambda); 742 } 743 744 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation, 745 SourceLocation ConvLocation, 746 CXXConversionDecl *Conv, 747 Expr *Src) { 748 // Make sure that the lambda call operator is marked used. 749 CXXRecordDecl *Lambda = Conv->getParent(); 750 CXXMethodDecl *CallOperator 751 = cast<CXXMethodDecl>( 752 *Lambda->lookup( 753 Context.DeclarationNames.getCXXOperatorName(OO_Call)).first); 754 CallOperator->setReferenced(); 755 CallOperator->setUsed(); 756 757 ExprResult Init = PerformCopyInitialization( 758 InitializedEntity::InitializeBlock(ConvLocation, 759 Src->getType(), 760 /*NRVO=*/false), 761 CurrentLocation, Src); 762 if (!Init.isInvalid()) 763 Init = ActOnFinishFullExpr(Init.take()); 764 765 if (Init.isInvalid()) 766 return ExprError(); 767 768 // Create the new block to be returned. 769 BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation); 770 771 // Set the type information. 772 Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo()); 773 Block->setIsVariadic(CallOperator->isVariadic()); 774 Block->setBlockMissingReturnType(false); 775 776 // Add parameters. 777 SmallVector<ParmVarDecl *, 4> BlockParams; 778 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 779 ParmVarDecl *From = CallOperator->getParamDecl(I); 780 BlockParams.push_back(ParmVarDecl::Create(Context, Block, 781 From->getLocStart(), 782 From->getLocation(), 783 From->getIdentifier(), 784 From->getType(), 785 From->getTypeSourceInfo(), 786 From->getStorageClass(), 787 From->getStorageClassAsWritten(), 788 /*DefaultArg=*/0)); 789 } 790 Block->setParams(BlockParams); 791 792 Block->setIsConversionFromLambda(true); 793 794 // Add capture. The capture uses a fake variable, which doesn't correspond 795 // to any actual memory location. However, the initializer copy-initializes 796 // the lambda object. 797 TypeSourceInfo *CapVarTSI = 798 Context.getTrivialTypeSourceInfo(Src->getType()); 799 VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation, 800 ConvLocation, 0, 801 Src->getType(), CapVarTSI, 802 SC_None, SC_None); 803 BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false, 804 /*Nested=*/false, /*Copy=*/Init.take()); 805 Block->setCaptures(Context, &Capture, &Capture + 1, 806 /*CapturesCXXThis=*/false); 807 808 // Add a fake function body to the block. IR generation is responsible 809 // for filling in the actual body, which cannot be expressed as an AST. 810 Block->setBody(new (Context) CompoundStmt(Context, 0, 0, 811 ConvLocation, 812 ConvLocation)); 813 814 // Create the block literal expression. 815 Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType()); 816 ExprCleanupObjects.push_back(Block); 817 ExprNeedsCleanups = true; 818 819 return BuildBlock; 820 } 821
