[Cxx1z] Implement Lambda Capture of *this by Value as [=,*this] (P0018R3)

[faisalv]

Summary

Implement lambda capture of *this.

struct A {

int d = 10;
auto foo() { return [*this] (auto a) mutable { d+=a; return d; }; }

};
auto L = A{}.foo(); // A{}'s lifetime is gone.

// Below is still ok, because *this was captured by value.
assert(L(10) == 20);
assert(L(100) == 120);

[faisalv]

Add warnings and extension diagnostics for C++1z, and refactor the codegen portion, simplifying it further.
Thanks!

[rsmith]

include/clang/AST/LambdaCapture.h

41

I'm not a fan of this representation. Please use Capture_ByCopy to indicate a by-copy capture of *this. It's probably time to clean up DeclAndBits a little. Something like this should work:

struct LLVM_ALIGNAS(4) OpaqueCapturedEntity {};
llvm::PointerIntPair<void*, 2> CapturedEntityAndBits;
static OpaqueCapturedEntity StarThis;
static OpaqueCapturedEntity VLAType;

where the void* is either a Decl* or points to StarThis or VLAType.

include/clang/Basic/Lambda.h

35–36

-> Capturing the \c *this object by reference?

include/clang/Sema/ScopeInfo.h

414–417

Please try to integrate this into the existing code rather than adding it as a separate thing on the side. Again, we can model this and *this as capturing the same entity either by reference or by value, and we should do so.

455–468

In particular: don't add isStarThisCapture, just use isThisCapture and isCopyCapture/isReferenceCapture to distinguish between this and *this.

lib/AST/ExprCXX.cpp

894

Add // Fall through comment.

lib/Parse/ParseExprCXX.cpp

850

You don't need lookahead for this; if the current token is *, you can consume that token then look for this. It's an error if something else comes next.

857–860

We shouldn't produce this warning during disambiguation between a lambda and an Obj-C message send or designator. Please move the diagnostic into Sema instead.

lib/Sema/SemaDecl.cpp

10994

Use C.getCaptureKind() rather than querying the type of the field directly here.

lib/Sema/SemaExpr.cpp

13256

Just delete this parameter? (As a separate change, though.)

lib/Sema/SemaExprCXX.cpp

841–849

(Only somewhat related to the current change...) This looks wrong. If we're in a lambda within a lambda within a default member initializer, we need to recurse up more parents to find the right context. Looks like we should be walking up to the parent of the closure type, checking whether that is itself a lambda, and if so, recursing, until we reach a class or a function that isn't a lambda call operator. And we should accumulate the constness of *this on the way.

919

Please don't invent a fake identifier *this here. Instead, directly pass the fact that the capture in question is a capture of *this.

929–932

Please assert(!ByCopy || Explicit) here (we cannot implicitly capture *this by value).

982

This looks wrong: for all scopes other than the innermost one, if *this is not already captured (explicitly) then it should always be captured by reference.

lib/Sema/SemaLambda.cpp

938

Just make this change?

[faisalv]

Thanks for the review! An updated patch that should address your concerns will follow in a few mins.

I'm still not entirely sure I follow your comment about the intialized-entity: 'directly pass the fact that the capture in question is a capture of *this'.

lib/Sema/SemaExprCXX.cpp

841–849

Thanks for taking a look at this. Agreed - I'll submit this as a separate fix - added a fixme.

919

OK - I don't invent a fake identifier and instead pass in nullptr - but to be honest, I'm not sure what you mean by 'directly pass the fact that the capture in question is a capture of *this'

982

You're absolutely right. Fixed. [=] { return [*this] { return m; }; }; will now emit the right code.

[faisalv]

Updated patch that should incorporate Richard's feedback.

Thanks!

[faisalv]

