Clang cleanup for -Wdeprecated-copy

[kristina]

Linking to D52863 and adding a reviewer from it.

[dexonsmith]

Thanks for working on this. However, it seems to be introducing the same sorts of problems (dropping vtable anchors) as the revision you've linked to. We should be adding vtable anchors, not removing them.

include/clang/Tooling/Refactoring/RefactoringActionRule.h

39

Even better would be to create a vtable anchor for this in the source file.

include/clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h

84

Even better would be to create a vtable anchor for this in the source file.

lib/AST/DeclBase.cpp

292–294

This is removing a vtable anchor. Please undo this change.

include/clang/AST/DeclBase.h

Decl(Kind DK, EmptyShell Empty)
       : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
         Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
         Access(AS_none), FromASTFile(0),
         IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
         CacheValidAndLinkage(0) {
     if (StatisticsEnabled) add(DK);
   }
 
-  virtual ~Decl();
+  virtual ~Decl() = default;
 
   /// Update a potentially out-of-date declaration.
   void updateOutOfDate(IdentifierInfo &II) const;
 
   Linkage getCachedLinkage() const {
     return Linkage(CacheValidAndLinkage - 1);
   }
 

include/clang/Sema/ObjCMethodList.h

struct ObjCMethodList {
   /// If there is more than one decl with this signature.
   llvm::PointerIntPair<ObjCMethodDecl *, 1> MethodAndHasMoreThanOneDecl;
   /// The next list object and 2 bits for extra info.
   llvm::PointerIntPair<ObjCMethodList *, 2> NextAndExtraBits;
 
   ObjCMethodList() { }
   ObjCMethodList(ObjCMethodDecl *M)
       : MethodAndHasMoreThanOneDecl(M, 0) {}
-  ObjCMethodList(const ObjCMethodList &L)
-      : MethodAndHasMoreThanOneDecl(L.MethodAndHasMoreThanOneDecl),
-        NextAndExtraBits(L.NextAndExtraBits) {}
+  ObjCMethodList(const ObjCMethodList &L) = default;
+  ObjCMethodList &operator=(const ObjCMethodList &L) = default;
 
   ObjCMethodList *getNext() const { return NextAndExtraBits.getPointer(); }
   unsigned getBits() const { return NextAndExtraBits.getInt(); }
   void setNext(ObjCMethodList *L) { NextAndExtraBits.setPointer(L); }
   void setBits(unsigned B) { NextAndExtraBits.setInt(B); }
 
   ObjCMethodDecl *getMethod() const {
     return MethodAndHasMoreThanOneDecl.getPointer();

include/clang/Sema/Sema.h

enum Kind {
       /// Create a deferred diagnostic, which is emitted only if the function
       /// it's attached to is codegen'ed.  Also emit a call stack as with
       /// K_ImmediateWithCallStack.
       K_Deferred
     };
 
     CUDADiagBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
                     FunctionDecl *Fn, Sema &S);
+    CUDADiagBuilder(const CUDADiagBuilder &) = default;
     ~CUDADiagBuilder();
 
     /// Convertible to bool: True if we immediately emitted an error, false if
     /// we didn't emit an error or we created a deferred error.
     ///
     /// Example usage:
     ///
     ///   if (CUDADiagBuilder(...) << foo << bar)

include/clang/Tooling/Refactoring/RefactoringActionRule.h

struct RefactoringDescriptor {
   StringRef Description;
 };
 
 /// A common refactoring action rule interface that defines the 'invoke'
 /// function that performs the refactoring operation (either fully or
 /// partially).
 class RefactoringActionRuleBase {
 public:
-  virtual ~RefactoringActionRuleBase() {}
+  virtual ~RefactoringActionRuleBase() = default;
 
   /// Initiates and performs a specific refactoring action.
   ///
   /// The specific rule will invoke an appropriate \c handle method on a
   /// consumer to propagate the result of the refactoring action.
   virtual void invoke(RefactoringResultConsumer &Consumer,
                       RefactoringRuleContext &Context) = 0;
 

include/clang/Tooling/Refactoring/RefactoringActionRuleRequirements.h

 public:
   Expected<CodeRangeASTSelection>
   evaluate(RefactoringRuleContext &Context) const;
 };
 
 /// A base class for any requirement that requires some refactoring options.
 class RefactoringOptionsRequirement : public RefactoringActionRuleRequirement {
 public:
-  virtual ~RefactoringOptionsRequirement() {}
+  virtual ~RefactoringOptionsRequirement() = default;
 
   /// Returns the set of refactoring options that are used when evaluating this
   /// requirement.
   virtual ArrayRef<std::shared_ptr<RefactoringOption>>
   getRefactoringOptions() const = 0;
 };
 
 /// A requirement that evaluates to the value of the given \c OptionType when

lib/AST/DeclBase.cpp

void PrettyStackTraceDecl::print(raw_ostream &OS) const {
   }
   OS << '\n';
 }
 
 //===----------------------------------------------------------------------===//
 // Decl Implementation
 //===----------------------------------------------------------------------===//
 
-// Out-of-line virtual method providing a home for Decl.
-Decl::~Decl() = default;
-
 void Decl::setDeclContext(DeclContext *DC) {
   DeclCtx = DC;
 }
 
 void Decl::setLexicalDeclContext(DeclContext *DC) {
   if (DC == getLexicalDeclContext())
     return;