[Sema] Diagnose template specializations with C linkage

[miyuki]

Summary

[Sema] Diagnose template specializations with C linkage

According to the C++ standard, templates as well as their
specializations cannot have C language linkage. Clang currently does
not diagnose function template specializations and class template
specializations with C linkage.

This patch implements such a diagnostic and adds tests for it.

[rogfer01]

lib/Sema/SemaTemplate.cpp

7087

Can you add a test for a partial specialization? Your test for the class case only includes an explicit specialization.

template <typename T>
struct A { };

extern "C" { 

template <typename T>   // I'd expect a diagnostic around here
struct A<T*>
{
};

}

[miyuki]

lib/Sema/SemaTemplate.cpp

7087

Currently the location used for template specialization-related diagnostics is on the next line, e.g.:

/work/llvm/src/tools/clang/test/SemaTemplate/class-template-spec.cpp:242:10: error: templates must have C++ linkage
  struct C<T*> {};
         ^

Do we want to use a different location for this particular diagnostic?

[rogfer01]

lib/Sema/SemaTemplate.cpp

7087

Oh sorry, I was not precise when I put that example. I don't think it should be different in this case.

[miyuki]

Added a test for partial specialization.

[faisalv]

lib/Sema/SemaTemplate.cpp

7095

What do you think about factoring this out into a separate function that is then called both from here and CheckTemplateDeclScope (since it is exactly the same code?)

[sepavloff]

Is it correct to emit error in this case?

According to the Standard 10.5p1 "All function types, function names with external linkage, and variable names with external linkage have a language linkage". So templates do not have a language linkage.
The next paragraph, which introduces inkage-specification, states: "The string-literal indicates the required language linkage". So the construct extern "C" specifies just language linkage, which is not pertinent to templates.

In 10.5p4 there is an example of a class defined in extern "C" construct:

extern "C" {
  class X {
    void mf(); // the name of the function mf and the member function’s type have
               // C++ language linkage
    void mf2(void(*)()); // the name of the function mf2 has C++ language linkage;
                         // the parameter has type “pointer to C function”
  };
}

Classes do not have language linkage according to 10.5p1, just as templates, so this code is valid.

It looks like defining templates inside extern "C" blocks is OK.

[miyuki]

Factored out template language linkage check into a separate function

[miyuki]

In D41179#957992, @sepavloff wrote:

Classes do not have language linkage according to 10.5p1, just as templates, so this code is valid.

It looks like defining templates inside extern "C" blocks is OK.

Currently both Clang and GCC diagnose class templates declared inside an 'extern "C"' block. I'm not sure how to proceed about this.

[faisalv]

In D41179#964522, @miyuki wrote:

In D41179#957992, @sepavloff wrote:

Classes do not have language linkage according to 10.5p1, just as templates, so this code is valid.

It looks like defining templates inside extern "C" blocks is OK.

Currently both Clang and GCC diagnose class templates declared inside an 'extern "C"' block. I'm not sure how to proceed about this.

Given that Clause 17 p6 specifically uses 'shall' to call out templates - i believe the implementation is expected to diagnose this. 10.5p1 (or is there another mention in the standard?) does not explicitly call out 'classes' as not having c language linkage - so implementations can get away not diagnosing this - and perhaps even allow classes to have language linkage on certain implementations?? (at least that's my squinty interpretation)

[sepavloff]

In D41179#964526, @faisalv wrote:

In D41179#964522, @miyuki wrote:

In D41179#957992, @sepavloff wrote:

Classes do not have language linkage according to 10.5p1, just as templates, so this code is valid.

It looks like defining templates inside extern "C" blocks is OK.

Currently both Clang and GCC diagnose class templates declared inside an 'extern "C"' block. I'm not sure how to proceed about this.

Given that Clause 17 p6 specifically uses 'shall' to call out templates - i believe the implementation is expected to diagnose this. 10.5p1 (or is there another mention in the standard?) does not explicitly call out 'classes' as not having c language linkage - so implementations can get away not diagnosing this - and perhaps even allow classes to have language linkage on certain implementations?? (at least that's my squinty interpretation)

This is a strange clause. The language linkage describes cases when an entity defined in one TU is identical to another entity in another TU implemented in different language. As templates have no meaning outside C++, so they merely cannot have C linkage.

I guess the statement about C linkage in 17p6 is a remnant of those times when template were allowed to have export specifier. In that case templates would have external representation and in principle could be used in non C++ compilation.

Maybe @rsmith could clarify this point?

[miyuki]

ping

[miyuki]

ping^2

[miyuki]

Abandoning in favour of:

commit a64883431369f28f3fac311c496a4dfad480058f
Author: Richard Smith <[e-mail]>
Date: Wed Jul 29 16:49:05 2020 -0700

PR46729: Reject explicit and partial specializations with C linkage.

lib/Sema/SemaTemplate.cpp

if (Complain)
                                                  TemplateArgLoc);
 
     return false;
   }
 
   return true;
 }
 