Added some more comments (hopefully didn't go overboard).

Thanks again for reviewing Richard!

[rsmith]

LGTM, thanks!

include/clang/AST/LambdaCapture.h

47

"by VLA capture" -> "capture of a VLA type"?

include/clang/Basic/DiagnosticSemaKinds.td

5982 ↗

(On Diff #50757)

star-this -> *this

5984–5987 ↗

(On Diff #50757)

by value capture of '*this' -> capture of '*this' by copy

lib/Sema/SemaExprCXX.cpp

994

You don't need this flag; instead, check Explicit && idx == MaxFunctionScopesIndex here.

1033

Likewise here.

[rsmith]

Couple more things:

1. Please add some testing to tests/CXX/expr/expr.prim/expr.prim.lambda
2. Please update cxx_status.html

[faisalv]

Committed as r263921

http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20160321/153258.html

README.txt

 Information on the LLVM project:   http://llvm.org/
 
 If you have questions or comments about Clang, a great place to discuss them is
 on the Clang development mailing list:
   http://lists.llvm.org/mailman/listinfo/cfe-dev
 
 If you find a bug in Clang, please file it in the LLVM bug tracker:
   http://llvm.org/bugs/
+
+use llvm svn-revision 262784
 No newline at end of file

include/clang/AST/LambdaCapture.h

enum {
     Capture_Implicit = 0x01,
 
     /// \brief Flag used by the Capture class to indicate that the
     /// given capture was by-copy.
     ///
     /// This includes the case of a non-reference init-capture.
     Capture_ByCopy = 0x02
   };
-
   llvm::PointerIntPair<Decl *, 2> DeclAndBits;
   SourceLocation Loc;
   SourceLocation EllipsisLoc;
-
+  bool IsStarThis : 1;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
 public:
   /// \brief Create a new capture of a variable or of \c this.
   ///
   /// \param Loc The source location associated with this capture.
   ///
   /// \param Kind The kind of capture (this, byref, bycopy), which must
   /// not be init-capture.
   ///
   /// \param Implicit Whether the capture was implicit or explicit.
   ///
   /// \param Var The local variable being captured, or null if capturing
   /// \c this.
   ///
   /// \param EllipsisLoc The location of the ellipsis (...) for a
   /// capture that is a pack expansion, or an invalid source
   /// location to indicate that this is not a pack expansion.
   LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind,
                 VarDecl *Var = nullptr,
                 SourceLocation EllipsisLoc = SourceLocation());
 
   /// \brief Determine the kind of capture.
   LambdaCaptureKind getCaptureKind() const;
 
   /// \brief Determine whether this capture handles the C++ \c this
   /// pointer.
   bool capturesThis() const {
-    return (DeclAndBits.getPointer() == nullptr) &&
-           !(DeclAndBits.getInt() & Capture_ByCopy);
+    return ((DeclAndBits.getPointer() == nullptr) &&
+           !(DeclAndBits.getInt() & Capture_ByCopy)) 
+           || IsStarThis;
+  }
+  bool capturesStarThis() const {
+    return capturesThis() && IsStarThis;
   }
 
   /// \brief Determine whether this capture handles a variable.
   bool capturesVariable() const {
     return dyn_cast_or_null<VarDecl>(DeclAndBits.getPointer());
   }
 
   /// \brief Determine whether this captures a variable length array bound

include/clang/Basic/Lambda.h

 };
 
 /// \brief The different capture forms in a lambda introducer
 ///
 /// C++11 allows capture of \c this, or of local variables by copy or
 /// by reference.  C++1y also allows "init-capture", where the initializer
 /// is an expression.
 enum LambdaCaptureKind {
   LCK_This,   ///< Capturing the \c this pointer
+  LCK_StarThis, /// < Capturing the \c *this object by value
   LCK_ByCopy, ///< Capturing by copy (a.k.a., by value)
   LCK_ByRef,  ///< Capturing by reference
   LCK_VLAType ///< Capturing variable-length array type
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_LAMBDA_H

include/clang/Sema/ScopeInfo.h

     // There are three ways to capture a local variable:
     //  - capture by copy in the C++11 sense,
     //  - capture by reference in the C++11 sense, and
     //  - __block capture.
     // Lambdas explicitly specify capture by copy or capture by reference.
     // For blocks, __block capture applies to variables with that annotation,
     // variables of reference type are captured by reference, and other
     // variables are captured by copy.
     enum CaptureKind {
       Cap_ByCopy, Cap_ByRef, Cap_Block, Cap_This
     };
-
+    bool IsStarThis = false;
     /// The variable being captured (if we are not capturing 'this') and whether
     /// this is a nested capture.
     llvm::PointerIntPair<VarDecl*, 1, bool> VarAndNested;
 
     /// Expression to initialize a field of the given type, and the kind of
     /// capture (if this is a capture and not an init-capture). The expression
     /// is only required if we are capturing ByVal and the variable's type has
     /// a non-trivial copy constructor.

             QualType CaptureType, Expr *Cpy)
         : VarAndNested(Var, IsNested),
           InitExprAndCaptureKind(Cpy, Block ? Cap_Block :
                                       ByRef ? Cap_ByRef : Cap_ByCopy),
           Loc(Loc), EllipsisLoc(EllipsisLoc), CaptureType(CaptureType) {}
 
     enum IsThisCapture { ThisCapture };
     Capture(IsThisCapture, bool IsNested, SourceLocation Loc,
-            QualType CaptureType, Expr *Cpy)
+            QualType CaptureType, Expr *Cpy, const bool ByCopy)
         : VarAndNested(nullptr, IsNested),
           InitExprAndCaptureKind(Cpy, Cap_This),
