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

const auto *

6234

Same here.

[majnemer]

lib/Sema/SemaTemplate.cpp

6228–6229

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 ↗

(On Diff #14872)

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

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

6225 ↗

(On Diff #14872)

We don't need these checks for a redeclaration:

if (isPartialSpecialization && !PrevDecl) {

6227 ↗

(On Diff #14872)

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

6232 ↗

(On Diff #14872)

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?

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_partial_spec_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<

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 && !PrevDecl) {
+    auto *ThisPartialSpec =
+        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_partial_spec_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

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*> {};
+}