Revert "Add new 'preferred_name' attribute."

This change exposed a pre-existing issue with deserialization cycles
caused by a combination of attributes and template instantiations
violating the deserialization ordering restrictions; see PR48434 for
details.

A previous commit attempted to work around PR48434, but appears to have
only been a partial fix, and fixing this properly seems non-trivial.
Backing out for now to unblock things.

This reverts commit 98f76ad and
commit a64c26a.

Author: zygoloid

clang/include/clang/AST/TypeProperties.td

@@ -484,12 +484,8 @@ let Class = TagType in {
     let Read = [{ node->isDependentType() }];
   }
   def : Property<"declaration", DeclRef> {
-    // We don't know which declaration was originally referenced here, and we
-    // cannot reference a declaration that follows the use (because that can
-    // introduce deserialization cycles), so conservatively generate a
-    // reference to the first declaration.
-    // FIXME: If this is a reference to a class template specialization, that
-    // can still introduce a deserialization cycle.
+    // Serializing a reference to the canonical declaration is apparently
+    // necessary to make module-merging work.
     let Read = [{ node->getDecl()->getCanonicalDecl() }];
   }
 }

clang/include/clang/Basic/Attr.td

@@ -126,9 +126,6 @@ def FunctionTmpl
                                  FunctionDecl::TK_FunctionTemplate}],
                     "function templates">;
 
-def ClassTmpl : SubsetSubject<CXXRecord, [{S->getDescribedClassTemplate()}],
-                              "class templates">;
-
 // FIXME: this hack is needed because DeclNodes.td defines the base Decl node
 // type to be a class, not a definition. This makes it impossible to create an
 // attribute subject which accepts a Decl. Normally, this is not a problem,
@@ -2394,16 +2391,6 @@ def Pascal : DeclOrTypeAttr {
   let Documentation = [Undocumented];
 }
 
-def PreferredName : InheritableAttr {
-  let Spellings = [Clang<"preferred_name", /*AllowInC*/0>];
-  let Subjects = SubjectList<[ClassTmpl]>;
-  let Args = [TypeArgument<"TypedefType">];
-  let Documentation = [PreferredNameDocs];
-  let InheritEvenIfAlreadyPresent = 1;
-  let MeaningfulToClassTemplateDefinition = 1;
-  let TemplateDependent = 1;
-}
-
 def PreserveMost : DeclOrTypeAttr {
   let Spellings = [Clang<"preserve_most">];
   let Documentation = [PreserveMostDocs];

clang/include/clang/Basic/AttrDocs.td

@@ -4471,30 +4471,6 @@ the old mangled name and the new code will use the new mangled name with tags.
   }];
 }
 
-def PreferredNameDocs : Documentation {
-  let Category = DocCatDecl;
-  let Content = [{
-The ``preferred_name`` attribute can be applied to a class template, and
-specifies a preferred way of naming a specialization of the template. The
-preferred name will be used whenever the corresponding template specialization
-would otherwise be printed in a diagnostic or similar context.
-
-The preferred name must be a typedef or type alias declaration that refers to a
-specialization of the class template (not including any type qualifiers). In
-general this requires the template to be declared at least twice. For example:
-
-.. code-block:: c++
-
-  template<typename T> struct basic_string;
-  using string = basic_string<char>;
-  using wstring = basic_string<wchar_t>;
-  template<typename T> struct [[clang::preferred_name(string),
-                                clang::preferred_name(wstring)]] basic_string {
-    // ...
-  };
-  }];
-}
-
 def PreserveMostDocs : Documentation {
   let Category = DocCatCallingConvs;
   let Content = [{

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3941,9 +3941,6 @@ def note_protocol_decl : Note<
   "protocol is declared here">;
 def note_protocol_decl_undefined : Note<
   "protocol %0 has no definition">;
-def err_attribute_preferred_name_arg_invalid : Error<
-  "argument %0 to 'preferred_name' attribute is not a typedef for "
-  "a specialization of %1">;
 
 // objc_designated_initializer attribute diagnostics.
 def warn_objc_designated_init_missing_super_call : Warning<

clang/lib/AST/TypePrinter.cpp

@@ -10,16 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/NestedNameSpecifier.h"
-#include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
@@ -1349,19 +1348,6 @@ void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
 }
 
 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
-  // Print the preferred name if we have one for this type.
-  if (const auto *Spec =
-          dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) {
-    for (const auto *PNA : Spec->getSpecializedTemplate()
-                               ->getTemplatedDecl()
-                               ->getMostRecentDecl()
-                               ->specific_attrs<PreferredNameAttr>()) {
-      if (declaresSameEntity(PNA->getTypedefType()->getAsCXXRecordDecl(), Spec))
-        return printTypeSpec(
-            PNA->getTypedefType()->castAs<TypedefType>()->getDecl(), OS);
-    }
-  }
-
   printTag(T->getDecl(), OS);
 }
 

clang/lib/Sema/SemaDeclAttr.cpp

@@ -1380,43 +1380,6 @@ static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
     S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
 }
 
