Kill FunctionDecl's IsCopyAssignment bit; it duplicated what could

already be determined by isCopyAssignmentOperator(), and was set too
late in the process for all clients to see the appropriate
value. Cleanup only; no functionality change.

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

diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index 1f848f7e1ce1eece5863ab8170749800dfc20210..1b1b1df7c67841285b6a07c488faa8dfb700598c 100644 (file)
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -1102,7 +1102,6 @@ private:
   bool HasWrittenPrototype : 1;
   bool IsDeleted : 1;
   bool IsTrivial : 1; // sunk from CXXMethodDecl
-  bool IsCopyAssignment : 1;  // sunk from CXXMethodDecl
   bool HasImplicitReturnZero : 1;
 
   /// \brief End part of this FunctionDecl's source range.
@@ -1182,7 +1181,6 @@ protected:
       SClass(S), SClassAsWritten(SCAsWritten), IsInline(isInline),
       IsVirtualAsWritten(false), IsPure(false), HasInheritedPrototype(false),
       HasWrittenPrototype(true), IsDeleted(false), IsTrivial(false),
-      IsCopyAssignment(false),
       HasImplicitReturnZero(false),
       EndRangeLoc(NameInfo.getEndLoc()),
       TemplateOrSpecialization(),
@@ -1291,9 +1289,6 @@ public:
   bool isTrivial() const { return IsTrivial; }
   void setTrivial(bool IT) { IsTrivial = IT; }
 
-  bool isCopyAssignment() const { return IsCopyAssignment; }
-  void setCopyAssignment(bool CA) { IsCopyAssignment = CA; }
-
   /// Whether falling off this function implicitly returns null/zero.
   /// If a more specific implicit return value is required, front-ends
   /// should synthesize the appropriate return statements.

diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp
index 1b89ab6bedaa7fd3e0b3e5f56dc4dfe778b42d90..bf1e58c7c964642b28c38593b02a1b142757746d 100644 (file)
--- a/lib/AST/DeclCXX.cpp
+++ b/lib/AST/DeclCXX.cpp
@@ -284,10 +284,8 @@ CXXRecordDecl::addedMember(Decl *D) {
       // If this is the implicit copy constructor, note that we have now
       // declared it.
       // FIXME: Move constructors
-      if (Method->getOverloadedOperator() == OO_Equal) {
+      if (Method->getOverloadedOperator() == OO_Equal)
         data().DeclaredCopyAssignment = true;
-        Method->setCopyAssignment(true);
-      }
     }
     
     // Nothing else to do for implicitly-declared members.
