Explicit class template instantiation definitions are also explicit instantiation definitions of those members that have been defined at the point of instantiation
Consider the following simplified example:
template<int rank>
struct A {};
template<int rank>
struct Field {
void dot(A<rank>) requires (rank == 1) { (void)(1); }
void dot(A<rank>) requires (rank == 2) { (void)(2); }
};
[temp.explicit]/11 states [emphasis mine]:
An explicit instantiation that names a class template specialization
is also an explicit instantiation of the same kind (declaration or
definition) of each of its members (not including members
inherited from base classes and members that are templates) that has
not been previously explicitly specialized in the translation unit
containing the explicit instantiation, provided that the associated
constraints, if any, of that member are satisfied by the template
arguments of the explicit instantiation ([temp.constr.decl],
[temp.constr.constr]), except as described below. [...]
Which implies that an explicit instantiation definition that names only a class template specialization of Field, say
template struct Field<1>;
will also lead to the explicit instantiation definition of the dot overload which fulfills the constraint expression requires (rank == 1), but not for the overload with a constraint expression requires (rank == 2). However, the except as described below part leads us to [temp.explicit]/12, which states [emphasis mine]:
An explicit instantiation definition that names a class template
specialization explicitly instantiates the class template
specialization and is an explicit instantiation definition of only
those members that have been defined at the point of instantiation.
Meaning that, for the simplified example above (followed by the explicit instantiation definition for Field<1>, as above), the passage above indicates the explicit instantiation definition of both dot overloads, as both have been defined at the point of the explicit instantiation definition of Field<1>. This, however, means an ODR-violation as there will be two definitions of Field<1>::void dot(A<1>).
// Not OK.
template<int rank>
struct A { };
template<int rank>
struct Field {
void dot(A<rank>) requires (rank == 1) { (void)(1); }
void dot(A<rank>) requires (rank == 2) { (void)(2); }
};
template struct Field<1>;
int main() {}
yielding the following error on Clang:
error: definition with same mangled name '_ZN5FieldILi1EE3dotE1AILi1EE' as another definition
void dot(A<rank>) requires (rank == 2) { }
Note that we may provide an explicit instantiation definition for, particularly, the dot non-template member of the Field class template for a given specialization of the latter, and GCC and Clang will happily accept it, indicating that the constraint expressions are respected when explicitly instantiating the overloaded, constrained functions:
// OK.
template<int rank>
struct A { };
template<int rank>
struct Field {
void dot(A<rank>) requires (rank == 1) { (void)(1); }
void dot(A<rank>) requires (rank == 2) { (void)(2); }
};
template void Field<1>::dot(A<1>);
int main() {}
but not when they are, as described above, implicitly given explicit instantiated definitions as per the [temp.explicit]/12 quote above, as this seems to provide separate instantiation definitions for both members (without respecting the constraint expression) and thus violating ODR.
The different behaviour from the compilers between the explicit instantiation definition of the class template specialization vs a non-template member function of the specialization is somewhat peculiar, but possibly the difference is that for the latter case, [temp.constr.constr]/2 applies [emphasis mine]
[...] Overload resolution requires the satisfaction of constraints on functions and function templates.
If we only declare but don't define the second overload, it will not be instantiated as part of the explicit instantiation definition (i.e., [temp.explicit]/12 does not apply for it) of Field<1>, and we will no longer have an ODR-violation:
// OK.
template<int rank>
struct A { };
template<int rank>
struct Field {
void dot(A<rank>) requires (rank == 1) { (void)(1); }
void dot(A<rank>) requires (rank == 2);
};
template struct Field<1>;
int main() {}
Now, why is this not failing for an implicit instantiation?
As per [temp.inst]/3 [emphasis mine]:
The implicit instantiation of a class template specialization causes
(3.1) the implicit instantiation of the declarations, but not of the
definitions, of the non-deleted class member functions, member
classes, scoped member enumerations, static data members, member
templates, and friends; and [...]
such that the following example is accepted by both Clang and GCC:
template<int rank>
struct A { };
template<int rank>
struct Field {
void dot(A<rank>) requires (rank == 1) { (void)(1); }
void dot(A<rank>) requires (rank == 2) { (void)(2); }
};
int main() {
Field<1> f{};
(void)f;
}
where, as per [temp.inst]/4, the dot overloads will not be instantiated as the Field<1> specialization is not referenced in a context that requires their definitions to exist.
Finally, however, we may note that the implicit instantiation of the dot static member function of the Field class template will respect the constraint expression, and instantiate the overload which fulfills the constraint on the rank non template parameter of the particular class template specialization:
#include <iostream>
template<int rank>
struct A { };
template<int rank>
struct Field {
void dot(A<rank>) requires (rank == 1) { std::cout << "1"; }
void dot(A<rank>) requires (rank == 2) { std::cout << "2"; }
};
int main() {
Field<1>{}.dot(A<1>{}); // "1"
}
This is likely governed by [temp.constr.constr]/2, as quoted above.
