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 // C++11 [expr.prim.lambda]p5: 59 // The closure type for a lambda-expression has a public inline function 60 // call operator (13.5.4) whose parameters and return type are described by 61 // the lambda-expression's parameter-declaration-clause and 62 // trailing-return-type respectively. 63 DeclarationName MethodName 64 = Context.DeclarationNames.getCXXOperatorName(OO_Call); 65 DeclarationNameLoc MethodNameLoc; 66 MethodNameLoc.CXXOperatorName.BeginOpNameLoc 67 = IntroducerRange.getBegin().getRawEncoding(); 68 MethodNameLoc.CXXOperatorName.EndOpNameLoc 69 = IntroducerRange.getEnd().getRawEncoding(); 70 CXXMethodDecl *Method 71 = CXXMethodDecl::Create(Context, Class, EndLoc, 72 DeclarationNameInfo(MethodName, 73 IntroducerRange.getBegin(), 74 MethodNameLoc), 75 MethodType->getType(), MethodType, 76 /*isStatic=*/false, 77 SC_None, 78 /*isInline=*/true, 79 /*isConstExpr=*/false, 80 EndLoc); 81 Method->setAccess(AS_public); 82 83 // Temporarily set the lexical declaration context to the current 84 // context, so that the Scope stack matches the lexical nesting. 85 Method->setLexicalDeclContext(CurContext); 86 87 // Add parameters. 88 if (!Params.empty()) { 89 Method->setParams(Params); 90 CheckParmsForFunctionDef(const_cast<ParmVarDecl **>(Params.begin()), 91 const_cast<ParmVarDecl **>(Params.end()), 92 /*CheckParameterNames=*/false); 93 94 for (CXXMethodDecl::param_iterator P = Method->param_begin(), 95 PEnd = Method->param_end(); 96 P != PEnd; ++P) 97 (*P)->setOwningFunction(Method); 98 } 99 100 // Allocate a mangling number for this lambda expression, if the ABI 101 // requires one. 102 Decl *ContextDecl = ExprEvalContexts.back().LambdaContextDecl; 103 104 enum ContextKind { 105 Normal, 106 DefaultArgument, 107 DataMember, 108 StaticDataMember 109 } Kind = Normal; 110 111 // Default arguments of member function parameters that appear in a class 112 // definition, as well as the initializers of data members, receive special 113 // treatment. Identify them. 114 if (ContextDecl) { 115 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ContextDecl)) { 116 if (const DeclContext *LexicalDC 117 = Param->getDeclContext()->getLexicalParent()) 118 if (LexicalDC->isRecord()) 119 Kind = DefaultArgument; 120 } else if (VarDecl *Var = dyn_cast<VarDecl>(ContextDecl)) { 121 if (Var->getDeclContext()->isRecord()) 122 Kind = StaticDataMember; 123 } else if (isa<FieldDecl>(ContextDecl)) { 124 Kind = DataMember; 125 } 126 } 127 128 // Itanium ABI [5.1.7]: 129 // In the following contexts [...] the one-definition rule requires closure 130 // types in different translation units to "correspond": 131 bool IsInNonspecializedTemplate = 132 !ActiveTemplateInstantiations.empty() || CurContext->isDependentContext(); 133 unsigned ManglingNumber; 134 switch (Kind) { 135 case Normal: 136 // -- the bodies of non-exported nonspecialized template functions 137 // -- the bodies of inline functions 138 if ((IsInNonspecializedTemplate && 139 !(ContextDecl && isa<ParmVarDecl>(ContextDecl))) || 140 isInInlineFunction(CurContext)) 141 ManglingNumber = Context.getLambdaManglingNumber(Method); 142 else 143 ManglingNumber = 0; 144 145 // There is no special context for this lambda. 146 ContextDecl = 0; 147 break; 148 149 case StaticDataMember: 150 // -- the initializers of nonspecialized static members of template classes 151 if (!IsInNonspecializedTemplate) { 152 ManglingNumber = 0; 153 ContextDecl = 0; 154 break; 155 } 156 // Fall through to assign a mangling number. 157 158 case DataMember: 159 // -- the in-class initializers of class members 160 case DefaultArgument: 161 // -- default arguments appearing in class definitions 162 ManglingNumber = ExprEvalContexts.back().getLambdaMangleContext() 163 .getManglingNumber(Method); 164 break; 165 } 166 167 Class->setLambdaMangling(ManglingNumber, ContextDecl); 168 169 return Method; 170 } 171 172 LambdaScopeInfo *Sema::enterLambdaScope(CXXMethodDecl *CallOperator, 173 SourceRange IntroducerRange, 174 LambdaCaptureDefault CaptureDefault, 175 bool ExplicitParams, 176 bool ExplicitResultType, 177 bool Mutable) { 178 PushLambdaScope(CallOperator->getParent(), CallOperator); 179 LambdaScopeInfo *LSI = getCurLambda(); 180 if (CaptureDefault == LCD_ByCopy) 181 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval; 182 else if (CaptureDefault == LCD_ByRef) 183 LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref; 184 LSI->IntroducerRange = IntroducerRange; 185 LSI->ExplicitParams = ExplicitParams; 186 LSI->Mutable = Mutable; 187 188 if (ExplicitResultType) { 189 LSI->ReturnType = CallOperator->getResultType(); 190 191 if (!LSI->ReturnType->isDependentType() && 192 !LSI->ReturnType->isVoidType()) { 193 if (RequireCompleteType(CallOperator->getLocStart(), LSI->ReturnType, 194 diag::err_lambda_incomplete_result)) { 195 // Do nothing. 196 } else if (LSI->ReturnType->isObjCObjectOrInterfaceType()) { 197 Diag(CallOperator->getLocStart(), diag::err_lambda_objc_object_result) 198 << LSI->ReturnType; 199 } 200 } 201 } else { 202 LSI->HasImplicitReturnType = true; 203 } 204 205 return LSI; 206 } 207 208 void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) { 209 LSI->finishedExplicitCaptures(); 210 } 211 212 void Sema::addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope) { 213 // Introduce our parameters into the function scope 214 for (unsigned p = 0, NumParams = CallOperator->getNumParams(); 215 p < NumParams; ++p) { 216 ParmVarDecl *Param = CallOperator->getParamDecl(p); 217 218 // If this has an identifier, add it to the scope stack. 219 if (CurScope && Param->getIdentifier()) { 220 CheckShadow(CurScope, Param); 221 222 PushOnScopeChains(Param, CurScope); 223 } 224 } 225 } 226 227 static bool checkReturnValueType(const ASTContext &Ctx, const Expr *E, 228 QualType &DeducedType, 229 QualType &AlternateType) { 230 // Handle ReturnStmts with no expressions. 231 if (!E) { 232 if (AlternateType.isNull()) 233 AlternateType = Ctx.VoidTy; 234 235 return Ctx.hasSameType(DeducedType, Ctx.VoidTy); 236 } 237 238 QualType StrictType = E->getType(); 239 QualType LooseType = StrictType; 240 241 // In C, enum constants have the type of their underlying integer type, 242 // not the enum. When inferring block return types, we should allow 243 // the enum type if an enum constant is used, unless the enum is 244 // anonymous (in which case there can be no variables of its type). 245 if (!Ctx.getLangOpts().CPlusPlus) { 246 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()); 247 if (DRE) { 248 const Decl *D = DRE->getDecl(); 249 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) { 250 const EnumDecl *Enum = cast<EnumDecl>(ECD->getDeclContext()); 251 if (Enum->getDeclName() || Enum->getTypedefNameForAnonDecl()) 252 LooseType = Ctx.getTypeDeclType(Enum); 253 } 254 } 255 } 256 257 // Special case for the first return statement we find. 258 // The return type has already been tentatively set, but we might still 259 // have an alternate type we should prefer. 260 if (AlternateType.isNull()) 261 AlternateType = LooseType; 262 263 if (Ctx.hasSameType(DeducedType, StrictType)) { 264 // FIXME: The loose type is different when there are constants from two 265 // different enums. We could consider warning here. 266 if (AlternateType != Ctx.DependentTy) 267 if (!Ctx.hasSameType(AlternateType, LooseType)) 268 AlternateType = Ctx.VoidTy; 269 return true; 270 } 271 272 if (Ctx.hasSameType(DeducedType, LooseType)) { 273 // Use DependentTy to signal that we're using an alternate type and may 274 // need to add casts somewhere. 275 AlternateType = Ctx.DependentTy; 276 return true; 277 } 278 279 if (Ctx.hasSameType(AlternateType, StrictType) || 280 Ctx.hasSameType(AlternateType, LooseType)) { 281 DeducedType = AlternateType; 282 // Use DependentTy to signal that we're using an alternate type and may 283 // need to add casts somewhere. 284 AlternateType = Ctx.DependentTy; 285 return true; 286 } 287 288 return false; 289 } 290 291 void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) { 292 assert(CSI.HasImplicitReturnType); 293 294 // First case: no return statements, implicit void return type. 295 ASTContext &Ctx = getASTContext(); 296 if (CSI.Returns.empty()) { 297 // It's possible there were simply no /valid/ return statements. 298 // In this case, the first one we found may have at least given us a type. 299 if (CSI.ReturnType.isNull()) 300 CSI.ReturnType = Ctx.VoidTy; 301 return; 302 } 303 304 // Second case: at least one return statement has dependent type. 305 // Delay type checking until instantiation. 306 assert(!CSI.ReturnType.isNull() && "We should have a tentative return type."); 307 if (CSI.ReturnType->isDependentType()) 308 return; 309 310 // Third case: only one return statement. Don't bother doing extra work! 311 SmallVectorImpl<ReturnStmt*>::iterator I = CSI.Returns.begin(), 312 E = CSI.Returns.end(); 313 if (I+1 == E) 314 return; 315 316 // General case: many return statements. 317 // Check that they all have compatible return types. 318 // For now, that means "identical", with an exception for enum constants. 319 // (In C, enum constants have the type of their underlying integer type, 320 // not the type of the enum. C++ uses the type of the enum.) 321 QualType AlternateType; 322 323 // We require the return types to strictly match here. 324 for (; I != E; ++I) { 325 const ReturnStmt *RS = *I; 326 const Expr *RetE = RS->getRetValue(); 327 if (!checkReturnValueType(Ctx, RetE, CSI.ReturnType, AlternateType)) { 328 // FIXME: This is a poor diagnostic for ReturnStmts without expressions. 329 Diag(RS->getLocStart(), 330 diag::err_typecheck_missing_return_type_incompatible) 331 << (RetE ? RetE->getType() : Ctx.VoidTy) << CSI.ReturnType 332 << isa<LambdaScopeInfo>(CSI); 333 // Don't bother fixing up the return statements in the block if some of 334 // them are unfixable anyway. 335 AlternateType = Ctx.VoidTy; 336 // Continue iterating so that we keep emitting diagnostics. 337 } 338 } 339 340 // If our return statements turned out to be compatible, but we needed to 341 // pick a different return type, go through and fix the ones that need it. 342 if (AlternateType == Ctx.DependentTy) { 343 for (SmallVectorImpl<ReturnStmt*>::iterator I = CSI.Returns.begin(), 344 E = CSI.Returns.end(); 345 I != E; ++I) { 346 ReturnStmt *RS = *I; 347 Expr *RetE = RS->getRetValue(); 348 if (RetE->getType() == CSI.ReturnType) 349 continue; 350 351 // Right now we only support integral fixup casts. 352 assert(CSI.ReturnType->isIntegralOrUnscopedEnumerationType()); 353 assert(RetE->getType()->isIntegralOrUnscopedEnumerationType()); 354 ExprResult Casted = ImpCastExprToType(RetE, CSI.ReturnType, 355 CK_IntegralCast); 356 assert(Casted.isUsable()); 357 RS->setRetValue(Casted.take()); 358 } 359 } 360 } 361 362 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, 363 Declarator &ParamInfo, 364 Scope *CurScope) { 365 // Determine if we're within a context where we know that the lambda will 366 // be dependent, because there are template parameters in scope. 367 bool KnownDependent = false; 368 if (Scope *TmplScope = CurScope->getTemplateParamParent()) 369 if (!TmplScope->decl_empty()) 370 KnownDependent = true; 371 372 CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, KnownDependent); 373 374 // Determine the signature of the call operator. 375 TypeSourceInfo *MethodTyInfo; 376 bool ExplicitParams = true; 377 bool ExplicitResultType = true; 378 bool ContainsUnexpandedParameterPack = false; 379 SourceLocation EndLoc; 380 llvm::SmallVector<ParmVarDecl *, 8> Params; 381 if (ParamInfo.getNumTypeObjects() == 0) { 382 // C++11 [expr.prim.lambda]p4: 383 // If a lambda-expression does not include a lambda-declarator, it is as 384 // if the lambda-declarator were (). 385 FunctionProtoType::ExtProtoInfo EPI; 386 EPI.HasTrailingReturn = true; 387 EPI.TypeQuals |= DeclSpec::TQ_const; 388 QualType MethodTy = Context.getFunctionType(Context.DependentTy, 389 /*Args=*/0, /*NumArgs=*/0, EPI); 390 MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy); 391 ExplicitParams = false; 392 ExplicitResultType = false; 393 EndLoc = Intro.Range.getEnd(); 394 } else { 395 assert(ParamInfo.isFunctionDeclarator() && 396 "lambda-declarator is a function"); 397 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo(); 398 399 // C++11 [expr.prim.lambda]p5: 400 // This function call operator is declared const (9.3.1) if and only if 401 // the lambda-expression's parameter-declaration-clause is not followed 402 // by mutable. It is neither virtual nor declared volatile. [...] 403 if (!FTI.hasMutableQualifier()) 404 FTI.TypeQuals |= DeclSpec::TQ_const; 405 406 MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope); 407 assert(MethodTyInfo && "no type from lambda-declarator"); 408 EndLoc = ParamInfo.getSourceRange().getEnd(); 409 410 ExplicitResultType 411 = MethodTyInfo->getType()->getAs<FunctionType>()->getResultType() 412 != Context.DependentTy; 413 414 Params.reserve(FTI.NumArgs); 415 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) 416 Params.push_back(cast<ParmVarDecl>(FTI.ArgInfo[i].Param)); 417 418 // Check for unexpanded parameter packs in the method type. 419 if (MethodTyInfo->getType()->containsUnexpandedParameterPack()) 420 ContainsUnexpandedParameterPack = true; 421 } 422 423 CXXMethodDecl *Method = startLambdaDefinition(Class, Intro.Range, 424 MethodTyInfo, EndLoc, Params); 425 426 if (ExplicitParams) 427 CheckCXXDefaultArguments(Method); 428 429 // Attributes on the lambda apply to the method. 430 ProcessDeclAttributes(CurScope, Method, ParamInfo); 431 432 // Introduce the function call operator as the current declaration context. 433 PushDeclContext(CurScope, Method); 434 435 // Introduce the lambda scope. 436 LambdaScopeInfo *LSI 437 = enterLambdaScope(Method, Intro.Range, Intro.Default, ExplicitParams, 438 ExplicitResultType, 439 !Method->isConst()); 440 441 // Handle explicit captures. 442 SourceLocation PrevCaptureLoc 443 = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc; 444 for (llvm::SmallVector<LambdaCapture, 4>::const_iterator 445 C = Intro.Captures.begin(), 446 E = Intro.Captures.end(); 447 C != E; 448 PrevCaptureLoc = C->Loc, ++C) { 449 if (C->Kind == LCK_This) { 450 // C++11 [expr.prim.lambda]p8: 451 // An identifier or this shall not appear more than once in a 452 // lambda-capture. 453 if (LSI->isCXXThisCaptured()) { 454 Diag(C->Loc, diag::err_capture_more_than_once) 455 << "'this'" 456 << SourceRange(LSI->getCXXThisCapture().getLocation()) 457 << FixItHint::CreateRemoval( 458 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 459 continue; 460 } 461 462 // C++11 [expr.prim.lambda]p8: 463 // If a lambda-capture includes a capture-default that is =, the 464 // lambda-capture shall not contain this [...]. 465 if (Intro.Default == LCD_ByCopy) { 466 Diag(C->Loc, diag::err_this_capture_with_copy_default) 467 << FixItHint::CreateRemoval( 468 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 469 continue; 470 } 471 472 // C++11 [expr.prim.lambda]p12: 473 // If this is captured by a local lambda expression, its nearest 474 // enclosing function shall be a non-static member function. 475 QualType ThisCaptureType = getCurrentThisType(); 476 if (ThisCaptureType.isNull()) { 477 Diag(C->Loc, diag::err_this_capture) << true; 478 continue; 479 } 480 481 CheckCXXThisCapture(C->Loc, /*Explicit=*/true); 482 continue; 483 } 484 485 assert(C->Id && "missing identifier for capture"); 486 487 // C++11 [expr.prim.lambda]p8: 488 // If a lambda-capture includes a capture-default that is &, the 489 // identifiers in the lambda-capture shall not be preceded by &. 490 // If a lambda-capture includes a capture-default that is =, [...] 491 // each identifier it contains shall be preceded by &. 492 if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) { 493 Diag(C->Loc, diag::err_reference_capture_with_reference_default) 494 << FixItHint::CreateRemoval( 495 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 496 continue; 497 } else if (C->Kind == LCK_ByCopy && Intro.Default == LCD_ByCopy) { 498 Diag(C->Loc, diag::err_copy_capture_with_copy_default) 499 << FixItHint::CreateRemoval( 500 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 501 continue; 502 } 503 504 DeclarationNameInfo Name(C->Id, C->Loc); 505 LookupResult R(*this, Name, LookupOrdinaryName); 506 LookupName(R, CurScope); 507 if (R.isAmbiguous()) 508 continue; 509 if (R.empty()) { 510 // FIXME: Disable corrections that would add qualification? 511 CXXScopeSpec ScopeSpec; 512 DeclFilterCCC<VarDecl> Validator; 513 if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R, Validator)) 514 continue; 515 } 516 517 // C++11 [expr.prim.lambda]p10: 518 // The identifiers in a capture-list are looked up using the usual rules 519 // for unqualified name lookup (3.4.1); each such lookup shall find a 520 // variable with automatic storage duration declared in the reaching 521 // scope of the local lambda expression. 522 // 523 // Note that the 'reaching scope' check happens in tryCaptureVariable(). 524 VarDecl *Var = R.getAsSingle<VarDecl>(); 525 if (!Var) { 526 Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id; 527 continue; 528 } 529 530 if (!Var->hasLocalStorage()) { 531 Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id; 532 Diag(Var->getLocation(), diag::note_previous_decl) << C->Id; 533 continue; 534 } 535 536 // C++11 [expr.prim.lambda]p8: 537 // An identifier or this shall not appear more than once in a 538 // lambda-capture. 539 if (LSI->isCaptured(Var)) { 540 Diag(C->Loc, diag::err_capture_more_than_once) 541 << C->Id 542 << SourceRange(LSI->getCapture(Var).getLocation()) 543 << FixItHint::CreateRemoval( 544 SourceRange(PP.getLocForEndOfToken(PrevCaptureLoc), C->Loc)); 545 continue; 546 } 547 548 // C++11 [expr.prim.lambda]p23: 549 // A capture followed by an ellipsis is a pack expansion (14.5.3). 550 SourceLocation EllipsisLoc; 551 if (C->EllipsisLoc.isValid()) { 552 if (Var->isParameterPack()) { 553 EllipsisLoc = C->EllipsisLoc; 554 } else { 555 Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 556 << SourceRange(C->Loc); 557 558 // Just ignore the ellipsis. 559 } 560 } else if (Var->isParameterPack()) { 561 ContainsUnexpandedParameterPack = true; 562 } 563 564 TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef : 565 TryCapture_ExplicitByVal; 566 tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc); 567 } 568 finishLambdaExplicitCaptures(LSI); 569 570 LSI->ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; 571 572 // Add lambda parameters into scope. 573 addLambdaParameters(Method, CurScope); 574 575 // Enter a new evaluation context to insulate the lambda from any 576 // cleanups from the enclosing full-expression. 577 PushExpressionEvaluationContext(PotentiallyEvaluated); 578 } 579 580 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, 581 bool IsInstantiation) { 582 // Leave the expression-evaluation context. 583 DiscardCleanupsInEvaluationContext(); 584 PopExpressionEvaluationContext(); 585 586 // Leave the context of the lambda. 587 if (!IsInstantiation) 588 PopDeclContext(); 589 590 // Finalize the lambda. 591 LambdaScopeInfo *LSI = getCurLambda(); 592 CXXRecordDecl *Class = LSI->Lambda; 593 Class->setInvalidDecl(); 594 SmallVector<Decl*, 4> Fields; 595 for (RecordDecl::field_iterator i = Class->field_begin(), 596 e = Class->field_end(); i != e; ++i) 597 Fields.push_back(*i); 598 ActOnFields(0, Class->getLocation(), Class, Fields, 599 SourceLocation(), SourceLocation(), 0); 600 CheckCompletedCXXClass(Class); 601 602 PopFunctionScopeInfo(); 603 } 604 605 /// \brief Add a lambda's conversion to function pointer, as described in 606 /// C++11 [expr.prim.lambda]p6. 607 static void addFunctionPointerConversion(Sema &S, 608 SourceRange IntroducerRange, 609 CXXRecordDecl *Class, 610 CXXMethodDecl *CallOperator) { 611 // Add the conversion to function pointer. 612 const FunctionProtoType *Proto 613 = CallOperator->getType()->getAs<FunctionProtoType>(); 614 QualType FunctionPtrTy; 615 QualType FunctionTy; 616 { 617 FunctionProtoType::ExtProtoInfo ExtInfo = Proto->getExtProtoInfo(); 618 ExtInfo.TypeQuals = 0; 619 FunctionTy = S.Context.getFunctionType(Proto->getResultType(), 620 Proto->arg_type_begin(), 621 Proto->getNumArgs(), 622 ExtInfo); 623 FunctionPtrTy = S.Context.getPointerType(FunctionTy); 624 } 625 626 FunctionProtoType::ExtProtoInfo ExtInfo; 627 ExtInfo.TypeQuals = Qualifiers::Const; 628 QualType ConvTy = S.Context.getFunctionType(FunctionPtrTy, 0, 0, ExtInfo); 629 630 SourceLocation Loc = IntroducerRange.getBegin(); 631 DeclarationName Name 632 = S.Context.DeclarationNames.getCXXConversionFunctionName( 633 S.Context.getCanonicalType(FunctionPtrTy)); 634 DeclarationNameLoc NameLoc; 635 NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(FunctionPtrTy, 636 Loc); 637 CXXConversionDecl *Conversion 638 = CXXConversionDecl::Create(S.Context, Class, Loc, 639 DeclarationNameInfo(Name, Loc, NameLoc), 640 ConvTy, 641 S.Context.getTrivialTypeSourceInfo(ConvTy, 642 Loc), 643 /*isInline=*/false, /*isExplicit=*/false, 644 /*isConstexpr=*/false, 645 CallOperator->getBody()->getLocEnd()); 646 Conversion->setAccess(AS_public); 647 Conversion->setImplicit(true); 648 Class->addDecl(Conversion); 649 650 // Add a non-static member function "__invoke" that will be the result of 651 // the conversion. 652 Name = &S.Context.Idents.get("__invoke"); 653 CXXMethodDecl *Invoke 654 = CXXMethodDecl::Create(S.Context, Class, Loc, 655 DeclarationNameInfo(Name, Loc), FunctionTy, 656 CallOperator->getTypeSourceInfo(), 657 /*IsStatic=*/true, SC_Static, /*IsInline=*/true, 658 /*IsConstexpr=*/false, 659 CallOperator->getBody()->getLocEnd()); 660 SmallVector<ParmVarDecl *, 4> InvokeParams; 661 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 662 ParmVarDecl *From = CallOperator->getParamDecl(I); 663 InvokeParams.push_back(ParmVarDecl::Create(S.Context, Invoke, 664 From->getLocStart(), 665 From->getLocation(), 666 From->getIdentifier(), 667 From->getType(), 668 From->getTypeSourceInfo(), 669 From->getStorageClass(), 670 From->getStorageClassAsWritten(), 671 /*DefaultArg=*/0)); 672 } 673 Invoke->setParams(InvokeParams); 674 Invoke->setAccess(AS_private); 675 Invoke->setImplicit(true); 676 Class->addDecl(Invoke); 677 } 678 679 /// \brief Add a lambda's conversion to block pointer. 680 static void addBlockPointerConversion(Sema &S, 681 SourceRange IntroducerRange, 682 CXXRecordDecl *Class, 683 CXXMethodDecl *CallOperator) { 684 const FunctionProtoType *Proto 685 = CallOperator->getType()->getAs<FunctionProtoType>(); 686 QualType BlockPtrTy; 687 { 688 FunctionProtoType::ExtProtoInfo ExtInfo = Proto->getExtProtoInfo(); 689 ExtInfo.TypeQuals = 0; 690 QualType FunctionTy 691 = S.Context.getFunctionType(Proto->getResultType(), 692 Proto->arg_type_begin(), 693 Proto->getNumArgs(), 694 ExtInfo); 695 BlockPtrTy = S.Context.getBlockPointerType(FunctionTy); 696 } 697 698 FunctionProtoType::ExtProtoInfo ExtInfo; 699 ExtInfo.TypeQuals = Qualifiers::Const; 700 QualType ConvTy = S.Context.getFunctionType(BlockPtrTy, 0, 0, ExtInfo); 701 702 SourceLocation Loc = IntroducerRange.getBegin(); 703 DeclarationName Name 704 = S.Context.DeclarationNames.getCXXConversionFunctionName( 705 S.Context.getCanonicalType(BlockPtrTy)); 706 DeclarationNameLoc NameLoc; 707 NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc); 708 CXXConversionDecl *Conversion 709 = CXXConversionDecl::Create(S.Context, Class, Loc, 710 DeclarationNameInfo(Name, Loc, NameLoc), 711 ConvTy, 712 S.Context.getTrivialTypeSourceInfo(ConvTy, Loc), 713 /*isInline=*/false, /*isExplicit=*/false, 714 /*isConstexpr=*/false, 715 CallOperator->getBody()->getLocEnd()); 716 Conversion->setAccess(AS_public); 717 Conversion->setImplicit(true); 718 Class->addDecl(Conversion); 719 } 720 721 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, 722 Scope *CurScope, 723 bool IsInstantiation) { 724 // Collect information from the lambda scope. 725 llvm::SmallVector<LambdaExpr::Capture, 4> Captures; 726 llvm::SmallVector<Expr *, 4> CaptureInits; 727 LambdaCaptureDefault CaptureDefault; 728 CXXRecordDecl *Class; 729 CXXMethodDecl *CallOperator; 730 SourceRange IntroducerRange; 731 bool ExplicitParams; 732 bool ExplicitResultType; 733 bool LambdaExprNeedsCleanups; 734 bool ContainsUnexpandedParameterPack; 735 llvm::SmallVector<VarDecl *, 4> ArrayIndexVars; 736 llvm::SmallVector<unsigned, 4> ArrayIndexStarts; 737 { 738 LambdaScopeInfo *LSI = getCurLambda(); 739 CallOperator = LSI->CallOperator; 740 Class = LSI->Lambda; 741 IntroducerRange = LSI->IntroducerRange; 742 ExplicitParams = LSI->ExplicitParams; 743 ExplicitResultType = !LSI->HasImplicitReturnType; 744 LambdaExprNeedsCleanups = LSI->ExprNeedsCleanups; 745 ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack; 746 ArrayIndexVars.swap(LSI->ArrayIndexVars); 747 ArrayIndexStarts.swap(LSI->ArrayIndexStarts); 748 749 // Translate captures. 750 for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) { 751 LambdaScopeInfo::Capture From = LSI->Captures[I]; 752 assert(!From.isBlockCapture() && "Cannot capture __block variables"); 753 bool IsImplicit = I >= LSI->NumExplicitCaptures; 754 755 // Handle 'this' capture. 756 if (From.isThisCapture()) { 757 Captures.push_back(LambdaExpr::Capture(From.getLocation(), 758 IsImplicit, 759 LCK_This)); 760 CaptureInits.push_back(new (Context) CXXThisExpr(From.getLocation(), 761 getCurrentThisType(), 762 /*isImplicit=*/true)); 763 continue; 764 } 765 766 VarDecl *Var = From.getVariable(); 767 LambdaCaptureKind Kind = From.isCopyCapture()? LCK_ByCopy : LCK_ByRef; 768 Captures.push_back(LambdaExpr::Capture(From.getLocation(), IsImplicit, 769 Kind, Var, From.getEllipsisLoc())); 770 CaptureInits.push_back(From.getCopyExpr()); 771 } 772 773 switch (LSI->ImpCaptureStyle) { 774 case CapturingScopeInfo::ImpCap_None: 775 CaptureDefault = LCD_None; 776 break; 777 778 case CapturingScopeInfo::ImpCap_LambdaByval: 779 CaptureDefault = LCD_ByCopy; 780 break; 781 782 case CapturingScopeInfo::ImpCap_LambdaByref: 783 CaptureDefault = LCD_ByRef; 784 break; 785 786 case CapturingScopeInfo::ImpCap_Block: 787 llvm_unreachable("block capture in lambda"); 788 break; 789 } 790 791 // C++11 [expr.prim.lambda]p4: 792 // If a lambda-expression does not include a 793 // trailing-return-type, it is as if the trailing-return-type 794 // denotes the following type: 795 // FIXME: Assumes current resolution to core issue 975. 796 if (LSI->HasImplicitReturnType) { 797 deduceClosureReturnType(*LSI); 798 799 // - if there are no return statements in the 800 // compound-statement, or all return statements return 801 // either an expression of type void or no expression or 802 // braced-init-list, the type void; 803 if (LSI->ReturnType.isNull()) { 804 LSI->ReturnType = Context.VoidTy; 805 } 806 807 // Create a function type with the inferred return type. 808 const FunctionProtoType *Proto 809 = CallOperator->getType()->getAs<FunctionProtoType>(); 810 QualType FunctionTy 811 = Context.getFunctionType(LSI->ReturnType, 812 Proto->arg_type_begin(), 813 Proto->getNumArgs(), 814 Proto->getExtProtoInfo()); 815 CallOperator->setType(FunctionTy); 816 } 817 818 // C++ [expr.prim.lambda]p7: 819 // The lambda-expression's compound-statement yields the 820 // function-body (8.4) of the function call operator [...]. 821 ActOnFinishFunctionBody(CallOperator, Body, IsInstantiation); 822 CallOperator->setLexicalDeclContext(Class); 823 Class->addDecl(CallOperator); 824 PopExpressionEvaluationContext(); 825 826 // C++11 [expr.prim.lambda]p6: 827 // The closure type for a lambda-expression with no lambda-capture 828 // has a public non-virtual non-explicit const conversion function 829 // to pointer to function having the same parameter and return 830 // types as the closure type's function call operator. 831 if (Captures.empty() && CaptureDefault == LCD_None) 832 addFunctionPointerConversion(*this, IntroducerRange, Class, 833 CallOperator); 834 835 // Objective-C++: 836 // The closure type for a lambda-expression has a public non-virtual 837 // non-explicit const conversion function to a block pointer having the 838 // same parameter and return types as the closure type's function call 839 // operator. 840 if (getLangOpts().Blocks && getLangOpts().ObjC1) 841 addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator); 842 843 // Finalize the lambda class. 844 SmallVector<Decl*, 4> Fields; 845 for (RecordDecl::field_iterator i = Class->field_begin(), 846 e = Class->field_end(); i != e; ++i) 847 Fields.push_back(*i); 848 ActOnFields(0, Class->getLocation(), Class, Fields, 849 SourceLocation(), SourceLocation(), 0); 850 CheckCompletedCXXClass(Class); 851 } 852 853 if (LambdaExprNeedsCleanups) 854 ExprNeedsCleanups = true; 855 856 LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange, 857 CaptureDefault, Captures, 858 ExplicitParams, ExplicitResultType, 859 CaptureInits, ArrayIndexVars, 860 ArrayIndexStarts, Body->getLocEnd(), 861 ContainsUnexpandedParameterPack); 862 863 // C++11 [expr.prim.lambda]p2: 864 // A lambda-expression shall not appear in an unevaluated operand 865 // (Clause 5). 866 if (!CurContext->isDependentContext()) { 867 switch (ExprEvalContexts.back().Context) { 868 case Unevaluated: 869 // We don't actually diagnose this case immediately, because we 870 // could be within a context where we might find out later that 871 // the expression is potentially evaluated (e.g., for typeid). 872 ExprEvalContexts.back().Lambdas.push_back(Lambda); 873 break; 874 875 case ConstantEvaluated: 876 case PotentiallyEvaluated: 877 case PotentiallyEvaluatedIfUsed: 878 break; 879 } 880 } 881 882 return MaybeBindToTemporary(Lambda); 883 } 884 885 ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation, 886 SourceLocation ConvLocation, 887 CXXConversionDecl *Conv, 888 Expr *Src) { 889 // Make sure that the lambda call operator is marked used. 890 CXXRecordDecl *Lambda = Conv->getParent(); 891 CXXMethodDecl *CallOperator 892 = cast<CXXMethodDecl>( 893 *Lambda->lookup( 894 Context.DeclarationNames.getCXXOperatorName(OO_Call)).first); 895 CallOperator->setReferenced(); 896 CallOperator->setUsed(); 897 898 ExprResult Init = PerformCopyInitialization( 899 InitializedEntity::InitializeBlock(ConvLocation, 900 Src->getType(), 901 /*NRVO=*/false), 902 CurrentLocation, Src); 903 if (!Init.isInvalid()) 904 Init = ActOnFinishFullExpr(Init.take()); 905 906 if (Init.isInvalid()) 907 return ExprError(); 908 909 // Create the new block to be returned. 910 BlockDecl *Block = BlockDecl::Create(Context, CurContext, ConvLocation); 911 912 // Set the type information. 913 Block->setSignatureAsWritten(CallOperator->getTypeSourceInfo()); 914 Block->setIsVariadic(CallOperator->isVariadic()); 915 Block->setBlockMissingReturnType(false); 916 917 // Add parameters. 918 SmallVector<ParmVarDecl *, 4> BlockParams; 919 for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) { 920 ParmVarDecl *From = CallOperator->getParamDecl(I); 921 BlockParams.push_back(ParmVarDecl::Create(Context, Block, 922 From->getLocStart(), 923 From->getLocation(), 924 From->getIdentifier(), 925 From->getType(), 926 From->getTypeSourceInfo(), 927 From->getStorageClass(), 928 From->getStorageClassAsWritten(), 929 /*DefaultArg=*/0)); 930 } 931 Block->setParams(BlockParams); 932 933 Block->setIsConversionFromLambda(true); 934 935 // Add capture. The capture uses a fake variable, which doesn't correspond 936 // to any actual memory location. However, the initializer copy-initializes 937 // the lambda object. 938 TypeSourceInfo *CapVarTSI = 939 Context.getTrivialTypeSourceInfo(Src->getType()); 940 VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation, 941 ConvLocation, 0, 942 Src->getType(), CapVarTSI, 943 SC_None, SC_None); 944 BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false, 945 /*Nested=*/false, /*Copy=*/Init.take()); 946 Block->setCaptures(Context, &Capture, &Capture + 1, 947 /*CapturesCXXThis=*/false); 948 949 // Add a fake function body to the block. IR generation is responsible 950 // for filling in the actual body, which cannot be expressed as an AST. 951 Block->setBody(new (Context) CompoundStmt(ConvLocation)); 952 953 // Create the block literal expression. 954 Expr *BuildBlock = new (Context) BlockExpr(Block, Conv->getConversionType()); 955 ExprCleanupObjects.push_back(Block); 956 ExprNeedsCleanups = true; 957 958 return BuildBlock; 959 } 960