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