Add a note that points to the linkage specifier for the "must have C++ linkage" errors

[arphaman]

Summary

This patch improves the "must have C++ linkage" error diagnostics for C++ by adding an additional note that points to the appropriate extern "C" linkage specifier. This patch covers the diagnostics for templates and literal operators, which AFAIK are the only declarations that emit this particular kind of error. Please let me know if you think there are errors for other C++ declarations that require similar changes.

[erik.pilkington]

lib/Sema/SemaTemplate.cpp

5946

Can you update the name of this diagnostic to not mention modules, now that we use it more generally?

[arphaman]

The updated patch renames the note diagnostic to a more generic rename.

[rjmccall]

LGTM.

include/clang/AST/DeclBase.h

public:
   /// Examples of transparent contexts include: enumerations (except for
   /// C++0x scoped enums), and C++ linkage specifications.
   bool isTransparentContext() const;
 
   /// \brief Determines whether this context or some of its ancestors is a
   /// linkage specification context that specifies C linkage.
   bool isExternCContext() const;
 
+  /// \brief Retrieve the nearest enclosing C linkage specification context.
+  const LinkageSpecDecl *getExternCContext() const;
+
   /// \brief Determines whether this context or some of its ancestors is a
   /// linkage specification context that specifies C++ linkage.
   bool isExternCXXContext() const;
 
   /// \brief Determine whether this declaration context is equivalent
   /// to the declaration context DC.
   bool Equals(const DeclContext *DC) const {
     return DC && this->getPrimaryContext() == DC->getPrimaryContext();

lib/AST/DeclBase.cpp

static bool isLinkageSpecContext(const DeclContext *DC,
   }
   return false;
 }
 
 bool DeclContext::isExternCContext() const {
   return isLinkageSpecContext(this, clang::LinkageSpecDecl::lang_c);
 }
 
+const LinkageSpecDecl *DeclContext::getExternCContext() const {
+  const DeclContext *DC = this;
+  while (DC->getDeclKind() != Decl::TranslationUnit) {
+    if (DC->getDeclKind() == Decl::LinkageSpec &&
+        cast<LinkageSpecDecl>(DC)->getLanguage() ==
+            clang::LinkageSpecDecl::lang_c)
+      return cast<LinkageSpecDecl>(DC);
+    DC = DC->getLexicalParent();
+  }
+  return nullptr;
+}
+
 bool DeclContext::isExternCXXContext() const {
   return isLinkageSpecContext(this, clang::LinkageSpecDecl::lang_cxx);
 }
 
 bool DeclContext::Encloses(const DeclContext *DC) const {
   if (getPrimaryContext() != this)
     return getPrimaryContext()->Encloses(DC);
 

lib/Sema/SemaDeclCXX.cpp

   if (isa<CXXMethodDecl>(FnDecl)) {
     Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
       << FnDecl->getDeclName();
     return true;
   }
 
   if (FnDecl->isExternC()) {
     Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
+    if (const LinkageSpecDecl *LSD =
+            FnDecl->getDeclContext()->getExternCContext())
+      Diag(LSD->getExternLoc(), diag::note_module_import_in_extern_c);
     return true;
   }
 
   // This might be the definition of a literal operator template.
   FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();
 
   // This might be a specialization of a literal operator template.
   if (!TpDecl)

lib/Sema/SemaTemplate.cpp

Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
   // 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())
-    return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
-             << TemplateParams->getSourceRange();
+  if (Ctx && Ctx->isExternCContext()) {
+    Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
+    if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
+      Diag(LSD->getExternLoc(), diag::note_module_import_in_extern_c);
+    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;

test/CXX/over/over.oper/over.literal/p6.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 
+// expected-note@+1 {{extern "C" language linkage specification begins here}}
 extern "C" void operator "" _a(const char *); // expected-error {{must have C++ linkage}}
 extern "C" template<char...> void operator "" _b(); // expected-error {{must have C++ linkage}}
+// expected-note@-1 {{extern "C" language linkage specification begins here}}
 
-extern "C" {
+extern "C" { // expected-note 4 {{extern "C" language linkage specification begins here}}
   void operator "" _c(const char *); // expected-error {{must have C++ linkage}}
   template<char...> void operator "" _d(); // expected-error {{must have C++ linkage}}
   namespace N {
     void operator "" _e(const char *); // expected-error {{must have C++ linkage}}
     template<char...> void operator "" _f(); // expected-error {{must have C++ linkage}}
   }
 }

test/SemaCXX/cxx0x-defaulted-functions.cpp

namespace PR14577 {
 
   template<typename T>
   Outer<T>::Inner1<T>::~Inner1() = delete; // expected-error {{nested name specifier 'Outer<T>::Inner1<T>::' for declaration does not refer into a class, class template or class template partial specialization}}  expected-error {{only functions can have deleted definitions}}
 
   template<typename T>
   Outer<T>::Inner2<T>::~Inner2() = default; // expected-error {{nested name specifier 'Outer<T>::Inner2<T>::' for declaration does not refer into a class, class template or class template partial specialization}}  expected-error {{only special member functions may be defaulted}}
 }
 
-extern "C" {
+extern "C" { // expected-note {{extern "C" language linkage specification begins here}}
  template<typename _Tp> // expected-error {{templates must have C++ linkage}}
  void PR13573(const _Tp&) = delete;
 }
 
 namespace PR15597 {
   template<typename T> struct A {
     A() noexcept(true) = default;
     ~A() noexcept(true) = default;

test/SemaTemplate/class-template-decl.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template<typename T> class A;
 
 extern "C++" {
   template<typename T> class B;
 }
 
 namespace N {
   template<typename T> class C;
 }
 
-extern "C" {
+extern "C" { // expected-note {{extern "C" language linkage specification begins here}}
   template<typename T> class D; // expected-error{{templates must have C++ linkage}}
 }
 
-extern "C" {
+extern "C" { // expected-note 2 {{extern "C" language linkage specification begins here}}
   class PR17968 {
     template<typename T> class D; // expected-error{{templates must have C++ linkage}}
     template<typename T> void f(); // expected-error{{templates must have C++ linkage}}
   };
 }
 
 template<class U> class A; // expected-note{{previous template declaration is here}}
 
struct U {
       template<typename T> struct J { // ok
       };
       template<typename T> friend struct K; // ok, redecl::K
     };
   };
 }
 
 extern "C" template <typename T> // expected-error{{templates must have C++ linkage}}
-void DontCrashOnThis() {
+void DontCrashOnThis() { // expected-note@-1 {{extern "C" language linkage specification begins here}}
   T &pT = T();
   pT;
 }
 
 namespace abstract_dependent_class {
   template<typename T> struct A {
     virtual A<T> *clone() = 0; // expected-note {{pure virtual}}
   };
   template<typename T> A<T> *A<T>::clone() { return new A<T>; } // expected-error {{abstract class type 'A<T>'}}
 }