contrib/llvm/tools/clang/lib/Sema/SemaLambda.cpp

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