AddInitializerToDecl can't take a FullExprArg. Make it take an ExprArg, and create...

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@79176 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h
index cef378f558c8618254bfaaf31b25442ffb253351..870613998822977d7dfe16cbe740c0c59f64e55b 100644 (file)
--- a/include/clang/Parse/Action.h
+++ b/include/clang/Parse/Action.h
@@ -310,7 +310,7 @@ public:
   /// This allows ActOnDeclarator to register "xx" prior to parsing the
   /// initializer. The declaration above should still result in a warning, 
   /// since the reference to "xx" is uninitialized.
-  virtual void AddInitializerToDecl(DeclPtrTy Dcl, FullExprArg Init) {
+  virtual void AddInitializerToDecl(DeclPtrTy Dcl, ExprArg Init) {
     return;
   }
 

diff --git a/lib/Frontend/PrintParserCallbacks.cpp b/lib/Frontend/PrintParserCallbacks.cpp
index 2101a85f4113c3e65e016cb657ab133bed781fef..9d6ea73eefb1fed89614318b97d54116ab0f9e8b 100644 (file)
--- a/lib/Frontend/PrintParserCallbacks.cpp
+++ b/lib/Frontend/PrintParserCallbacks.cpp
@@ -109,7 +109,7 @@ namespace {
     /// This allows ActOnDeclarator to register "xx" prior to parsing the
     /// initializer. The declaration above should still result in a warning, 
     /// since the reference to "xx" is uninitialized.
-    virtual void AddInitializerToDecl(DeclPtrTy Dcl, FullExprArg Init) {
+    virtual void AddInitializerToDecl(DeclPtrTy Dcl, ExprArg Init) {
       Out << __FUNCTION__ << "\n";
     }
 

diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 029d9b5aaec7e99b94b83c6ee8e16577a7a1be9f..9958bdf5668637dc971d4631d73e39a0cad1a482 100644 (file)
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -446,7 +446,7 @@ Parser::DeclPtrTy Parser::ParseDeclarationAfterDeclarator(Declarator &D,
         SkipUntil(tok::semi, true, true);
         return DeclPtrTy();
       }
-      Actions.AddInitializerToDecl(ThisDecl, Actions.FullExpr(Init));
+      Actions.AddInitializerToDecl(ThisDecl, move(Init));
     }
   } else if (Tok.is(tok::l_paren)) {
     // Parse C++ direct initializer: '(' expression-list ')'

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index d17e2f149894f754d551d0a4d7461650f2294b99..d3bdec8f39edc7b49e7620d1c5454acb3af55c24 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -503,7 +503,7 @@ public:
   // argument locations.
   llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
 
-  virtual void AddInitializerToDecl(DeclPtrTy dcl, FullExprArg init);
+  virtual void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init);
   void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
   void ActOnUninitializedDecl(DeclPtrTy dcl, bool TypeContainsUndeducedAuto);
   virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
@@ -1689,15 +1689,17 @@ public:
                                     CXXConstructorDecl *Constructor,
                                     QualType DeclInitType, 
                                     Expr **Exprs, unsigned NumExprs);
-  
+
+  Expr *BuildCXXConstructExpr(QualType DeclInitType,
+                              CXXConstructorDecl *Constructor,
+                              Expr **Exprs, unsigned NumExprs);
+
   /// BuildCXXConstructExpr - Creates a complete call to a constructor,
   /// including handling of its default argument expressions.
   Expr *BuildCXXConstructExpr(QualType DeclInitType,
                               CXXConstructorDecl *Constructor,
                               bool Elidable,
                               Expr **Exprs, unsigned NumExprs);
-
-  Expr *BuildCXXCopyConstructExpr(Expr *Expr);
   
   /// FinalizeVarWithDestructor - Prepare for calling destructor on the
   /// constructed variable.

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index bf1dd91f74bb6925ae07008a5fd917a91c9707e6..b672d0501a0498dbc69f6bed6403a62e41cda40b 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -2996,8 +2996,8 @@ bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
   return true;
 }
 