-          Loc(Loc), EllipsisLoc(), CaptureType(CaptureType) {}
+          Loc(Loc), EllipsisLoc(), CaptureType(CaptureType),
+          IsStarThis(ByCopy) {}
 
     bool isThisCapture() const {
       return InitExprAndCaptureKind.getInt() == Cap_This;
     }
+    bool isStarThisCapture() const {
+      return IsStarThis;
+    }
     bool isVariableCapture() const {
-      return InitExprAndCaptureKind.getInt() != Cap_This && !isVLATypeCapture();
+      return !isThisCapture() && !isVLATypeCapture();
     }
     bool isCopyCapture() const {
-      return InitExprAndCaptureKind.getInt() == Cap_ByCopy &&
-             !isVLATypeCapture();
+      return (InitExprAndCaptureKind.getInt() == Cap_ByCopy &&
+              !isVLATypeCapture()) ||
+             IsStarThis;
     }
     bool isReferenceCapture() const {
       return InitExprAndCaptureKind.getInt() == Cap_ByRef;
     }
     bool isBlockCapture() const {
       return InitExprAndCaptureKind.getInt() == Cap_Block;
     }
     bool isVLATypeCapture() const {
       return InitExprAndCaptureKind.getInt() == Cap_ByCopy &&

   void addVLATypeCapture(SourceLocation Loc, QualType CaptureType) {
     Captures.push_back(Capture(/*Var*/ nullptr, /*isBlock*/ false,
                                /*isByref*/ false, /*isNested*/ false, Loc,
                                /*EllipsisLoc*/ SourceLocation(), CaptureType,
                                /*Cpy*/ nullptr));
   }
 
   void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType,
-                      Expr *Cpy);
+                      Expr *Cpy, bool ByCopy);
 
   /// \brief Determine whether the C++ 'this' is captured.
   bool isCXXThisCaptured() const { return CXXThisCaptureIndex != 0; }
   
   /// \brief Retrieve the capture of C++ 'this', if it has been captured.
   Capture &getCXXThisCapture() {
     assert(isCXXThisCaptured() && "this has not been captured");
     return Captures[CXXThisCaptureIndex - 1];

 void FunctionScopeInfo::recordUseOfWeak(const ExprT *E, bool IsRead) {
   assert(E);
   WeakUseVector &Uses = WeakObjectUses[WeakObjectProfileTy(E)];
   Uses.push_back(WeakUseTy(E, IsRead));
 }
 
 inline void
 CapturingScopeInfo::addThisCapture(bool isNested, SourceLocation Loc,
-                                   QualType CaptureType, Expr *Cpy) {
+                                   QualType CaptureType, Expr *Cpy,
+                                   const bool ByCopy) {
   Captures.push_back(Capture(Capture::ThisCapture, isNested, Loc, CaptureType,
-                             Cpy));
+                             Cpy, ByCopy));
   CXXThisCaptureIndex = Captures.size();
 }
 
 } // end namespace sema
 } // end namespace clang
 
 #endif

include/clang/Sema/Sema.h

   /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
   /// This is useful when enclosing lambdas must speculatively capture 
   /// 'this' that may or may not be used in certain specializations of
   /// a nested generic lambda (depending on whether the name resolves to 
   /// a non-static member function or a static function).
   /// \return returns 'true' if failed, 'false' if success.
   bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false, 
       bool BuildAndDiagnose = true,
-      const unsigned *const FunctionScopeIndexToStopAt = nullptr);
+      const unsigned *const FunctionScopeIndexToStopAt = nullptr,
+      bool ByCopy = false);
 
   /// \brief Determine whether the given type is the type of *this that is used
   /// outside of the body of a member function for a type that is currently
   /// being defined.
   bool isThisOutsideMemberFunctionBody(QualType BaseType);
 
   /// ActOnCXXBoolLiteral - Parse {true,false} literals.
   ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);

lib/AST/ExprCXX.cpp

       Args[i] = args[i];
     }
   }
 }
 
 LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit,
                              LambdaCaptureKind Kind, VarDecl *Var,
                              SourceLocation EllipsisLoc)
