I thought g++ used to warn for this:

template <typename T>
class foo { };

template<> class foo<int> { };

template class foo<int>;

Where the error was something informative like "one may not explicitly specialize and explicitly instantiate" blah blah blah

However, mainline currently does not do this.

From 14.7

-5- No program shall explicitly instantiate any template more than once, both explicitly instantiate and explicitly specialize a template, or specialize a template more than once for a given set of template-arguments. An implementation is not required to diagnose a violation of this rule.

So, this is not required by the standard. As a QoI issue, however, this would be  beneficial. 

Here's why I wanted this: if one is doing API testing, and the API requires explicit specializations, than one possible negative test is to explicitly instantiate the required specialization and get an error. 

Otherwise, I suppose another neg test is to redefine the specialization. This is also not required to give an error, but current g++ does (redefinition error). 

Note also, no diagnostic for duplicate explicit instantiations:

template <typename T>
class foo { };

template class foo<int>;
template class foo<int>;


Either of these or all may be a warning regressions (if my mind is not playing tricks on me.)

I have not tested with other compilers, or previous g++ versions.

Consistent behavior for all three cases would be appreciated.