[MSVC] Explicit specializations can be declared in any namespace (fix for http://llvm.org/PR13738)

[alexfrol]

Summary

MS compiler emits no errors in case of explicit specializations outside declaration enclosing namespaces, even when language extensions are disabled.
The patch is to suppress errors and emit extension warnings if explicit specializations are not declared in the corresponding namespaces.

This fixes PR13738.

[dblaikie]

Test case? Also I think we're trying to avoid implementing every random
extension from msvc, preferring to update choose where the number of
instances of code relying on the extension is small (& not in a platform
header) - do you have a particular case where this shows up a lot (such
that it's a substaintial burden to update the code to be conforming)?

I might be wrong about this, so others may come in to correct me, that's
just my vague understanding

[alexfrol]

What would you recommend to do with http://llvm.org/PR13738 then?

[rnk]

This seems like a pretty reasonable compatibility hack, given that we already recover from the error gracefully. Richard?

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

5889

Hm, I guess we already recover from this error.

[rsmith]

Yes, given that we already support this for error recovery, this seems to be exceptionally low-cost. I'm fine with supporting this as an extension.

[rsmith]

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

5840

Since this is a non-heinous, conforming extension (and even something that's been suggested for standardization), should it go under -fms-extensions not -fms-compatibility?

[alexfrol]

Update after review.

[rnk]

lgtm

llvm/tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx98_compat_template_spec_decl_out_of_scope : Warning<
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 outside namespace %2 is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_template_spec_redecl_out_of_scope : Error<
   "%select{class template|class template partial|variable template|"
   "variable template partial|function template|member "
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 not in a namespace enclosing %2">;
+def ext_ms_template_spec_redecl_out_of_scope: ExtWarn<
+  "%select{class template|class template partial|variable template|"
+  "variable template partial|function template|member "
+  "function|static data member|member class|member enumeration}0 "
+  "specialization of %1 outside namespace enclosing %2 "
+  "is a Microsoft extension">, InGroup<Microsoft>;
 def err_template_spec_redecl_global_scope : Error<
   "%select{class template|class template partial|variable template|"
   "variable template partial|function template|member "
   "function|static data member|member class|member enumeration}0 "
   "specialization of %1 must occur at global scope">;
 def err_spec_member_not_instantiated : Error<
   "specialization of member %q0 does not specialize an instantiated member">;
 def note_specialized_decl : Note<"attempt to specialize declaration here">;

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

static bool CheckTemplateSpecializationScope(Sema &S,
   if (!DC->Encloses(SpecializedContext) &&
       !(isa<FunctionTemplateDecl>(Specialized) ||
         isa<FunctionDecl>(Specialized) ||
         isa<VarTemplateDecl>(Specialized) ||
         isa<VarDecl>(Specialized))) {
     if (isa<TranslationUnitDecl>(SpecializedContext))
       S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
         << EntityKind << Specialized;
-    else if (isa<NamespaceDecl>(SpecializedContext))
-      S.Diag(Loc, diag::err_template_spec_redecl_out_of_scope)
-        << EntityKind << Specialized
+    else if (isa<NamespaceDecl>(SpecializedContext)) {
+      int Diag = diag::err_template_spec_redecl_out_of_scope;
+      if (S.getLangOpts().MSVCCompat)
+        Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
+      S.Diag(Loc, Diag) << EntityKind << Specialized
                         << cast<NamedDecl>(SpecializedContext);
-    else
+    } else
       llvm_unreachable("unexpected namespace context for specialization");
 
     S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
   } else if ((!PrevDecl ||
               getTemplateSpecializationKind(PrevDecl) == TSK_Undeclared ||
               getTemplateSpecializationKind(PrevDecl) ==
                   TSK_ImplicitInstantiation)) {
     // C++ [temp.exp.spec]p2:
if (!DC->InEnclosingNamespaceSetOf(SpecializedContext)) {
         S.Diag(Loc, Diag)
           << EntityKind << Specialized << cast<NamedDecl>(SpecializedContext);
       }
 
       S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
     }
   }
 
   return false;
 }
 
 static SourceRange findTemplateParameter(unsigned Depth, Expr *E) {
   if (!E->isInstantiationDependent())
     return SourceLocation();
   DependencyChecker Checker(Depth);
   Checker.TraverseStmt(E);
   if (Checker.Match && Checker.MatchLoc.isInvalid())

llvm/tools/clang/test/SemaTemplate/ext_ms_template_spec.cpp

+// RUN: %clang_cc1 -fsyntax-only -fms-compatibility -std=c++11 -verify %s
+
+namespace A {
+
+template <class T>
+class ClassTemplate; // expected-note {{explicitly specialized declaration is here}}
+
+template <class T1, class T2>
+class ClassTemplatePartial; // expected-note {{explicitly specialized declaration is here}}
+
+template <typename T> struct X {
+  struct MemberClass; // expected-note {{explicitly specialized declaration is here}}
+  enum MemberEnumeration; // expected-note {{explicitly specialized declaration is here}}
+};
+
+}
+
+namespace B {
+
+template <>
+class A::ClassTemplate<int>; // expected-warning {{class template specialization of 'ClassTemplate' outside namespace enclosing 'A' is a Microsoft extension}}
+
+template <class T1>
+class A::ClassTemplatePartial<T1, T1 *> {}; // expected-warning {{class template partial specialization of 'ClassTemplatePartial' outside namespace enclosing 'A' is a Microsoft extension}}
+
+template <>
+struct A::X<int>::MemberClass; // expected-warning {{member class specialization of 'MemberClass' outside namespace enclosing 'A' is a Microsoft extension}}
+
+template <>
+enum A::X<int>::MemberEnumeration; // expected-warning {{member enumeration specialization of 'MemberEnumeration' outside namespace enclosing 'A' is a Microsoft extension}}
+
+}
+