-  : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc)
+  : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc), IsStarThis(false)
 {
   unsigned Bits = 0;
   if (Implicit)
     Bits |= Capture_Implicit;
   
   switch (Kind) {
+  case LCK_StarThis:
+    IsStarThis = true;
   case LCK_This:
     assert(!Var && "'this' capture cannot have a variable!");
     break;
   
   case LCK_ByCopy:
     Bits |= Capture_ByCopy;
     // Fall through 
   case LCK_ByRef:
     assert(Var && "capture must have a variable!");
     break;
   case LCK_VLAType:
     assert(!Var && "VLA type capture cannot have a variable!");
     Bits |= Capture_ByCopy;
     break;
   }
   DeclAndBits.setInt(Bits);
 }
 
 LambdaCaptureKind LambdaCapture::getCaptureKind() const {
   Decl *D = DeclAndBits.getPointer();
-  bool CapByCopy = DeclAndBits.getInt() & Capture_ByCopy;
+  unsigned Bits = DeclAndBits.getInt();
+  bool CapByCopy = Bits & Capture_ByCopy;
   if (!D)
-    return CapByCopy ? LCK_VLAType : LCK_This;
+    return CapByCopy ? LCK_VLAType
+                     : (IsStarThis ? LCK_StarThis : LCK_This);
 
   return CapByCopy ? LCK_ByCopy : LCK_ByRef;
 }
 
 LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange,
                        LambdaCaptureDefault CaptureDefault,
                        SourceLocation CaptureDefaultLoc,
                        ArrayRef<LambdaCapture> Captures, bool ExplicitParams,

lib/AST/StmtPrinter.cpp

     if (NeedComma)
       OS << ", ";
     NeedComma = true;
 
     switch (C->getCaptureKind()) {
     case LCK_This:
       OS << "this";
       break;
-
+    case LCK_StarThis:
+      OS << "*this";
+      break;
     case LCK_ByRef:
       if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
         OS << '&';
       OS << C->getCapturedVar()->getName();
       break;
 
     case LCK_ByCopy:
       OS << C->getCapturedVar()->getName();

lib/AST/StmtProfile.cpp

 void
 StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
   VisitExpr(S);
   for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(),
                                  CEnd = S->explicit_capture_end();
        C != CEnd; ++C) {
     ID.AddInteger(C->getCaptureKind());
     switch (C->getCaptureKind()) {
+    case LCK_StarThis:
     case LCK_This:
       break;
     case LCK_ByRef:
     case LCK_ByCopy:
       VisitDecl(C->getCapturedVar());
       ID.AddBoolean(C->isPackExpansion());
       break;
     case LCK_VLAType:

lib/CodeGen/CodeGenFunction.cpp

     const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
     if (MD->getParent()->isLambda() &&
         MD->getOverloadedOperator() == OO_Call) {
       // We're in a lambda; figure out the captures.
       MD->getParent()->getCaptureFields(LambdaCaptureFields,
                                         LambdaThisCaptureField);
       if (LambdaThisCaptureField) {
         // If this lambda captures this, load it.
-        LValue ThisLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
-        CXXThisValue = EmitLoadOfLValue(ThisLValue,
+        if (!LambdaThisCaptureField->getType()->isPointerType()) {
+          QualType LambdaTagType = getContext().getTagDeclType(LambdaThisCaptureField->getParent());
+          LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue, LambdaTagType);
+          LValue ThisLValue = EmitLValueForField(LambdaLV, LambdaThisCaptureField);
+          CXXThisValue = ThisLValue.getAddress().getPointer();
+        } else {
+          LValue ThisLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
+          CXXThisValue = EmitLoadOfLValue(ThisLValue,
                                         SourceLocation()).getScalarVal();
+        }
       }
       for (auto *FD : MD->getParent()->fields()) {
         if (FD->hasCapturedVLAType()) {
           auto *ExprArg = EmitLoadOfLValue(EmitLValueForLambdaField(FD),
                                            SourceLocation()).getScalarVal();
           auto VAT = FD->getCapturedVLAType();
           VLASizeMap[VAT->getSizeExpr()] = ExprArg;
         }

lib/Parse/ParseExprCXX.cpp

     
     // Parse capture.
     LambdaCaptureKind Kind = LCK_ByCopy;
     LambdaCaptureInitKind InitKind = LambdaCaptureInitKind::NoInit;
     SourceLocation Loc;
     IdentifierInfo *Id = nullptr;
     SourceLocation EllipsisLoc;
     ExprResult Init;
-    
-    if (Tok.is(tok::kw_this)) {
+    if (Tok.is(tok::star) && NextToken().is(tok::kw_this)) {
+      Kind = LCK_StarThis;
+      // FIXME: We should store our location for '*' for better diagnostic messages;
+      ConsumeToken(); // Consume '*'
+      Loc = ConsumeToken();
+    } else if (Tok.is(tok::kw_this)) {
       Kind = LCK_This;
       Loc = ConsumeToken();
     } else {
       if (Tok.is(tok::amp)) {
         Kind = LCK_ByRef;
         ConsumeToken();
 
         if (Tok.is(tok::code_completion)) {
           Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro, 
                                                /*AfterAmpersand=*/true);
           cutOffParsing();
           break;
         }

lib/Sema/SemaDecl.cpp

       LSI->addCapture(VD, /*IsBlock*/false, ByRef, 
           /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
           /*EllipsisLoc*/C.isPackExpansion() 
                          ? C.getEllipsisLoc() : SourceLocation(),
           CaptureType, /*Expr*/ nullptr);
 
     } else if (C.capturesThis()) {
       LSI->addThisCapture(/*Nested*/ false, C.getLocation(), 
-                              S.getCurrentThisType(), /*Expr*/ nullptr);
+                              S.getCurrentThisType(), /*Expr*/ nullptr,
+                              !I->getType()->isPointerType());
     } else {
       LSI->addVLATypeCapture(C.getLocation(), I->getType());
     }
     ++I;
   }
 }
 
 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,

lib/Sema/SemaExpr.cpp

                     SourceLocation(), CaptureType, CopyExpr);
   
   
   return true;
 }
 
 /// \brief Create a field within the lambda class for the variable
 /// being captured.