@@ -359,8 +357,7 @@ CXXRecordDecl::addedMember(Decl *D) {
         return;
       
       // This is a copy assignment operator.
-      // Note on the decl that it is a copy assignment operator.
-      Method->setCopyAssignment(true);
+      // FIXME: Move assignment operators.
       
       // Suppress the implicit declaration of a copy constructor.
       data().UserDeclaredCopyAssignment = true;

diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp
index aadceff8be5c7e36f56d0eda17cc9bb287f8186e..68f40583892c7fc67096469b3a4976a65cfeaba9 100644 (file)
--- a/lib/CodeGen/CGExprCXX.cpp
+++ b/lib/CodeGen/CGExprCXX.cpp
@@ -114,7 +114,7 @@ RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
   if (MD->isTrivial()) {
     if (isa<CXXDestructorDecl>(MD)) return RValue::get(0);
 
-    assert(MD->isCopyAssignment() && "unknown trivial member function");
+    assert(MD->isCopyAssignmentOperator() && "unknown trivial member function");
     // We don't like to generate the trivial copy assignment operator when
     // it isn't necessary; just produce the proper effect here.
     llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
@@ -211,7 +211,7 @@ CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
                                                ReturnValueSlot ReturnValue) {
   assert(MD->isInstance() &&
          "Trying to emit a member call expr on a static method!");
-  if (MD->isCopyAssignment()) {
+  if (MD->isCopyAssignmentOperator()) {
     const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext());
     if (ClassDecl->hasTrivialCopyAssignment()) {
       assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&

diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp
index f5ba76c1b9dcdd9a894c0e9ae485aed2f14705da..805b33e32472ff6a772c6acf3687e0c09ff825cb 100644 (file)
--- a/lib/CodeGen/CodeGenModule.cpp
+++ b/lib/CodeGen/CodeGenModule.cpp
@@ -867,7 +867,7 @@ CodeGenModule::GetOrCreateLLVMFunction(llvm::StringRef MangledName,
         DeferredDeclsToEmit.push_back(D);
       }
     } else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
-      if (MD->isCopyAssignment() && MD->isImplicit()) {
+      if (MD->isImplicit() && MD->isCopyAssignmentOperator()) {
         assert(MD->isUsed() && "Sema doesn't consider CopyAssignment as used.");
         DeferredDeclsToEmit.push_back(D);
       }

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 48beca71cf01c97efc6ddd5748d1cf4be0facb35..d5d01485941c9c8695ebc97176ab23a07ca8a24d 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -1063,7 +1063,8 @@ Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
   if (isa<CXXDestructorDecl>(MD))
     return Sema::CXXDestructor;
   
-  assert(MD->isCopyAssignment() && "Must have copy assignment operator");
+  assert(MD->isCopyAssignmentOperator() && 
+         "Must have copy assignment operator");
   return Sema::CXXCopyAssignment;
 }
 

diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 92655da609f75da279ad4cc63964656c946588ff..b540f8d43bd8101887973c18c2940edfc2f7a876 100644 (file)
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -4930,7 +4930,6 @@ CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
   CopyAssignment->setAccess(AS_public);
   CopyAssignment->setImplicit();
   CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
-  CopyAssignment->setCopyAssignment(true);
   
   // Add the parameter to the operator.
   ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index 696e5b289c9a519a13d4dccbea8bdc1731e4e4b1..a7e5e3ae71574e14454ef79b0c8bc1138a49d2b1 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -5525,7 +5525,7 @@ OverloadCandidateKind ClassifyOverloadCandidate(Sema &S,
     if (!Meth->isImplicit())
       return isTemplate ? oc_method_template : oc_method;
 
-    assert(Meth->isCopyAssignment()
+    assert(Meth->isCopyAssignmentOperator()
            && "implicit method is not copy assignment operator?");
     return oc_implicit_copy_assignment;
   }

diff --git a/lib/Serialization/ASTReaderDecl.cpp b/lib/Serialization/ASTReaderDecl.cpp
index e5a87b0c109ef0c536946b09a7745d8687dc7640..d51d5162b28b921e58a28e4d8567b1326b652c02 100644 (file)
--- a/lib/Serialization/ASTReaderDecl.cpp
+++ b/lib/Serialization/ASTReaderDecl.cpp
@@ -346,7 +346,6 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->setHasWrittenPrototype(Record[Idx++]);
   FD->setDeleted(Record[Idx++]);
   FD->setTrivial(Record[Idx++]);
-  FD->setCopyAssignment(Record[Idx++]);
   FD->setHasImplicitReturnZero(Record[Idx++]);
   FD->setLocEnd(SourceLocation::getFromRawEncoding(Record[Idx++]));
 

diff --git a/lib/Serialization/ASTWriterDecl.cpp b/lib/Serialization/ASTWriterDecl.cpp
index 76974667a8928277e5dc6a7766a91525a1630cc9..f8d584bb51cf26824d56c5562c763d338b945008 100644 (file)
--- a/lib/Serialization/ASTWriterDecl.cpp
+++ b/lib/Serialization/ASTWriterDecl.cpp
@@ -296,7 +296,6 @@ void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.push_back(D->hasWrittenPrototype());
   Record.push_back(D->isDeleted());
   Record.push_back(D->isTrivial());
-  Record.push_back(D->isCopyAssignment());
   Record.push_back(D->hasImplicitReturnZero());
   Writer.AddSourceLocation(D->getLocEnd(), Record);