Partial specialization after class template instantiation.

[nikola]

It looks good ignoring two style nitpicks. I'll have more confidence when you add the test for this, code review can stay open until you get to it.

lib/Sema/SemaTemplate.cpp

6226 ↗

(On Diff #14776)

const auto *

6234 ↗

(On Diff #14776)

Same here.

[majnemer]

lib/Sema/SemaTemplate.cpp

6228–6229 ↗

(On Diff #14776)

It would probably be more concise to do:

for (ClassTemplateSpecializationDecl &S : ClassTemplate.specializations())

[AntonBikineev]

In case const auto * deduced type has different meaning (pointer to constant), so it doesn’t compile.

[nikola]

You can drop the const altogether, we know that the pointer won't change.

[AntonBikineev]

some notes have been applied;
some tests have been added.
feel free to suggest some new test cases.

[rsmith]

../llvm/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

3395

Please use partial_spec or partial_specialization rather than part_specialization, like other diagnostics do.

../llvm/tools/clang/lib/Sema/SemaTemplate.cpp

6225

We don't need these checks for a redeclaration:

if (isPartialSpecialization && !PrevDecl) {

6227

Use cast, not static_cast, here. (It'll assert if the type doesn't match.)

6232

Hmm, what happens if we get an error outside of the immediate context during this deduction? Are we allowed to reject the program for that reason?

For instance:

template<typename T> struct X { typedef typename T::type type; };
template<typename T, typename U> struct A {};
A<int, int> Aint;
template<typename T> struct A<T, typename X<T>::type> {};

Do we provide a sufficiently useful template instantiation backtrace in this case?

[AntonBikineev]

Applied some comments

[AntonBikineev]

@rsmith, are there any plans/suggestions regarding this patch?

../llvm/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_specialized_decl : Note<"attempt to specialize declaration here">;
 def err_specialization_after_instantiation : Error<
   "explicit specialization of %0 after instantiation">;
+def err_part_specialization_after_instantiation : Error<
+  "partial specialization of %0 after instantiation">;
 def note_instantiation_required_here : Note<
   "%select{implicit|explicit}0 instantiation first required here">;
 def err_template_spec_friend : Error<

../llvm/tools/clang/lib/Sema/SemaTemplate.cpp

     CanonType = Context.getTypeDeclType(Specialization);
   }
 
+  // C++ [temp.class.spec]p1:
+  //   A partial specialization shall be declared before the first use of a class
+  //   template specialization that would make use of partial specialization as
+  //   the result of an implicit or explicit instantiation in every translation
+  //   unit in which such a use occurs; no diagnostic is required.
+  if (isPartialSpecialization) {
+    auto *ThisPartialSpec =
+        static_cast<ClassTemplatePartialSpecializationDecl *>(Specialization);
+    for (const auto &S : ClassTemplate->specializations()) {
+      TemplateDeductionInfo Info(KWLoc);
+      if (S->getSpecializationKind() != TSK_ExplicitSpecialization &&
+          S->hasDefinition() &&
+          !DeduceTemplateArguments(ThisPartialSpec, S->getTemplateArgs(), Info)) {
+        auto *InstantiatedFrom =
+            S->getInstantiatedFrom()
+                .dyn_cast<ClassTemplatePartialSpecializationDecl *>();
+        if (!InstantiatedFrom ||
+            getMoreSpecializedPartialSpecialization(
+                ThisPartialSpec, InstantiatedFrom, KWLoc) == ThisPartialSpec) {
+          SourceRange Range(TemplateNameLoc, RAngleLoc);
+          Diag(TemplateNameLoc, diag::err_part_specialization_after_instantiation)
+              << Context.getTypeDeclType(ThisPartialSpec) << Range;
+
+          Diag(S->getPointOfInstantiation(),
+               diag::note_instantiation_required_here)
+              << (S->getTemplateSpecializationKind() !=
+                  TSK_ImplicitInstantiation);
+        }
+      }
+    }
+  }
+
   // C++ [temp.expl.spec]p6:
   //   If a template, a member template or the member of a class template is
   //   explicitly specialized then that specialization shall be declared

../llvm/tools/clang/test/SemaTemplate/class-template-spec.cpp

   > struct S;
   template<typename T> struct S<T> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'T'}}
 }
+
+namespace PartialSpecAfterInstantiation {
+  template <typename T> struct A {};
+
+  A<int*> a; // expected-note {{implicit instantiation}}
+  template <typename T> struct A<T*> {}; // expected-error {{partial specialization}}
+
+  template struct A<int&>; // expected-note {{explicit instantiation}}
+  template <typename T> struct A<T&> {}; // expected-error {{partial specialization}}
+
+  A<const int*>* b; // that's fine
+  template <typename T> struct A<const T*> {};
+}