-static void addAsFieldToClosureType(Sema &S, LambdaScopeInfo *LSI, VarDecl *Var,
+static void addAsFieldToClosureType(Sema &S, LambdaScopeInfo *LSI, VarDecl *,
                                     QualType FieldType, QualType DeclRefType,
                                     SourceLocation Loc,
                                     bool RefersToCapturedVariable) {
   CXXRecordDecl *Lambda = LSI->Lambda;
 
   // Build the non-static data member.
   FieldDecl *Field
     = FieldDecl::Create(S.Context, Lambda, Loc, Loc, nullptr, FieldType,

lib/Sema/SemaExprCXX.cpp

 
 QualType Sema::getCurrentThisType() {
   DeclContext *DC = getFunctionLevelDeclContext();
   QualType ThisTy = CXXThisTypeOverride;
   if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
     if (method && method->isInstance())
       ThisTy = method->getThisType(Context);
   }
   if (ThisTy.isNull()) {
     if (isGenericLambdaCallOperatorSpecialization(CurContext) &&
         CurContext->getParent()->getParent()->isRecord()) {
       // This is a generic lambda call operator that is being instantiated
       // within a default initializer - so use the enclosing class as 'this'.
       // There is no enclosing member function to retrieve the 'this' pointer
       // from.
       QualType ClassTy = Context.getTypeDeclType(
           cast<CXXRecordDecl>(CurContext->getParent()->getParent()));
       // There are no cv-qualifiers for 'this' within default initializers, 
       // per [expr.prim.general]p4.
-      return Context.getPointerType(ClassTy);
+      ThisTy = Context.getPointerType(ClassTy);
+    }
+  }
+   // Add const for '* this' capture if not mutable.
+  if (isLambdaCallOperator(CurContext)) {
+    LambdaScopeInfo *LSI = getCurLambda();
+    assert(LSI);
+    if (LSI->isCXXThisCaptured()) {
+      auto C = LSI->getCXXThisCapture();
+      QualType BaseType = ThisTy->getPointeeType();
+      if (C.isStarThisCapture() && LSI->CallOperator->isConst() &&
+          !BaseType.isConstQualified()) {
+        BaseType.addConst();
+        ThisTy = Context.getPointerType(BaseType);
+      }
     }
   }
   return ThisTy;
 }
 
 Sema::CXXThisScopeRAII::CXXThisScopeRAII(Sema &S, 
                                          Decl *ContextDecl,
                                          unsigned CXXThisTypeQuals,

 
 
 Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
   if (Enabled) {
     S.CXXThisTypeOverride = OldCXXThisTypeOverride;
   }
 }
 
-static Expr *captureThis(ASTContext &Context, RecordDecl *RD,
-                         QualType ThisTy, SourceLocation Loc) {
+static Expr *captureThis(Sema &S, ASTContext &Context, RecordDecl *RD,
+                         QualType ThisTy, SourceLocation Loc,
+                         const bool ByCopy) {
+  QualType CaptureThisTy = ByCopy ? ThisTy->getPointeeType() : ThisTy;
+ 
   FieldDecl *Field
-    = FieldDecl::Create(Context, RD, Loc, Loc, nullptr, ThisTy,
-                        Context.getTrivialTypeSourceInfo(ThisTy, Loc),
+       = FieldDecl::Create(Context, RD, Loc, Loc, nullptr, CaptureThisTy,
+                       Context.getTrivialTypeSourceInfo(CaptureThisTy, Loc),
                         nullptr, false, ICIS_NoInit);
   Field->setImplicit(true);
   Field->setAccess(AS_private);
   RD->addDecl(Field);
-  return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/true);
+  Expr *This = new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit*/true);
+  if (ByCopy) {
+    Expr *StarThis =  S.CreateBuiltinUnaryOp(Loc,
+                                      UO_Deref,
+                                      This).get();
+    InitializedEntity Entity = InitializedEntity::InitializeLambdaCapture(
+      &S.Context.Idents.get("*this"), CaptureThisTy, Loc);
+    InitializationKind InitKind = InitializationKind::CreateDirect(Loc, Loc, Loc);
+    InitializationSequence Init(S, Entity, InitKind, StarThis);
+    ExprResult ER = Init.Perform(S, Entity, InitKind, StarThis);
+    if (ER.isInvalid()) return nullptr;
+    return ER.get();
+  }
+  return This;
 }
 
 bool Sema::CheckCXXThisCapture(SourceLocation Loc, bool Explicit, 
-    bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt) {
+    bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt,
+    const bool ByCopy) {
   // We don't need to capture this in an unevaluated context.
   if (isUnevaluatedContext() && !Explicit)
     return true;
 
   const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt ?
     *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;  
  // Otherwise, check that we can capture 'this'.
   unsigned NumClosures = 0;
   for (unsigned idx = MaxFunctionScopesIndex; idx != 0; idx--) {

   // contexts.
   for (unsigned idx = MaxFunctionScopesIndex; NumClosures; 
       --idx, --NumClosures) {
     CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]);
     Expr *ThisExpr = nullptr;
     QualType ThisTy = getCurrentThisType();
     if (LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI))
       // For lambda expressions, build a field and an initializing expression.
-      ThisExpr = captureThis(Context, LSI->Lambda, ThisTy, Loc);
+      ThisExpr = captureThis(*this, Context, LSI->Lambda, ThisTy, Loc, ByCopy);
     else if (CapturedRegionScopeInfo *RSI
         = dyn_cast<CapturedRegionScopeInfo>(FunctionScopes[idx]))
-      ThisExpr = captureThis(Context, RSI->TheRecordDecl, ThisTy, Loc);
+      ThisExpr =
+          captureThis(*this, Context, RSI->TheRecordDecl, ThisTy, Loc,
+                      false/*ByCopy*/);
 
     bool isNested = NumClosures > 1;
-    CSI->addThisCapture(isNested, Loc, ThisTy, ThisExpr);
+    CSI->addThisCapture(isNested, Loc, ThisTy, ThisExpr, ByCopy);
   }
   return false;
 }
 
 ExprResult Sema::ActOnCXXThis(SourceLocation Loc) {
   /// C++ 9.3.2: In the body of a non-static member function, the keyword this
   /// is a non-lvalue expression whose value is the address of the object for
   /// which the function is called.
 
   QualType ThisTy = getCurrentThisType();
   if (ThisTy.isNull()) return Diag(Loc, diag::err_invalid_this_use);
 
   CheckCXXThisCapture(Loc);
+ 
   return new (Context) CXXThisExpr(Loc, ThisTy, /*isImplicit=*/false);
 }
 
 bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) {
   // If we're outside the body of a member function, then we'll have a specified
   // type for 'this'.
   if (CXXThisTypeOverride.isNull())
     return false;

   if (!TypeRep)
     return ExprError();
 
   TypeSourceInfo *TInfo;
   QualType Ty = GetTypeFromParser(TypeRep, &TInfo);
   if (!TInfo)
     TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation());
 
   return BuildCXXTypeConstructExpr(TInfo, LParenLoc, exprs, RParenLoc);
 }
 
 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
 /// Can be interpreted either as function-style casting ("int(x)")
 /// or class type construction ("ClassType(x,y,z)")
 /// or creation of a value-initialized type ("int()").
 ExprResult
 Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,

