[Clang][Attributes] Add MeaningfulToClassTemplateDefinition to unavailable attribute

[shafik]

Summary

There may be cases in which we want to diagnose a type as unavailable but it may not be complete at the time. Setting MeaningfulToClassTemplateDefinition fixes this issue.

This fixes: https://github.com/llvm/llvm-project/issues/61815

[aaron.ballman]

LGTM, though please add a release note about the fix. I don't *think* this qualifies as a potentially breaking change, though it does theoretically have the ability to cause code which previously compiled to no longer compile. At least, my search over sourcegraph didn't come up with any results (https://sourcegraph.com/search?q=context:global+lang:C%2B%2B+-file:.*test.*+template+%3Ctypename%7Cclass+.*%3E+__attribute__%5C%28%5C%28unavailable&patternType=regexp&sm=1&groupBy=repo).

[shafik]

• Add release note

clang/docs/ReleaseNotes.rst

 - Clang now avoids duplicate warnings on unreachable ``[[fallthrough]];`` statements
   previously issued from ``-Wunreachable-code`` and ``-Wunreachable-code-fallthrough``
   by prioritizing ``-Wunreachable-code-fallthrough``.
 - Clang now correctly diagnoses statement attributes ``[[clang::always_inine]]`` and
   ``[[clang::noinline]]`` when used on a statement with dependent call expressions.
 - Clang now checks for completeness of the second and third arguments in the
   conditional operator.
   (`#59718 <https://github.com/llvm/llvm-project/issues/59718>`_)
+- There were some cases in which the diagnostic for the unavailable attribute
+  might not be issued, this fixes those cases.
+  (`61815 <https://github.com/llvm/llvm-project/issues/61815>`_)
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.
   (`#60344 <https://github.com/llvm/llvm-project/issues/60344>`_)
 - Fix confusing warning message when ``/clang:-x`` is passed in ``clang-cl``

clang/include/clang/Basic/Attr.td

let Args = [StringArgument<"Message", 1>,
                 ["", "", "", ""],
                 ["IR_None",
                  "IR_ARCForbiddenType",
                  "IR_ForbiddenWeak",
                  "IR_ARCForbiddenConversion",
                  "IR_ARCInitReturnsUnrelated",
                  "IR_ARCFieldWithOwnership"], 1, /*fake*/ 1>];
   let Documentation = [Undocumented];
+  let MeaningfulToClassTemplateDefinition = 1;
 }
 
 def DiagnoseIf : InheritableAttr {
   // Does not have a [[]] spelling because this attribute requires the ability
   // to parse function arguments but the attribute is not written in the type
   // position.
   let Spellings = [GNU<"diagnose_if">];
   let Subjects = SubjectList<[Function, ObjCMethod, ObjCProperty]>;

clang/test/SemaCXX/attr-unavailable.cpp

 int instantiate_it2 = has_default_arg_template2<int>();
 
 template <class T>
 int phase_one_unavailable(int x = unavailable_int()) {}
 // expected-error@-1 {{'unavailable_int' is unavailable}}
 
 template <class T>
 int phase_one_unavailable2(int x = unavailable_int()) __attribute__((unavailable)) {}
+
+namespace GH61815 {
+template <class _ValueType = int>
+class __attribute__((unavailable)) polymorphic_allocator {}; // expected-note 2 {{'polymorphic_allocator<void>' has been explicitly marked unavailable here}}
+
+void f() {
+  polymorphic_allocator<void> a; // expected-error {{'polymorphic_allocator<void>' is unavailable}}
+  polymorphic_allocator<void> b; // expected-error {{'polymorphic_allocator<void>' is unavailable}}
+}
+}