[clang] Add fix-it note to defaulted-function-deleted warning

[njames93]

Summary

Adds a fix to the diagnostic of replacing the = default to = delete

[aaron.ballman]

Thank you for this, I think it's a good idea! Can you also add a release note for the changes?

This mostly LG to me but I did spot one thing I was curious about.

clang/lib/Serialization/ASTWriterDecl.cpp

2293

Should this be using 6 instead of 3 as with the other location fields? (InnerLocStart, LocEnd) And if so, we should probably add some test coverage for this bit.

[njames93]

clang/lib/Serialization/ASTWriterDecl.cpp

2293

Whoops, Yes you're right, 6 is above 3 on on number keyboard. Technically it shouldn't make any functional change, just that the field may be expressed in more bits.

[njames93]

Add release notes and fix issue in ASTWriterDecl.

[njames93]

Rebase fixing merge conflicts.

[martong]

clang/lib/AST/ASTImporter.cpp

3707

This should be imported very similarly to EndLoc.

[aaron.ballman]

LGTM, though please address the concern by @martong before landing. Thank you!

[njames93]

Address @martong's comment.

[njames93]

Rebase to trunk

clang/docs/ReleaseNotes.rst

 - Correctly diagnose use of an integer literal without a suffix whose
   underlying type is ``long long`` or ``unsigned long long`` as an extension in
   C89 mode . Clang previously only diagnosed if the literal had an explicit
   ``LL`` suffix.
 - Clang now correctly diagnoses index that refers past the last possible element
   of FAM-like arrays.
 - Clang now correctly diagnoses a warning when defercencing a void pointer in C mode.
   This fixes `Issue 53631 <https://github.com/llvm/llvm-project/issues/53631>`_