lib/Sema/SemaLambda.cpp

   // Distinct capture names, for diagnostics.
   llvm::SmallSet<IdentifierInfo*, 8> CaptureNames;
 
   // Handle explicit captures.
   SourceLocation PrevCaptureLoc
     = Intro.Default == LCD_None? Intro.Range.getBegin() : Intro.DefaultLoc;
   for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E;
        PrevCaptureLoc = C->Loc, ++C) {
-    if (C->Kind == LCK_This) {
+    if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
       // C++11 [expr.prim.lambda]p8:
       //   An identifier or this shall not appear more than once in a 
       //   lambda-capture.
       if (LSI->isCXXThisCaptured()) {
         Diag(C->Loc, diag::err_capture_more_than_once)
             << "'this'" << SourceRange(LSI->getCXXThisCapture().getLocation())
             << FixItHint::CreateRemoval(
                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
         continue;
       }
-
+      // FIXME: Fix this comment from the wording for lambda '*this' wording.
       // C++11 [expr.prim.lambda]p8:
       //   If a lambda-capture includes a capture-default that is =, the 
       //   lambda-capture shall not contain this [...].
-      if (Intro.Default == LCD_ByCopy) {
+      if (Intro.Default == LCD_ByCopy && C->Kind != LCK_StarThis) {
         Diag(C->Loc, diag::err_this_capture_with_copy_default)
             << FixItHint::CreateRemoval(
                 SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
         continue;
       }
 
       // C++11 [expr.prim.lambda]p12:
       //   If this is captured by a local lambda expression, its nearest
       //   enclosing function shall be a non-static member function.
       QualType ThisCaptureType = getCurrentThisType();
       if (ThisCaptureType.isNull()) {
         Diag(C->Loc, diag::err_this_capture) << true;
         continue;
       }
       
-      CheckCXXThisCapture(C->Loc, /*Explicit=*/true);
+      CheckCXXThisCapture(C->Loc, /*Explicit=*/true, /*BuildAndDiagnose*/ true,
+                          /*FunctionScopeIndexToStopAtPtr*/ nullptr,
+                          C->Kind == LCK_StarThis);
       continue;
     }
 
     assert(C->Id && "missing identifier for capture");
 
     if (C->Init.isInvalid())
       continue;
 

     for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) {
       LambdaScopeInfo::Capture From = LSI->Captures[I];
       assert(!From.isBlockCapture() && "Cannot capture __block variables");
       bool IsImplicit = I >= LSI->NumExplicitCaptures;
 
       // Handle 'this' capture.
       if (From.isThisCapture()) {
         Captures.push_back(
-            LambdaCapture(From.getLocation(), IsImplicit, LCK_This));
-        CaptureInits.push_back(new (Context) CXXThisExpr(From.getLocation(),
-                                                         getCurrentThisType(),
-                                                         /*isImplicit=*/true));
+            LambdaCapture(From.getLocation(), IsImplicit,
+                          From.isStarThisCapture() ? LCK_StarThis : LCK_This));
+        CaptureInits.push_back(From.getInitExpr());
         ArrayIndexStarts.push_back(ArrayIndexVars.size());
         continue;
       }
       if (From.isVLATypeCapture()) {
         Captures.push_back(
             LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType));
         CaptureInits.push_back(nullptr);
         ArrayIndexStarts.push_back(ArrayIndexVars.size());

lib/Sema/TreeTransform.h

     // the list of explicit captures.
     if (!FinishedExplicitCaptures && C->isImplicit()) {
       getSema().finishLambdaExplicitCaptures(LSI);
       FinishedExplicitCaptures = true;
     }
 
     // Capturing 'this' is trivial.
     if (C->capturesThis()) {
-      getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit());
+      getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
+                                    /*BuildAndDiagnose*/ true, nullptr,
+                                    C->capturesStarThis());
       continue;
     }
     // Captured expression will be recaptured during captured variables
     // rebuilding.
     if (C->capturesVLAType())
       continue;
 
     // Rebuild init-captures, including the implied field declaration.

lib/Serialization/ASTReaderDecl.cpp

       = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
     Capture *ToCapture = Lambda.Captures;
     Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
       SourceLocation Loc = ReadSourceLocation(Record, Idx);
       bool IsImplicit = Record[Idx++];
       LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
       switch (Kind) {
+      case LCK_StarThis: 
       case LCK_This:
       case LCK_VLAType:
         *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
         break;
+      
       case LCK_ByCopy:
       case LCK_ByRef:
         VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
         SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
         *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
         break;
       }
     }