-static void handlePreferredName(Sema &S, Decl *D, const ParsedAttr &AL) {
-  auto *RD = cast<CXXRecordDecl>(D);
-  ClassTemplateDecl *CTD = RD->getDescribedClassTemplate();
-  assert(CTD && "attribute does not appertain to this declaration");
-
-  ParsedType PT = AL.getTypeArg();
-  TypeSourceInfo *TSI = nullptr;
-  QualType T = S.GetTypeFromParser(PT, &TSI);
-  if (!TSI)
-    TSI = S.Context.getTrivialTypeSourceInfo(T, AL.getLoc());
-
-  if (!T.hasQualifiers() && T->getAs<TypedefType>()) {
-    // Find the template name, if this type names a template specialization.
-    const TemplateDecl *Template = nullptr;
-    if (const auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
-            T->getAsCXXRecordDecl())) {
-      Template = CTSD->getSpecializedTemplate();
-    } else if (const auto *TST = T->getAs<TemplateSpecializationType>()) {
-      while (TST && TST->isTypeAlias())
-        TST = TST->getAliasedType()->getAs<TemplateSpecializationType>();
-      if (TST)
-        Template = TST->getTemplateName().getAsTemplateDecl();
-    }
-
-    if (Template && declaresSameEntity(Template, CTD)) {
-      D->addAttr(::new (S.Context) PreferredNameAttr(S.Context, AL, TSI));
-      return;
-    }
-  }
-
-  S.Diag(AL.getLoc(), diag::err_attribute_preferred_name_arg_invalid)
-      << T << CTD;
-  if (const auto *TT = T->getAs<TypedefType>())
-    S.Diag(TT->getDecl()->getLocation(), diag::note_entity_declared_at)
-        << TT->getDecl();
-}
-
 static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
   // The IBOutlet/IBOutletCollection attributes only apply to instance
   // variables or properties of Objective-C classes.  The outlet must also
@@ -7815,9 +7778,6 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_Packed:
     handlePackedAttr(S, D, AL);
     break;
-  case ParsedAttr::AT_PreferredName:
-    handlePreferredName(S, D, AL);
-    break;
   case ParsedAttr::AT_Section:
     handleSectionAttr(S, D, AL);
     break;

clang/lib/Sema/SemaTemplate.cpp

@@ -3792,15 +3792,11 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
         Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
     }
 
-    if (Decl->getSpecializationKind() == TSK_Undeclared &&
-        ClassTemplate->getTemplatedDecl()->hasAttrs()) {
-      InstantiatingTemplate Inst(*this, TemplateLoc, Decl);
-      if (!Inst.isInvalid()) {
-        MultiLevelTemplateArgumentList TemplateArgLists;
-        TemplateArgLists.addOuterTemplateArguments(Converted);
-        InstantiateAttrsForDecl(TemplateArgLists,
-                                ClassTemplate->getTemplatedDecl(), Decl);
-      }
+    if (Decl->getSpecializationKind() == TSK_Undeclared) {
+      MultiLevelTemplateArgumentList TemplateArgLists;
+      TemplateArgLists.addOuterTemplateArguments(Converted);
+      InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
+                              Decl);
     }
 
     // Diagnose uses of this specialization.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -548,30 +548,12 @@ static void instantiateDependentAMDGPUWavesPerEUAttr(
   S.addAMDGPUWavesPerEUAttr(New, Attr, MinExpr, MaxExpr);
 }
 