-void Sema::AddInitializerToDecl(DeclPtrTy dcl, FullExprArg init) {
-  AddInitializerToDecl(dcl, init.release(), /*DirectInit=*/false);
+void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
+  AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
 }
 
 /// AddInitializerToDecl - Adds the initializer Init to the
@@ -3160,6 +3160,8 @@ void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
     Init->setType(DclT);
   }
     
+  Init = MaybeCreateCXXExprWithTemporaries(Init, 
+                                           /*ShouldDestroyTemporaries=*/true);
   // Attach the initializer to the decl.
   VDecl->setInit(Context, Init);
 

diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index d460950824e1cc2720a79c9133d74279f1840245..068978cd92691d919c3f47c8c858c1fc1d52ce95 100644 (file)
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -2377,6 +2377,32 @@ void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
   CopyConstructor->setUsed();
 }
 
+Expr *Sema::BuildCXXConstructExpr(QualType DeclInitType,
+                                  CXXConstructorDecl *Constructor,
+                                  Expr **Exprs, unsigned NumExprs) {
+  bool Elidable = false;
+  
+  // [class.copy]p15:
+  // Whenever a temporary class object is copied using a copy constructor, and 
+  // this object and the copy have the same cv-unqualified type, an 
+  // implementation is permitted to treat the original and the copy as two
+  // different ways of referring to the same object and not perform a copy at
+  //all, even if the class copy constructor or destructor have side effects.
+  
+  // FIXME: Is this enough?
+  if (Constructor->isCopyConstructor(Context) && NumExprs == 1) {
+    Expr *E = Exprs[0];
+    while (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
+      E = BE->getSubExpr();
+    
+    if (isa<CallExpr>(E) || isa<CXXTemporaryObjectExpr>(E))
+      Elidable = true;
+  }
+  
+  return BuildCXXConstructExpr(DeclInitType, Constructor, Elidable,
+                               Exprs, NumExprs);
+}
+
 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
 /// including handling of its default argument expressions.
 Expr *Sema::BuildCXXConstructExpr(QualType DeclInitType, 
@@ -2413,7 +2439,7 @@ void Sema::InitializeVarWithConstructor(VarDecl *VD,
                                         QualType DeclInitType, 
                                         Expr **Exprs, unsigned NumExprs) {
   Expr *Temp = BuildCXXConstructExpr(DeclInitType, Constructor, 
-                                     false, Exprs, NumExprs);  
+                                     Exprs, NumExprs);  
   MarkDeclarationReferenced(VD->getLocation(), Constructor);
   Temp = MaybeCreateCXXExprWithTemporaries(Temp, /*DestroyTemps=*/true);
   VD->setInit(Context, Temp);

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 274893b99e9f4684762180a3a934936f087f912f..f313c5653e85a9d2620e394910b78fe6d01cb7d1 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -902,11 +902,7 @@ Sema::PerformImplicitConversion(Expr *&From, QualType ToType,
     // FIXME: When can ToType be a reference type?
     assert(!ToType->isReferenceType());
     
-    // FIXME: Keep track of whether the copy constructor is elidable or not.
-    bool Elidable = (isa<CallExpr>(From) || 
-                     isa<CXXTemporaryObjectExpr>(From));
-    From = BuildCXXConstructExpr(ToType, SCS.CopyConstructor, 
-                                 Elidable, &From, 1);
+    From = BuildCXXConstructExpr(ToType, SCS.CopyConstructor, &From, 1);
     return false;
   }
 

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index f734d9347ace5a1bfe7be4f3cbb8615152e67711..ce6a99acd9daff3970fc4a436c8a991675f816f9 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -176,10 +176,7 @@ bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType,
                                              DirectInit? IK_Direct : IK_Copy);
         if (!Constructor)
           return true;
-        bool Elidable = (isa<CallExpr>(Init) || 
-                         isa<CXXTemporaryObjectExpr>(Init));
-        Init = BuildCXXConstructExpr(DeclType, Constructor, Elidable, &Init, 1);
-        Init = MaybeCreateCXXExprWithTemporaries(Init, /*DestroyTemps=*/true);
+        Init = BuildCXXConstructExpr(DeclType, Constructor, &Init, 1);
         return false;
       }