lib/Serialization/ASTWriter.cpp

     AddDeclRef(Lambda.ContextDecl, Record);
     AddTypeSourceInfo(Lambda.MethodTyInfo, Record);
     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
       const LambdaCapture &Capture = Lambda.Captures[I];
       AddSourceLocation(Capture.getLocation(), Record);
       Record.push_back(Capture.isImplicit());
       Record.push_back(Capture.getCaptureKind());
       switch (Capture.getCaptureKind()) {
+      case LCK_StarThis:
       case LCK_This:
       case LCK_VLAType:
         break;
       case LCK_ByCopy:
       case LCK_ByRef:
         VarDecl *Var =
             Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr;
         AddDeclRef(Var, Record);

test/CodeGenCXX/cxx1z-lambda-star-this.cpp

+// RUN: %clang_cc1 -std=c++1y -triple i686-pc-windows-msvc -emit-llvm %s -o - | FileCheck %s
+//CHECK: %[[A_LAMBDA:.*]] = type { %struct.A }
+//CHECK: %[[B_LAMBDA:.*]] = type { %struct.B* }
+struct A {
+  double a = 111;
+  auto foo() { return [*this] { return a; }; }
+};
+
+namespace ns1 {
+int X = A{}.foo()();
+} //end ns1
+
+//CHECK: @"\01?foo@A@@QAE?A?<auto>@@XZ"(%struct.A* %this, %class.anon* noalias sret %[[A_LAMBDA_RETVAL:.*]])
+// get the first object with the closure type, which is of type 'struct.A'
+//CHECK: %0 = getelementptr inbounds %[[A_LAMBDA]], %[[A_LAMBDA]]* %[[A_LAMBDA_RETVAL]], i32 0, i32 0
+//CHECK: %1 = bitcast %struct.A* %0 to i8*
+//CHECK: %2 = bitcast %struct.A* %this1 to i8*
+// copy the contents ...
+//CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %1, i8* %2, i32 8, i32 8, i1 false)
+
+struct B {
+  double b = 222;
+  auto bar() { return [this] { return b; }; };
+};
+
+namespace ns2 {
+int X = B{}.bar()();
+}
+//CHECK: @"\01?bar@B@@QAE?A?<auto>@@XZ"(%struct.B* %this, %class.anon.0* noalias sret %agg.result)
+//CHECK: %0 = getelementptr inbounds %class.anon.0, %class.anon.0* %agg.result, i32 0, i32 0
+//CHECK: store %struct.B* %this1, %struct.B** %0, align 4
 No newline at end of file

test/SemaCXX/cxx1z-lambda-star-this.cpp

+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
+
+
+namespace test_star_this {
+namespace ns1 {
+class A {
+  int x = 345;
+  auto foo() {
+    (void) [*this, this] { };  //expected-error{{'this' can appear only once}}
+    (void) [this] { ++x; };
+    (void) [*this] { ++x; };  //expected-error{{read-only variable}}
+    (void) [*this] () mutable { ++x; };
+    (void) [=] { return x; };
+    (void) [&, this] { return x; };
+    (void) [=, *this] { return x; };
+    (void) [&, *this] { return x; };
+  }
+};
+} // end ns1
+
+namespace ns2 {
+  class B {
+    B(const B&) = delete; //expected-note{{deleted here}}
+    int *x = (int *) 456;
+    void foo() {
+      (void)[this] { return x; };
+      (void)[*this] { return x; }; //expected-error{{call to deleted}}
+    }
+  };
+} // end ns2
+namespace ns3 {
+  class B {
+    B(const B&) = delete; //expected-note2{{deleted here}}
+    
+    int *x = (int *) 456;
+    public: 
+    template<class T = int>
+    void foo() {
+      (void)[this] { return x; };
+      (void)[*this] { return x; }; //expected-error2{{call to deleted}}
+    }
+    
+    B() = default;
+  } b;
+  B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
+} // end ns3
+
+namespace ns4 {
+template<class U>
+class B {
+  B(const B&) = delete; //expected-note{{deleted here}}
+  double d = 3.14;
+  public: 
+  template<class T = int>
+  auto foo() {
+    const auto &L = [*this] (auto a) mutable { //expected-error{{call to deleted}}
+      d += a; 
+      return [this] (auto b) { return d +=b; }; 
+    }; 
+  }
+  
+  B() = default;
+};
+void main() {
+  B<int*> b;
+  b.foo(); //expected-note{{in instantiation}}
+} // end main  
+} // end ns4
+} //end ns test_star_this