-/// Determine whether the attribute A might be relevent to the declaration D.
-/// If not, we can skip instantiating it. The attribute may or may not have
-/// been instantiated yet.
-static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A) {
-  // Never instantiate preferred_name attributes; they're relevant only on the
-  // template.
-  if (const auto *PNA = dyn_cast<PreferredNameAttr>(A))
-    return false;
-
-  return true;
-}
-
 void Sema::InstantiateAttrsForDecl(
     const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
     Decl *New, LateInstantiatedAttrVec *LateAttrs,
     LocalInstantiationScope *OuterMostScope) {
   if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
-    // FIXME: This function is called multiple times for the same template
-    // specialization. We should only instantiate attributes that were added
-    // since the previous instantiation.
     for (const auto *TmplAttr : Tmpl->attrs()) {
-      if (!isRelevantAttr(*this, New, TmplAttr))
-        continue;
-
       // FIXME: If any of the special case versions from InstantiateAttrs become
       // applicable to template declaration, we'll need to add them here.
       CXXThisScopeRAII ThisScope(
@@ -580,7 +562,7 @@ void Sema::InstantiateAttrsForDecl(
 
       Attr *NewAttr = sema::instantiateTemplateAttributeForDecl(
           TmplAttr, Context, *this, TemplateArgs);
-      if (NewAttr && isRelevantAttr(*this, New, NewAttr))
+      if (NewAttr)
         New->addAttr(NewAttr);
     }
   }
@@ -605,9 +587,6 @@ void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
                             LateInstantiatedAttrVec *LateAttrs,
                             LocalInstantiationScope *OuterMostScope) {
   for (const auto *TmplAttr : Tmpl->attrs()) {
-    if (!isRelevantAttr(*this, New, TmplAttr))
-      continue;
-
     // FIXME: This should be generalized to more than just the AlignedAttr.
     const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
     if (Aligned && Aligned->isAlignmentDependent()) {
@@ -730,7 +709,7 @@ void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
 
       Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
                                                          *this, TemplateArgs);
-      if (NewAttr && isRelevantAttr(*this, New, TmplAttr))
+      if (NewAttr)
         New->addAttr(NewAttr);
     }
   }

clang/test/PCH/decl-attrs.cpp

@@ -63,63 +63,3 @@ namespace PR9049 {
 // CHECK:   AnnotateAttr {{.*}} "ANNOTATE_BAR"
 template<typename T> [[clang::annotate("ANNOTATE_FOO"), clang::annotate("ANNOTATE_BAR")]] void HasAnnotations();
 void UseAnnotations() { HasAnnotations<int>(); }
-
-namespace preferred_name {
-  int x [[clang::preferred_name("frank")]]; // expected-error {{expected a type}}
-  int y [[clang::preferred_name(int)]]; // expected-warning {{'preferred_name' attribute only applies to class templates}}
-  struct [[clang::preferred_name(int)]] A; // expected-warning {{'preferred_name' attribute only applies to class templates}}
-  template<typename T> struct [[clang::preferred_name(int)]] B; // expected-error {{argument 'int' to 'preferred_name' attribute is not a typedef for a specialization of 'B'}}
-  template<typename T> struct C;
-  using X = C<int>; // expected-note {{'X' declared here}}
-  typedef C<float> Y;
-  using Z = const C<double>; // expected-note {{'Z' declared here}}
-  template<typename T> struct [[clang::preferred_name(C<int>)]] C; // expected-error {{argument 'C<int>' to 'preferred_name' attribute is not a typedef for a specialization of 'C'}}
-  template<typename T> struct [[clang::preferred_name(X), clang::preferred_name(Y)]] C;
-  template<typename T> struct [[clang::preferred_name(const X)]] C; // expected-error {{argument 'const preferred_name::X'}}
-  template<typename T> struct [[clang::preferred_name(Z)]] C; // expected-error {{argument 'preferred_name::Z' (aka 'const C<double>')}}
-  template<typename T> struct C {};
-
-  // CHECK: ClassTemplateDecl {{.*}} <line:[[@LINE-10]]:{{.*}} C
-  // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
-  // CHECK:     TemplateArgument type 'int'
-  // CHECK-NOT: PreferredNameAttr
-  // CHECK:     CXXRecordDecl
-  // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
-  // CHECK:     TemplateArgument type 'float'
-  // CHECK-NOT: PreferredNameAttr
-  // CHECK:     CXXRecordDecl
-  // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
-  // CHECK:     TemplateArgument type 'double'
-  // CHECK-NOT: PreferredNameAttr
-  // CHECK:     CXXRecordDecl
-
-  // Check this doesn't cause us to instantiate the same attribute multiple times.
-  C<float> *cf1;
-  C<float> *cf2;
-
-  void f(C<int> a, C<float> b, C<double> c) {
-    auto p = a;
-    auto q = b;
-    auto r = c;
-    p.f(); // expected-error {{no member named 'f' in 'preferred_name::X'}}
-    q.f(); // expected-error {{no member named 'f' in 'preferred_name::Y'}}
-    r.f(); // expected-error {{no member named 'f' in 'preferred_name::C<double>'}}
-  }
-
-  template<typename T> struct D;
-  using DInt = D<int>;
-  template<typename T> struct __attribute__((__preferred_name__(DInt))) D {};
-  template struct D<int>;
-  int use_dint = D<int>().get(); // expected-error {{no member named 'get' in 'preferred_name::DInt'}}
-
-  template<typename T> struct MemberTemplate {
-    template<typename U> struct Iter;
-    using iterator = Iter<T>;
-    using const_iterator = Iter<const T>;
-    template<typename U>
-    struct [[clang::preferred_name(iterator),
-             clang::preferred_name(const_iterator)]] Iter {};
-  };
-  auto it = MemberTemplate<int>::Iter<const int>();
-  int n = it; // expected-error {{no viable conversion from 'preferred_name::MemberTemplate<int>::Iter<const int>' to 'int'}}
-}