+/// \brief Check whether a template is declared with "C" language linkage.
+///
+/// If a template or a template specialization is declared with "C" language
+/// linkage, issues a diagnostic and returns true. Otherwise, returns false.
+static bool
+CheckTemplateLanguageLinkage(Sema &S, DeclContext *Ctx, SourceRange Rng) {
+  if (Ctx && Ctx->isExternCContext()) {
+    S.Diag(Rng.getBegin(), diag::err_template_linkage) << Rng;
+    if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
+      S.Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
+    return true;
+  }
+  return false;
+}
+
 /// \brief Check whether a template can be declared within this scope.
 ///
 /// If the template declaration is valid in this scope, returns
 /// false. Otherwise, issues a diagnostic and returns true.
 bool
 Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
   if (!S)
     return false;
 
   // Find the nearest enclosing declaration scope.
   while ((S->getFlags() & Scope::DeclScope) == 0 ||
          (S->getFlags() & Scope::TemplateParamScope) != 0)
     S = S->getParent();
 
   // C++ [temp]p4:
   //   A template [...] shall not have C linkage.
   DeclContext *Ctx = S->getEntity();
-  if (Ctx && Ctx->isExternCContext()) {
-    Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
-        << TemplateParams->getSourceRange();
-    if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
-      Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
+  if (CheckTemplateLanguageLinkage(*this, Ctx,
+                                   TemplateParams->getSourceRange()))
     return true;
-  }
+
   Ctx = Ctx->getRedeclContext();
 
   // C++ [temp]p2:
   //   A template-declaration can appear only as a namespace scope or
   //   class scope declaration.
   if (Ctx) {
     if (Ctx->isFileContext())
       return false;
else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
     EntityKind = 8;
   else {
     S.Diag(Loc, diag::err_template_spec_unknown_kind)
       << S.getLangOpts().CPlusPlus11;
     S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
     return true;
   }
 
+  // C++ [temp]p6:
+  //   A template, a template explicit specialization, and a class template
+  //   partial specialization shall not have C linkage.
+  if (CheckTemplateLanguageLinkage(S, S.CurContext, Loc))
+    return true;
+
   // C++ [temp.expl.spec]p2:
   //   An explicit specialization shall be declared in the namespace
   //   of which the template is a member, or, for member templates, in
   //   the namespace of which the enclosing class or enclosing class
   //   template is a member. An explicit specialization of a member
   //   function, member class or static data member of a class
   //   template shall be declared in the namespace of which the class
   //   template is a member. Such a declaration may also be a
   //   definition. If the declaration is not a definition, the
   //   specialization may be defined later in the name- space in which
   //   the explicit specialization was declared, or in a namespace
   //   that encloses the one in which the explicit specialization was

test/SemaTemplate/class-template-spec.cpp

namespace DefaultArgVsPartialSpec {
   > struct X {};
   template<typename T> struct X<T> {};
 
   template<typename T,
       T N = 0 // expected-note {{template parameter is declared here}}
   > struct S;
   template<typename T> struct S<T> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'T'}}
 }
+
+template<typename T> struct C {};
+extern "C" { // expected-note 2{{extern "C" language linkage specification begins here}}
+  template<typename T> struct C<T*> {}; // expected-error{{templates must have C++ linkage}}
+  template<> struct C<int> {}; // expected-error{{templates must have C++ linkage}}
+}

test/SemaTemplate/function-template-specialization.cpp

 class Foo {
   template<class T>
   static void Bar(const T& input);
 
   // Don't crash here.
   template<>
   static void Bar(const long& input) {}  // expected-error{{explicit specialization of 'Bar' in class scope}}
 };
+
+template<typename T> void f3(T) {}
+extern "C" { // expected-note {{extern "C" language linkage specification begins here}}
+  template<> void f3(int) {} // expected-error{{templates must have C++ linkage}}
+}