+- Add a fix-it hint for the ``-Wdefaulted-function-deleted`` warning to
+  explicitly delete the function.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - It's now possible to set the crash diagnostics directory through
   the environment variable ``CLANG_CRASH_DIAGNOSTICS_DIR``.
   The ``-fcrash-diagnostics-dir`` flag takes precedence.
 - When using header modules, inclusion of a private header and violations of
   the `use-declaration rules

clang/include/clang/AST/Decl.h

private:
   ///
   /// We could compute the full range in getSourceRange(). However, when we're
   /// dealing with a function definition deserialized from a PCH/AST file,
   /// we can only compute the full range once the function body has been
   /// de-serialized, so it's far better to have the (sometimes-redundant)
   /// EndRangeLoc.
   SourceLocation EndRangeLoc;
 
+  SourceLocation DefaultKWLoc;
+
   /// The template or declaration that this declaration
   /// describes or was instantiated from, respectively.
   ///
   /// For non-templates this value will be NULL, unless this declaration was
   /// declared directly inside of a function template, in which case it will
   /// have a pointer to a FunctionDecl, stored in the NamedDecl. For function
   /// declarations that describe a function template, this will be a pointer to
   /// a FunctionTemplateDecl, stored in the NamedDecl. For member functions of
bool isExplicitlyDefaulted() const {
     return FunctionDeclBits.IsExplicitlyDefaulted;
   }
 
   /// State that this function is explicitly defaulted.
   void setExplicitlyDefaulted(bool ED = true) {
     FunctionDeclBits.IsExplicitlyDefaulted = ED;
   }
 
+  SourceLocation getDefaultLoc() const {
+    return isExplicitlyDefaulted() ? DefaultKWLoc : SourceLocation();
+  }
+
+  void setDefaultLoc(SourceLocation NewLoc) {
+    assert(NewLoc.isInvalid() ||
+           isExplicitlyDefaulted() &&
+               "Can't set default loc is function isn't explicitly defaulted");
+    DefaultKWLoc = NewLoc;
+  }
+
   /// True if this method is user-declared and was not
   /// deleted or defaulted on its first declaration.
   bool isUserProvided() const {
     auto *DeclAsWritten = this;
     if (FunctionDecl *Pattern = getTemplateInstantiationPattern())
       DeclAsWritten = Pattern;
     return !(DeclAsWritten->isDeleted() ||
              DeclAsWritten->getCanonicalDecl()->isDefaulted());

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_incorrect_defaulted_constexpr : Error<
   "defaulted definition of %sub{select_special_member_kind}0 "
   "is not constexpr">;
 def err_incorrect_defaulted_consteval : Error<
   "defaulted declaration of %sub{select_special_member_kind}0 "
   "cannot be consteval because implicit definition is not constexpr">;
 def warn_defaulted_method_deleted : Warning<
   "explicitly defaulted %sub{select_special_member_kind}0 is implicitly "
   "deleted">, InGroup<DefaultedFunctionDeleted>;
+def note_replace_equals_default_to_delete : Note<
+  "replace 'default' with 'delete'">;
 def err_out_of_line_default_deletes : Error<
   "defaulting this %sub{select_special_member_kind}0 "
   "would delete it after its first declaration">;
 def note_deleted_type_mismatch : Note<
   "function is implicitly deleted because its declared type does not match "
   "the type of an implicit %sub{select_special_member_kind}0">;
 def warn_cxx17_compat_defaulted_method_type_mismatch : Warning<
   "explicitly defaulting this %sub{select_special_member_kind}0 with a type "

clang/include/clang/Sema/Sema.h

public:
   Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
   void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
                                      StorageClass &SC);
   void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
 
   void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD);
 
   bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
-                                             CXXSpecialMember CSM);
+                                             CXXSpecialMember CSM,
+                                             SourceLocation DefaultLoc);
   void CheckDelayedMemberExceptionSpecs();
 
   bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD,
                                           DefaultedComparisonKind DCK);
   void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,
                                          FunctionDecl *Spaceship);
   void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,
                                  DefaultedComparisonKind DCK);

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   ToFunction->setTrivial(D->isTrivial());
   ToFunction->setPure(D->isPure());
   ToFunction->setDefaulted(D->isDefaulted());
   ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
   ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
   ToFunction->setFriendConstraintRefersToEnclosingTemplate(
       D->FriendConstraintRefersToEnclosingTemplate());
   ToFunction->setRangeEnd(ToEndLoc);
+  ToFunction->setDefaultLoc(D->getDefaultLoc());
 
   // Set the parameters.
   for (auto *Param : Parameters) {
     Param->setOwningFunction(ToFunction);
     ToFunction->addDeclInternal(Param);
     if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
       LT->update(Param, Importer.getToContext().getTranslationUnitDecl());
   }

clang/lib/Sema/SemaDeclCXX.cpp

if (!DefKind) {
     return;
   }
 
   if (DefKind.isComparison())
     UnusedPrivateFields.clear();
 
   if (DefKind.isSpecialMember()
           ? CheckExplicitlyDefaultedSpecialMember(cast<CXXMethodDecl>(FD),
-                                                  DefKind.asSpecialMember())
+                                                  DefKind.asSpecialMember(),
+                                                  FD->getDefaultLoc())
           : CheckExplicitlyDefaultedComparison(S, FD, DefKind.asComparison()))
     FD->setInvalidDecl();
 }
 
 bool Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
-                                                 CXXSpecialMember CSM) {
+                                                 CXXSpecialMember CSM,
+                                                 SourceLocation DefaultLoc) {
   CXXRecordDecl *RD = MD->getParent();
 
   assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
          "not an explicitly-defaulted special member");
 
   // Defer all checking for special members of a dependent type.
   if (RD->isDependentType())
     return false;
bool Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
 
   if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {
     if (First) {
       SetDeclDeleted(MD, MD->getLocation());
       if (!inTemplateInstantiation() && !HadError) {
         Diag(MD->getLocation(), diag::warn_defaulted_method_deleted) << CSM;
         if (ShouldDeleteForTypeMismatch) {
           Diag(MD->getLocation(), diag::note_deleted_type_mismatch) << CSM;
-        } else {
-          ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
+        } else if (ShouldDeleteSpecialMember(MD, CSM, nullptr,
+                                             /*Diagnose*/ true) &&
+                   DefaultLoc.isValid()) {
+          Diag(DefaultLoc, diag::note_replace_equals_default_to_delete)
+              << FixItHint::CreateReplacement(DefaultLoc, "delete");
         }
       }
       if (ShouldDeleteForTypeMismatch && !HadError) {
         Diag(MD->getLocation(),
              diag::warn_cxx17_compat_defaulted_method_type_mismatch) << CSM;
       }
     } else {
       // C++11 [dcl.fct.def.default]p4:
if (Info.Deleted) {
 
     SetDeclDeleted(FD, FD->getLocation());
     if (!inTemplateInstantiation() && !FD->isImplicit()) {
       Diag(FD->getLocation(), diag::warn_defaulted_comparison_deleted)
           << (int)DCK;
       DefaultedComparisonAnalyzer(*this, RD, FD, DCK,
                                   DefaultedComparisonAnalyzer::ExplainDeleted)
           .visit();
+      if (FD->getDefaultLoc().isValid())
+        Diag(FD->getDefaultLoc(), diag::note_replace_equals_default_to_delete)
+            << FixItHint::CreateReplacement(FD->getDefaultLoc(), "delete");
     }
     return false;
   }
 
   // C++2a [class.spaceship]p2:
   //   The return type is deduced as the common comparison type of R0, R1, ...
   if (DCK == DefaultedComparisonKind::ThreeWay &&
       FD->getDeclaredReturnType()->isUndeducedAutoType()) {
if (DefKind.isComparison() &&
       DefKind.asComparison() != DefaultedComparisonKind::ThreeWay) {
     Diag(DefaultLoc, getLangOpts().CPlusPlus20
                          ? diag::warn_cxx17_compat_defaulted_comparison
                          : diag::ext_defaulted_comparison);
   }
 
   FD->setDefaulted();
   FD->setExplicitlyDefaulted();
+  FD->setDefaultLoc(DefaultLoc);
 
   // Defer checking functions that are defaulted in a dependent context.
   if (FD->isDependentContext())
     return;
 
   // Unset that we will have a body for this function. We might not,
   // if it turns out to be trivial, and we don't need this marking now
   // that we've marked it as defaulted.
void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
   if (DefKind.isComparison()) {
     if (CheckExplicitlyDefaultedComparison(nullptr, FD, DefKind.asComparison()))
       FD->setInvalidDecl();
     else
       DefineDefaultedComparison(DefaultLoc, FD, DefKind.asComparison());
   } else {
     auto *MD = cast<CXXMethodDecl>(FD);
 
-    if (CheckExplicitlyDefaultedSpecialMember(MD, DefKind.asSpecialMember()))
+    if (CheckExplicitlyDefaultedSpecialMember(MD, DefKind.asSpecialMember(),
+                                              DefaultLoc))
       MD->setInvalidDecl();
     else
       DefineDefaultedFunction(*this, MD, DefaultLoc);
   }
 }
 
 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
   for (Stmt *SubStmt : S->children()) {

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->setUsesSEHTry(Record.readInt());
   FD->setHasSkippedBody(Record.readInt());
   FD->setIsMultiVersion(Record.readInt());
   FD->setLateTemplateParsed(Record.readInt());
   FD->setFriendConstraintRefersToEnclosingTemplate(Record.readInt());
 
   FD->setCachedLinkage(static_cast<Linkage>(Record.readInt()));
   FD->EndRangeLoc = readSourceLocation();
+  FD->setDefaultLoc(readSourceLocation());
 
   FD->ODRHash = Record.readInt();
   FD->setHasODRHash(true);
 
   if (FD->isDefaulted()) {
     if (unsigned NumLookups = Record.readInt()) {
       SmallVector<DeclAccessPair, 8> Lookups;
       for (unsigned I = 0; I != NumLookups; ++I) {

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.push_back(static_cast<uint64_t>(D->getConstexprKind()));
   Record.push_back(D->usesSEHTry());
   Record.push_back(D->hasSkippedBody());
   Record.push_back(D->isMultiVersion());
   Record.push_back(D->isLateTemplateParsed());
   Record.push_back(D->FriendConstraintRefersToEnclosingTemplate());
   Record.push_back(D->getLinkageInternal());
   Record.AddSourceLocation(D->getEndLoc());
+  Record.AddSourceLocation(D->getDefaultLoc());
 
   Record.push_back(D->getODRHash());
 
   if (D->isDefaulted()) {
     if (auto *FDI = D->getDefaultedFunctionInfo()) {
       Record.push_back(FDI->getUnqualifiedLookups().size());
       for (DeclAccessPair P : FDI->getUnqualifiedLookups()) {
         Record.AddDeclRef(P.getDecl());
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Constexpr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FriendConstraintRefersToEnclosingTemplate
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LocEnd
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Default/DeleteLoc
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
   // This Array slurps the rest of the record. Fortunately we want to encode
   // (nearly) all the remaining (variable number of) fields in the same way.
   //
   // This is the function template information if any, then
   //         NumParams and Params[] from FunctionDecl, and
   //         NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.

clang/test/CXX/class.derived/class.abstract/p16.cpp

 // expected-note@-4 {{copy assignment operator of 'E' is implicitly deleted because base class 'D' has an inaccessible copy assignment operator}}
 struct F : D {};
 struct G : D {};
 // expected-error@-1 {{deleted function '~G' cannot override a non-deleted function}}
 // expected-note@-2 {{destructor of 'G' is implicitly deleted because base class 'D' has an inaccessible destructor}}
 // expected-error@-3 {{deleted function 'operator=' cannot override a non-deleted function}}
 // expected-note@-4 {{move assignment operator of 'G' is implicitly deleted because base class 'D' has an inaccessible move assignment operator}}
 struct H : D { // expected-note {{deleted because base class 'D' has an inaccessible move assignment}}
-  H &operator=(H&&) = default; // expected-warning {{implicitly deleted}}
+  H &operator=(H&&) = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   // expected-error@-1 {{deleted function 'operator=' cannot override a non-deleted function}}
   // expected-note@-3 {{move assignment operator of 'H' is implicitly deleted because base class 'D' has an inaccessible move assignment operator}}
   ~H();
 };

clang/test/CXX/class/class.compare/class.compare.default/p1.cpp

 // RUN: %clang_cc1 -std=c++2a -verify %s
 
 struct B {};
 
 template<typename T = void>
   bool operator<(const B&, const B&) = default; // expected-error {{comparison operator template cannot be defaulted}}
 
 struct A {
   friend bool operator==(const A&, const A&) = default;
   friend bool operator!=(const A&, const B&) = default; // expected-error {{parameters for defaulted equality comparison operator must have the same type (found 'const A &' vs 'const B &')}}
   friend bool operator!=(const B&, const B&) = default; // expected-error {{invalid parameter type for defaulted equality comparison}}
   friend bool operator<(const A&, const A&);
   friend bool operator<(const B&, const B&) = default; // expected-error {{invalid parameter type for defaulted relational comparison}}
-  friend bool operator>(A, A) = default; // expected-warning {{implicitly deleted}}
+  friend bool operator>(A, A) = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
 
   bool operator<(const A&) const;
   bool operator<=(const A&) const = default;
   bool operator==(const A&) const volatile && = default; // surprisingly, OK
   bool operator<=>(const A&) = default; // expected-error {{defaulted member three-way comparison operator must be const-qualified}}
   bool operator>=(const B&) const = default; // expected-error-re {{invalid parameter type for defaulted relational comparison operator; found 'const B &', expected 'const A &'{{$}}}}
   static bool operator>(const B&) = default; // expected-error {{overloaded 'operator>' cannot be a static member function}}
   friend bool operator>(A, const A&) = default; // expected-error {{must have the same type}} expected-note {{would be the best match}}
auto h() {
       bool operator!=(const B&, const B&); // expected-note 2{{best match}}
       std::strong_ordering operator<=>(const B&, const B&);
       bool operator<(const B&, const B&); // expected-note 2{{best match}}
       bool operator<=(const B&, const B&); // expected-note 2{{best match}}
       bool operator>(const B&, const B&); // expected-note 2{{best match}}
       bool operator>=(const B&, const B&); // expected-note 2{{best match}}
 
       struct B {
-        bool operator!=(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}}
-        bool operator<(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}}
-        bool operator<=(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}}
-        bool operator>(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}}
-        bool operator>=(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}}
+        bool operator!=(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}} expected-note{{replace 'default'}}
+        bool operator<(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}} expected-note{{replace 'default'}}
+        bool operator<=(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}} expected-note{{replace 'default'}}
+        bool operator>(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}} expected-note{{replace 'default'}}
+        bool operator>=(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note {{deleted here}} expected-note{{replace 'default'}}
       };
       return B();
     }
   }
 
   namespace M {
     bool operator==(const A &, const A &) = delete;
     bool operator<(const A &, const A &) = delete;

 
 namespace P1946 {
   struct A {
     friend bool operator==(A &, A &); // expected-note {{would lose const qualifier}}
   };
   struct B {
     A a; // expected-note {{no viable three-way comparison}}
     friend bool operator==(B, B) = default; // ok
-    friend bool operator==(const B&, const B&) = default; // expected-warning {{deleted}}
+    friend bool operator==(const B&, const B&) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 }
 
 namespace p2085 {
 // out-of-class defaulting
 
 struct S1 {
   bool operator==(S1 const &) const;

clang/test/CXX/class/class.compare/class.compare.default/p2.cpp

 // RUN: %clang_cc1 -std=c++2a -verify %s
 
 struct A1 {
   int x;
   int &y; // expected-note 9{{because class 'A1' has a reference member}}
 
-  bool operator==(const A1&) const = default; // expected-warning {{implicitly deleted}} expected-note 2{{deleted here}}
-  bool operator<=>(const A1&) const = default; // expected-warning {{implicitly deleted}} expected-note 5{{deleted here}}
+  bool operator==(const A1&) const = default; // expected-warning {{implicitly deleted}} expected-note 2{{deleted here}} expected-note{{replace 'default'}}
+  bool operator<=>(const A1&) const = default; // expected-warning {{implicitly deleted}} expected-note 5{{deleted here}} expected-note{{replace 'default'}}
 };
 struct A2 {
   int x;
   int &y;
 
   bool operator==(const A2&) const;
   bool operator!=(const A2&) const = default;
 
void f(A2 a) {
   void(a <= a);
   void(a > a);
   void(a >= a);
 }
 
 struct A3 {
   int &x; // expected-note {{because class 'A3' has a reference member}}
 
-  bool operator==(const A3 &) const = default; // expected-warning {{implicitly deleted}}
-  bool operator<(const A3 &) const = default;  // expected-warning {{implicitly deleted}}
+  bool operator==(const A3 &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
+  bool operator<(const A3 &) const = default;  // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{because there is no viable three-way comparison function for 'A3'}}
 };
 
 struct B1 {
   struct {
     int x;
     int &y; // expected-note 2{{because class 'B1' has a reference member}}
   };
 
-  bool operator==(const B1&) const = default; // expected-warning {{implicitly deleted}}
-  bool operator<=>(const B1&) const = default; // expected-warning {{implicitly deleted}}
+  bool operator==(const B1&) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
+  bool operator<=>(const B1&) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
 };
 
 struct B2 {
   struct {
     int x;
     int &y;
   };
 
   bool operator==(const B2&) const;
   bool operator!=(const B2&) const = default;
 
   bool operator<=>(const B2&) const;
   bool operator<(const B2&) const = default;
   bool operator<=(const B2&) const = default;
   bool operator>(const B2&) const = default;
   bool operator>=(const B2&) const = default;
 };
 
 union C1 {
   int a;
 
-  bool operator==(const C1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'C1' is a union }}
-  bool operator<=>(const C1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'C1' is a union }}
+  bool operator==(const C1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'C1' is a union }} expected-note{{replace 'default'}}
+  bool operator<=>(const C1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'C1' is a union }} expected-note{{replace 'default'}}
 };
 
 union C2 {
   int a;
 
   bool operator==(const C2&) const;
   bool operator!=(const C2&) const = default;
 
   bool operator<=>(const C2&) const;
   bool operator<(const C2&) const = default;
   bool operator<=(const C2&) const = default;
   bool operator>(const C2&) const = default;
   bool operator>=(const C2&) const = default;
 };
 
 struct D1 {
   union {
     int a;
   };
 
-  bool operator==(const D1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'D1' is a union-like class}}
-  bool operator<=>(const D1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'D1' is a union-like class}}
+  bool operator==(const D1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'D1' is a union-like class}} expected-note{{replace 'default'}}
+  bool operator<=>(const D1&) const = default; // expected-warning {{implicitly deleted}} expected-note {{because 'D1' is a union-like class}} expected-note{{replace 'default'}}
 };
 struct D2 {
   union {
     int a;
   };
 
   bool operator==(const D2&) const;
   bool operator!=(const D2&) const = default;

clang/test/CXX/class/class.compare/class.compare.secondary/p2.cpp

 // RUN: %clang_cc1 -std=c++20 -verify %s
 
 struct A {
-  bool operator!=(const A&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}}
+  bool operator!=(const A&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{defaulted 'operator!=' is implicitly deleted because there is no viable 'operator==' for 'A'}}
 };
 
 struct Q {};
 bool operator!=(Q, Q); // expected-note {{defaulted 'operator!=' is implicitly deleted because this non-rewritten comparison function would be the best match for the comparison}}
 struct B {
   operator Q() const;
-  bool operator!=(const B&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}}
+  bool operator!=(const B&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
 };
 
 struct R {};
 bool operator==(R, R);
 struct B2 {
   operator R() const;
   bool operator!=(const B2&) const = default; // OK! Converts to use rewritten R comparison.
 };
 
 struct C {
   operator int() const; // expected-note {{defaulted 'operator!=' is implicitly deleted because a builtin comparison function using this conversion would be the best match for the comparison}}
-  bool operator!=(const C&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}}
+  bool operator!=(const C&) const = default; // expected-warning {{explicitly defaulted equality comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
 };
 
 struct D {
-  bool operator<(const D&) const = default; // expected-warning {{explicitly defaulted relational comparison operator is implicitly deleted}}
+  bool operator<(const D&) const = default; // expected-warning {{explicitly defaulted relational comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{defaulted 'operator<' is implicitly deleted because there is no viable three-way comparison function for 'D'}}
 };
 
 bool operator<(Q, Q); // expected-note {{defaulted 'operator<' is implicitly deleted because this non-rewritten comparison function would be the best match for the comparison}}
 struct E {
   operator Q() const;
-  bool operator<(const E&) const = default; // expected-warning {{explicitly defaulted relational comparison operator is implicitly deleted}}
+  bool operator<(const E&) const = default; // expected-warning {{explicitly defaulted relational comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
 };
 
 int operator<=>(R, R);
 struct E2 {
   operator R() const;
   bool operator<(const E2&) const = default;
 };
 
 struct F {
   operator int() const; // expected-note {{defaulted 'operator<' is implicitly deleted because a builtin comparison function using this conversion would be the best match for the comparison}}
-  bool operator<(const F&) const = default; // expected-warning {{explicitly defaulted relational comparison operator is implicitly deleted}}
+  bool operator<(const F&) const = default; // expected-warning {{explicitly defaulted relational comparison operator is implicitly deleted}} expected-note{{replace 'default'}}
 };

clang/test/CXX/class/class.compare/class.eq/p2.cpp

struct E {
   E(const E &) = delete; // expected-note {{deleted}}
   int operator==(E) const; // expected-note {{passing}}
 };
 struct F { void operator==(F) const; };
 struct G { bool operator==(G) const = delete; }; // expected-note {{deleted here}}
 
 struct H1 {
   bool operator==(const H1 &) const = default;
-  bool operator<(const H1 &) const = default; // expected-warning {{implicitly deleted}}
+  bool operator<(const H1 &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{because there is no viable three-way comparison function for 'H1'}}
   void (*x)();
 };
 struct H2 {
   bool operator==(const H2 &) const = default;
-  bool operator<(const H2 &) const = default; // expected-warning {{implicitly deleted}}
+  bool operator<(const H2 &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{because there is no viable three-way comparison function for 'H2'}}
   void (H2::*x)();
 };
 struct H3 {
   bool operator==(const H3 &) const = default;
-  bool operator<(const H3 &) const = default; // expected-warning {{implicitly deleted}}
+  bool operator<(const H3 &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   // expected-note@-1 {{because there is no viable three-way comparison function for 'H3'}}
   int H3::*x;
 };
 
 template<typename T> struct X {
   X();
   bool operator==(const X&) const = default; // #x expected-note 4{{deleted here}}
   T t; // expected-note 3{{because there is no viable three-way comparison function for member 't'}}
void test() {
   void(X<B[3]>() == X<B[3]>());
 }
 
 namespace Access {
   class A {
     bool operator==(const A &) const; // expected-note 2{{implicitly declared private here}}
   };
   struct B : A { // expected-note 2{{because it would invoke a private 'operator==' to compare base class 'A'}}
-    bool operator==(const B &) const = default; // expected-warning {{deleted}}
-    friend bool operator==(const B &, const B &) = default; // expected-warning {{deleted}}
+    bool operator==(const B &) const = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
+    friend bool operator==(const B &, const B &) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 
   class C {
   protected:
     bool operator==(const C &) const; // expected-note 2{{declared protected here}}
   };
   struct D : C {
     bool operator==(const D &) const = default;
     friend bool operator==(const D &, const D&) = default;
   };
   struct E {
     C c; // expected-note 2{{because it would invoke a protected 'operator==' member of 'Access::C' to compare member 'c'}}
-    bool operator==(const E &) const = default; // expected-warning {{deleted}}
-    friend bool operator==(const E &, const E &) = default; // expected-warning {{deleted}}
+    bool operator==(const E &) const = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
+    friend bool operator==(const E &, const E &) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 
   struct F : C {
     using C::operator==;
   };
   struct G : F {
     bool operator==(const G&) const = default;
     friend bool operator==(const G&, const G&) = default;
   };
 
   struct H : C {
   private:
     using C::operator==; // expected-note 2{{declared private here}}
   };
   struct I : H { // expected-note 2{{private 'operator==' to compare base class 'H'}}
-    bool operator==(const I&) const = default; // expected-warning {{deleted}}
-    friend bool operator==(const I&, const I&) = default; // expected-warning {{deleted}}
+    bool operator==(const I&) const = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
+    friend bool operator==(const I&, const I&) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 
   class J {
     bool operator==(const J&) const;
     friend class K;
   };
   class K {
     J j;

clang/test/CXX/class/class.compare/class.rel/p2.cpp

namespace Rel {
   static_assert(A{1} > A{0});
   static_assert(A{1} > A{1}); // expected-error {{failed}}
   static_assert(A{1} >= A{0});
   static_assert(A{1} >= A{1});
   static_assert(A{1} >= A{2}); // expected-error {{failed}}
 
   struct B {
     bool operator<=>(B) const = delete; // expected-note 4{{deleted here}} expected-note-re 8{{candidate {{.*}} deleted}}
-    friend bool operator<(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}}
-    friend bool operator<=(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}}
-    friend bool operator>(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}}
-    friend bool operator>=(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}}
+    friend bool operator<(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}} expected-note{{replace 'default'}}
+    friend bool operator<=(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}} expected-note{{replace 'default'}}
+    friend bool operator>(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}} expected-note{{replace 'default'}}
+    friend bool operator>=(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}} expected-note{{replace 'default'}}
   };
   bool b1 = B() < B(); // expected-error {{deleted}}
   bool b2 = B() <= B(); // expected-error {{deleted}}
   bool b3 = B() > B(); // expected-error {{deleted}}
   bool b4 = B() >= B(); // expected-error {{deleted}}
 
   struct C {
     friend bool operator<=>(const C&, const C&);
     friend bool operator<(const C&, const C&); // expected-note {{because this non-rewritten comparison function would be the best match}}
 
-    bool operator<(const C&) const = default; // expected-warning {{implicitly deleted}}
+    bool operator<(const C&) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
     bool operator>(const C&) const = default; // OK
   };
 }
 
 // Under P2002R0, operator!= follows these rules too.
 namespace NotEqual {
   struct A {
     int n;
     constexpr bool operator==(A a) const { return n == a.n; }
     friend bool operator!=(const A&, const A&) = default;
   };
   static_assert(A{1} != A{2});
   static_assert(A{1} != A{1}); // expected-error {{failed}}
 
   struct B {
     bool operator==(B) const = delete; // expected-note {{deleted here}} expected-note-re 2{{candidate {{.*}} deleted}}
-    friend bool operator!=(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}}
+    friend bool operator!=(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note {{because it would invoke a deleted comparison}} expected-note-re {{candidate {{.*}} deleted}} expected-note{{replace 'default'}}
   };
   bool b = B() != B(); // expected-error {{deleted}}
 
   struct C {
     friend bool operator==(const C&, const C&);
     friend bool operator!=(const C&, const C&); // expected-note {{because this non-rewritten comparison function would be the best match}}
 
-    bool operator!=(const C&) const = default; // expected-warning {{implicitly deleted}}
+    bool operator!=(const C&) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   };
 
   // Ensure we don't go into an infinite loop diagnosing this: the first function
   // is deleted because it calls the second function, which is deleted because it
   // calls the first.
   struct Evil {
-    friend bool operator!=(const Evil&, const Evil&) = default; // expected-warning {{implicitly deleted}} expected-note {{would be the best match}}
-    bool operator!=(const Evil&) const = default; // expected-warning {{implicitly deleted}} expected-note {{would be the best match}}
+    friend bool operator!=(const Evil&, const Evil&) = default; // expected-warning {{implicitly deleted}} expected-note {{would be the best match}} expected-note{{replace 'default'}}
+    bool operator!=(const Evil&) const = default; // expected-warning {{implicitly deleted}} expected-note {{would be the best match}} expected-note{{replace 'default'}}
   };
 }
 
 namespace Access {
   class A {
     int operator<=>(A) const; // expected-note {{private}}
   };
   struct B : A {
-    friend bool operator<(const B&, const B&) = default; // expected-warning {{implicitly deleted}}
+    friend bool operator<(const B&, const B&) = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
     // expected-note@-1 {{defaulted 'operator<' is implicitly deleted because it would invoke a private 'operator<=>' member of 'Access::A'}}
   };
 }

clang/test/CXX/class/class.compare/class.spaceship/p1.cpp

namespace Access {
   class A {
     std::strong_ordering operator<=>(const A &) const; // expected-note {{here}}
   public:
     bool operator==(const A &) const;
     bool operator<(const A &) const;
   };
   struct B {
     A a; // expected-note {{would invoke a private 'operator<=>'}}
-    friend std::strong_ordering operator<=>(const B &, const B &) = default; // expected-warning {{deleted}}
+    friend std::strong_ordering operator<=>(const B &, const B &) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 
   class C {
     std::strong_ordering operator<=>(const C &); // not viable (not const)
     bool operator==(const C &) const; // expected-note {{here}}
     bool operator<(const C &) const;
   };
   struct D {
     C c; // expected-note {{would invoke a private 'operator=='}}
-    friend std::strong_ordering operator<=>(const D &, const D &) = default; // expected-warning {{deleted}}
+    friend std::strong_ordering operator<=>(const D &, const D &) = default; // expected-warning {{deleted}} expected-note{{replace 'default'}}
   };
 }
 
 namespace Synthesis {
   enum Result { False, True, Mu };
 
   constexpr bool toBool(Result R) {
     if (R == Mu) throw "should not ask this question";

clang/test/CXX/class/class.compare/class.spaceship/p2.cpp

 }
 
 namespace DeducedNotCat {
   struct A {
     A operator<=>(const A&) const; // expected-note {{selected 'operator<=>' for member 'a' declared here}}
   };
   struct B {
     A a; // expected-note {{return type 'A' of three-way comparison for member 'a' is not a standard comparison category type}}
-    auto operator<=>(const B&) const = default; // expected-warning {{implicitly deleted}}
+    auto operator<=>(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   };
 }
 
 namespace DeducedVsSynthesized {
   struct A {
     bool operator==(const A&) const;
     bool operator<(const A&) const;
   };
   struct B {
     A a; // expected-note {{no viable three-way comparison function for member 'a'}}
-    auto operator<=>(const B&) const = default; // expected-warning {{implicitly deleted}}
+    auto operator<=>(const B&) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   };
 }
 
 namespace Deduction {
   template<typename T> struct wrap {
     T t;
     friend auto operator<=>(const wrap&, const wrap&) = default;
   };
namespace PR44723 {
 
   struct c {
     auto operator<=>(const c&) const&; // expected-note {{selected 'operator<=>' for base class 'c' declared here}}
   };
   struct d : c { // expected-note {{base class 'c' declared here}}
     friend auto operator<=>(const d&, const d&) = default; // #d
     // expected-error@#d {{return type of defaulted 'operator<=>' cannot be deduced because three-way comparison for base class 'c' has a deduced return type and is not yet defined}}
     // expected-warning@#d {{implicitly deleted}}
+    // expected-note@#d {{replace 'default'}}
   };
   auto c::operator<=>(const c&) const& { // #c
     return std::strong_ordering::equal;
   }
   // expected-error@+1 {{overload resolution selected deleted operator '<=>'}}
   std::strong_ordering cmp_d = d() <=> d();
   // expected-note@#c 2{{candidate}}
   // expected-note@#d {{candidate function has been implicitly deleted}}
namespace BadDeducedType {
   struct D {
     // expected-error@+1 {{deduced return type for defaulted three-way comparison operator must be 'auto', not 'CmpCat auto'}}
     friend CmpCat auto operator<=>(const D&, const D&) = default;
   };
 }
 
 namespace PR48856 {
   struct A {
-    auto operator<=>(const A &) const = default; // expected-warning {{implicitly deleted}}
+    auto operator<=>(const A &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
     void (*x)();                                 // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 
   struct B {
-    auto operator<=>(const B &) const = default; // expected-warning {{implicitly deleted}}
+    auto operator<=>(const B &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
     void (B::*x)();                              // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 
   struct C {
-    auto operator<=>(const C &) const = default; // expected-warning {{implicitly deleted}}
+    auto operator<=>(const C &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
     int C::*x;                                   // expected-note {{because there is no viable three-way comparison function for member 'x'}}
   };
 }
 
 namespace PR50591 {
   struct a1 {
     operator int() const;
   };
namespace PR50591 {
   std::partial_ordering cmp_b2 = b2() <=> b2();
 
   using fp = void (*)();
 
   struct a3 {
     operator fp() const;
   };
   struct b3 {
-    auto operator<=>(b3 const &) const = default; // expected-warning {{implicitly deleted}}
+    auto operator<=>(b3 const &) const = default; // expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
     a3 f;                                         // expected-note {{because there is no viable three-way comparison function}}
   };
 
   struct a4 { // Test that function pointer conversion operator here is ignored for this overload resolution.
     operator int() const;
     operator fp() const;
   };
   struct b4 {
     auto operator<=>(b4 const &) const = default;
     a4 f;
   };
   std::strong_ordering cmp_b4 = b4() <=> b4();
 }

clang/test/CXX/drs/dr6xx.cpp

namespace dr666 { // dr666: yes
   int a = f<X>();
   int b = f<Y>(); // expected-note {{instantiation of}}
 }
 
 // Triviality is entirely different in C++98.
 #if __cplusplus >= 201103L
 namespace dr667 { // dr667: yes
   struct A {
-    A() = default; // expected-warning {{explicitly defaulted default constructor is implicitly deleted}}
+    A() = default; // expected-warning {{explicitly defaulted default constructor is implicitly deleted}} expected-note{{replace 'default'}}
     int &r; // expected-note {{because field 'r' of reference type 'int &' would not be initialized}}
   };
   static_assert(!__is_trivially_constructible(A), "");
 
   struct B { ~B() = delete; };
   union C { B b; };
   static_assert(!__is_trivially_destructible(C), "");
 

clang/test/SemaCXX/cxx0x-deleted-default-ctor.cpp

 };
 struct has_friend {
   friend_default fd;
 };
 has_friend hf;
 
 struct defaulted_delete {
   no_default nd; // expected-note 2{{because field 'nd' has a deleted default constructor}}
-  defaulted_delete() = default; // expected-note{{implicitly deleted here}} expected-warning {{implicitly deleted}}
+  defaulted_delete() = default; // expected-note{{implicitly deleted here}} expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
 };
 defaulted_delete dd; // expected-error {{call to implicitly-deleted default constructor}}
 
 struct late_delete {
   no_default nd; // expected-note {{because field 'nd' has a deleted default constructor}}
   late_delete();
 };
 late_delete::late_delete() = default; // expected-error {{would delete it}}

clang/test/SemaCXX/dr1301.cpp

 int b = B().n; // expected-error {{call to deleted}}
 
 struct C {
   B b; // expected-note {{deleted default constructor}}
 };
 int c = C().b.n; // expected-error {{call to implicitly-deleted default}}
 
 struct D {
-  D() = default; // expected-note {{here}} expected-warning {{implicitly deleted}}
+  D() = default; // expected-note {{here}} expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   B b; // expected-note 2{{'b' has a deleted default constructor}}
 };
 int d = D().b.n; // expected-error {{call to implicitly-deleted default}}
 
 struct E {
   E() = default;
   int n;
 };

clang/test/SemaCXX/explicitly-defaulted.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+struct Deleted {
+  Deleted() = delete; // expected-note 3{{marked deleted here}}
+  Deleted(const Deleted &) = delete; // expected-note 2{{marked deleted here}}
+  Deleted(Deleted &&) = delete; // expected-note 2{{marked deleted here}}
+  Deleted &operator=(const Deleted &) = delete; // expected-note 2{{marked deleted here}}
+  Deleted &operator=(Deleted &&) = delete; // expected-note 2{{marked deleted here}}
+  ~Deleted() = delete; // expected-note 2{{marked deleted here}}
+};
+
+struct Derive : Deleted { // expected-note 6{{because base class}}
+  Derive() = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Derive(const Derive &) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Derive(Derive &&) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Derive &operator=(const Derive &) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Derive &operator=(Derive &&) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  ~Derive() = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+};
+
+struct Member {
+  Deleted A; // expected-note 6{{because field 'A'}}
+  Member() = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Member(const Member &) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Member(Member &&) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Member &operator=(const Member &) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  Member &operator=(Member &&) = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+  ~Member() = default; // expected-warning{{explicitly defaulted}} expected-note{{replace 'default' with 'delete'}}
+};
+
+template<typename T>
+struct TDerive : T { // expected-note {{because base class}}
+  TDerive() = default; //expected-note {{explicitly defaulted}} // Don't expect a fix note to be emitted
+};
+
+using ShouldDelete = TDerive<Deleted>;
+
+ShouldDelete A; // expected-error{{call to implicitly-deleted}}

clang/test/SemaCXX/microsoft-dtor-lookup-cxx11.cpp

 // RUN: %clang_cc1 -triple i686-pc-win32 -std=c++11 -verify %s
 
 struct S {
   virtual ~S() = delete; // expected-note {{'~S' has been explicitly marked deleted here}}
   void operator delete(void*, int);
   void operator delete(void*, double);
 } s; // expected-error {{attempt to use a deleted function}}
 
 struct T { // expected-note 2{{virtual destructor requires an unambiguous, accessible 'operator delete'}}
-  virtual ~T() = default; // expected-note {{explicitly defaulted function was implicitly deleted here}} expected-warning {{implicitly deleted}}
+  virtual ~T() = default; // expected-note {{explicitly defaulted function was implicitly deleted here}} expected-warning {{implicitly deleted}} expected-note{{replace 'default'}}
   void operator delete(void*, int);
   void operator delete(void*, double);
 } t; // expected-error {{attempt to use a deleted function}}

clang/test/SemaObjCXX/arc-0x.mm

namespace test_union {
   // Implicitly-declared special functions of a union are deleted by default if
   // ARC is enabled and the union has an ObjC pointer field.
   union U0 {
     id f0; // expected-note 6 {{'U0' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
   };
 
   union U1 {
     __weak id f0; // expected-note 12 {{'U1' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
-    U1() = default; // expected-warning {{explicitly defaulted default constructor is implicitly deleted}} expected-note {{explicitly defaulted function was implicitly deleted here}}
-    ~U1() = default; // expected-warning {{explicitly defaulted destructor is implicitly deleted}} expected-note {{explicitly defaulted function was implicitly deleted here}}
-    U1(const U1 &) = default; // expected-warning {{explicitly defaulted copy constructor is implicitly deleted}} expected-note 2 {{explicitly defaulted function was implicitly deleted here}}
-    U1(U1 &&) = default; // expected-warning {{explicitly defaulted move constructor is implicitly deleted}}
-    U1 & operator=(const U1 &) = default; // expected-warning {{explicitly defaulted copy assignment operator is implicitly deleted}} expected-note 2 {{explicitly defaulted function was implicitly deleted here}}
-    U1 & operator=(U1 &&) = default; // expected-warning {{explicitly defaulted move assignment operator is implicitly deleted}}
+    U1() = default; // expected-warning {{explicitly defaulted default constructor is implicitly deleted}} expected-note {{explicitly defaulted function was implicitly deleted here}} expected-note{{replace 'default'}}
+    ~U1() = default; // expected-warning {{explicitly defaulted destructor is implicitly deleted}} expected-note {{explicitly defaulted function was implicitly deleted here}} expected-note{{replace 'default'}}
+    U1(const U1 &) = default; // expected-warning {{explicitly defaulted copy constructor is implicitly deleted}} expected-note 2 {{explicitly defaulted function was implicitly deleted here}} expected-note{{replace 'default'}}
+    U1(U1 &&) = default; // expected-warning {{explicitly defaulted move constructor is implicitly deleted}} expected-note{{replace 'default'}}
+    U1 & operator=(const U1 &) = default; // expected-warning {{explicitly defaulted copy assignment operator is implicitly deleted}} expected-note 2 {{explicitly defaulted function was implicitly deleted here}} expected-note{{replace 'default'}}
+    U1 & operator=(U1 &&) = default; // expected-warning {{explicitly defaulted move assignment operator is implicitly deleted}} expected-note{{replace 'default'}}
   };
 
   id getStrong();
 
   // If the ObjC pointer field of a union has a default member initializer, the
   // implicitly-declared default constructor of the union is not deleted by
   // default.
   union U2 {