Warn if variable cannot be implicitly instantiated

[sepavloff]

Summary

Instantiation of static class members may be a source of user misunderstanding,
especially in the case of using modules, PR24425 describes one of such examples.
This patch implements warning if compiler tried to make implicit instantiation
but could not find template definition. The implementation follows discussion
of http://reviews.llvm.org/D12326.

[sepavloff]

Any feedback?

Thanks,
--Serge

[rsmith]

Are you planning on extending this to also cover templated functions?

include/clang/Basic/DiagnosticGroups.td

78

undefined rather than unavailable? "unavailable" means something different in Clang.

include/clang/Basic/DiagnosticSemaKinds.td

3888

not found -> not defined? The template is found, or the code would be ill-formed.

Also, 'corresponding template' isn't quite right; in S<int>::m, the template is S, which must be defined. Maybe you could map to the pattern declaration for the instantiation, and warn that it isn't defined, so we'd say something like

"instantiation of 'S<int>::m' required here, but 'S<T>::m' is not defined"

lib/Sema/SemaTemplateInstantiateDecl.cpp

4102

Explicit instantiation declarations are a C++11 feature. Should we suppress this warning, or at least the note, in C++98?

[sepavloff]

Updated patch according to review notes.

The patch adds diagnostics for undefined function templates, in a similar way
as for template variables. These two warnings are classified into different groups.
Warnings on undefined variable templates are enabled by default. This is more
error-prone case, existence of PR24425 may be considered as an evidence. Warnings
on undefined function templates are off by default. If it is enabled,
about 80 tests require update.

References to template declarations can now be printed in two ways. The usual way
is to print only names, such as 'C1::C2', it is compact and convenient when the
reference occurs inside template definition. The patch adds new format, in which
template parameters are also printed, like 'C1<T>::C2<T1,N1>', it can be more
convenient if the template is referenced from outside.

[rsmith]

I would prefer to avoid adding the %qt format if we can. But if we do provide it, the template parameter names we use should match what was written in the declaration of the template itself.

lib/AST/Decl.cpp

1423

Presumably you mean C1<T, Val>::C2<T1, TC>::meth<T2>?

1447

Please don't invent a name here. If you really want this formatting for template names, please query the TemplateDecl to find the names that were used when declaring its parameters.

1464

This doesn't make sense: a template template argument is passed as a template, but adding <> would make it a type instead. Remove this.

lib/Sema/SemaTemplateInstantiateDecl.cpp

3611

Please produce a note pointing at the declaration of the undefined template. With a bit of rewording the diagnostics, I think you can remove the need for the %qt format entirely:

warning: instantiation for 'X<int>::f<double>' is required but no definition is available
  X<int>::f(0.0);
          ^
note: forward declaration of template entity is here
  template<typename T> void f(T);
                            ^
note: add an explicit instantiation declaration to suppress this warning if 'X<int>::f<double>' is explicitly instantiated in another translation unit

[sepavloff]

Updated patch

Get rid of '%qt' format, instead print template parameters always. It requires
about 10 tests to be fixed. However printing parameters still can be suppressed,
it is required for proper work of AST matchers, - a matcher may want to match
names like 'Y::f' where 'Y' is a template. Template parameters are printed as
they were written in template declarations.

[rsmith]

I have a lingering concern with this style of formatting, because it risks making our diagnostics (more) ambiguous. Consider this:

template<typename T> struct X {};

struct T {};
X<T> xt;

If we give a diagnostic talking about X<T>, it's ambiguous whether we're referring to the X template itself or the concrete type of xt. That said, the actual diagnostic changes here do look like improvements, particularly because the template parameter names we're using are typically in scope at the point where we issue the diagnostic (so there is no ambiguity). On the whole, I think the risk of ambiguity is less than the benefit here.

lib/Sema/SemaTemplateInstantiateDecl.cpp

3611

I would still like this note to be added to the diagnostic.

test/OpenMP/parallel_ast_print.cpp

135

This looks like an undesirable change. Can you turn off PrintTemplateArguments by default and turn it on only for %t in diagnostics?

[sepavloff]

Updated patch

Changed text of messages as proposed by reviewer. As a result, printing
template parameters is not needed anymore, related code is removed.

[rsmith]

Thanks!

include/clang/AST/ASTContext.h

template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
     return getParents(ast_type_traits::DynTypedNode::create(Node));
   }
 
   DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);
 
   const clang::PrintingPolicy &getPrintingPolicy() const {
     return PrintingPolicy;
   }
+  clang::PrintingPolicy &getPrintingPolicy() { return PrintingPolicy; }
 
   void setPrintingPolicy(const clang::PrintingPolicy &Policy) {
     PrintingPolicy = Policy;
   }
   
   SourceManager& getSourceManager() { return SourceMgr; }
   const SourceManager& getSourceManager() const { return SourceMgr; }
 

include/clang/AST/PrettyPrinter.h

struct PrintingPolicy {
   PrintingPolicy(const LangOptions &LO)
     : LangOpts(LO), Indentation(2), SuppressSpecifiers(false),
       SuppressTagKeyword(false),
       IncludeTagDefinition(false), SuppressScope(false),
       SuppressUnwrittenScope(false), SuppressInitializers(false),
       ConstantArraySizeAsWritten(false), AnonymousTagLocations(true),
       SuppressStrongLifetime(false), SuppressLifetimeQualifiers(false),
       SuppressTemplateArgsInCXXConstructors(false),
+      PrintTemplateParameters(false),
       Bool(LO.Bool), TerseOutput(false), PolishForDeclaration(false),
       Half(LO.Half), MSWChar(LO.MicrosoftExt && !LO.WChar),
       IncludeNewlines(true), MSVCFormatting(false) { }
 
   /// \brief What language we're printing.
   LangOptions LangOpts;
 
   /// \brief The number of spaces to use to indent each line.
struct PrintingPolicy {
   /// \brief When true, suppress printing of lifetime qualifier in
   /// ARC.
   unsigned SuppressLifetimeQualifiers : 1;
 
   /// When true, suppresses printing template arguments in names of C++
   /// constructors.
   unsigned SuppressTemplateArgsInCXXConstructors : 1;
 
+  /// \brief When true, a template declaration name is printed with parameters,
+  /// e.g. 'C1<T>::C2<T1,N1>' instead of 'C1::C2'.
+  bool PrintTemplateParameters : 1;
+
   /// \brief Whether we can use 'bool' rather than '_Bool', even if the language
   /// doesn't actually have 'bool' (because, e.g., it is defined as a macro).
   unsigned Bool : 1;
 
   /// \brief Provide a 'terse' output.
   ///
   /// For example, in this mode we don't print function bodies, class members,
   /// declarations inside namespaces etc.  Effectively, this should print

include/clang/Basic/DiagnosticGroups.td

 def Comment : DiagGroup<"comment">;
 def GNUComplexInteger : DiagGroup<"gnu-complex-integer">;
 def GNUConditionalOmittedOperand : DiagGroup<"gnu-conditional-omitted-operand">;
 def ConfigMacros : DiagGroup<"config-macros">;
 def : DiagGroup<"ctor-dtor-privacy">;
 def GNUDesignator : DiagGroup<"gnu-designator">;
 def GNUStringLiteralOperatorTemplate :
   DiagGroup<"gnu-string-literal-operator-template">;
+def UndefinedVarTemplate : DiagGroup<"undefined-var-template">;
+def UndefinedFuncTemplate : DiagGroup<"undefined-func-template">;
 
 def DeleteIncomplete : DiagGroup<"delete-incomplete">;
 def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">;
 def AbstractFinalClass : DiagGroup<"abstract-final-class">;
 
 def CXX11CompatDeprecatedWritableStr :
   DiagGroup<"c++11-compat-deprecated-writable-strings">;
 

include/clang/Basic/DiagnosticSemaKinds.td

 def note_template_enum_def_here : Note<
   "in instantiation of enumeration %q0 requested here">;
 def note_template_nsdmi_here : Note<
   "in instantiation of default member initializer %q0 requested here">;
 def note_template_type_alias_instantiation_here : Note<
   "in instantiation of template type alias %0 requested here">;
 def note_template_exception_spec_instantiation_here : Note<
   "in instantiation of exception specification for %0 requested here">;
-  
+def warn_var_template_missing : Warning<"instantiation of variable %q0 "
+  "required here, but %qt1 is not defined">, InGroup<UndefinedVarTemplate>;
+def warn_func_template_missing : Warning<"instantiation of function %q0 "
+  "required here, but %qt1 is not defined">, InGroup<UndefinedFuncTemplate>,
+  DefaultIgnore;
+def note_inst_declaration_hint : Note<"add an explicit instantiation "
+  "declaration to suppress this warning if %q0 is explicitly instantiated in "
+  "another translation unit">;
 def note_default_arg_instantiation_here : Note<
   "in instantiation of default argument for '%0' required here">;
 def note_default_function_arg_instantiation_here : Note<
   "in instantiation of default function argument expression "
   "for '%0' required here">;
 def note_explicit_template_arg_substitution_here : Note<
   "while substituting explicitly-specified template arguments into function "
   "template %0 %1">;

include/clang/Sema/Sema.h

bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
              TemplateArgumentListInfo &Result,
              const MultiLevelTemplateArgumentList &TemplateArgs);
 
   void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                 FunctionDecl *Function);
   void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                      FunctionDecl *Function,
                                      bool Recursive = false,
-                                     bool DefinitionRequired = false);
+                                     bool DefinitionRequired = false,
+                                     bool AtEndOfTU = false);
   VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
       VarTemplateDecl *VarTemplate, VarDecl *FromVar,
       const TemplateArgumentList &TemplateArgList,
       const TemplateArgumentListInfo &TemplateArgsInfo,
       SmallVectorImpl<TemplateArgument> &Converted,
       SourceLocation PointOfInstantiation, void *InsertPos,
       LateInstantiatedAttrVec *LateAttrs = nullptr,
       LocalInstantiationScope *StartingScope = nullptr);
   VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
       VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
       const MultiLevelTemplateArgumentList &TemplateArgs);
   void
   BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
                              const MultiLevelTemplateArgumentList &TemplateArgs,
                              LateInstantiatedAttrVec *LateAttrs,
                              DeclContext *Owner,
                              LocalInstantiationScope *StartingScope,
                              bool InstantiatingVarTemplate = false);
   void InstantiateVariableInitializer(
       VarDecl *Var, VarDecl *OldVar,
       const MultiLevelTemplateArgumentList &TemplateArgs);
   void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
                                      VarDecl *Var, bool Recursive = false,
-                                     bool DefinitionRequired = false);
+                                     bool DefinitionRequired = false,
+                                     bool AtEndOfTU = false);
   void InstantiateStaticDataMemberDefinition(
                                      SourceLocation PointOfInstantiation,
                                      VarDecl *Var,
                                      bool Recursive = false,
                                      bool DefinitionRequired = false);
 
   void InstantiateMemInitializers(CXXConstructorDecl *New,
                                   const CXXConstructorDecl *Tmpl,

lib/AST/ASTDiagnostic.cpp

ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
   return S;
 }
 
 static bool FormatTemplateTypeDiff(ASTContext &Context, QualType FromType,
                                    QualType ToType, bool PrintTree,
                                    bool PrintFromType, bool ElideType,
                                    bool ShowColors, raw_ostream &OS);
 
+namespace {
+/// \brief Helper class to restore PrintingPolicy::PrintTemplateParameters, when
+/// it temporary changes.
+struct SavedPrintTemplParamFlag {
+  PrintingPolicy &PPolicy;
+  bool SavedValue;
+  SavedPrintTemplParamFlag(PrintingPolicy &P) : PPolicy(P),
+    SavedValue(P.PrintTemplateParameters) {}
+  ~SavedPrintTemplParamFlag() { PPolicy.PrintTemplateParameters = SavedValue; }
+};
+}
+
 void clang::FormatASTNodeDiagnosticArgument(
     DiagnosticsEngine::ArgumentKind Kind,
     intptr_t Val,
     StringRef Modifier,
     StringRef Argument,
     ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
     SmallVectorImpl<char> &Output,
     void *Cookie,
case DiagnosticsEngine::ak_declarationname: {
         assert(Modifier.empty() && Argument.empty() &&
                "Invalid modifier for DeclarationName argument");
 
       OS << DeclarationName::getFromOpaqueInteger(Val);
       break;
     }
     case DiagnosticsEngine::ak_nameddecl: {
       bool Qualified;
+      SavedPrintTemplParamFlag PrintFlag(Context.getPrintingPolicy());
       if (Modifier == "q" && Argument.empty())
         Qualified = true;
-      else {
+      else if (Modifier == "qt" && Argument.empty()) {
+        Qualified = true;
+        Context.getPrintingPolicy().PrintTemplateParameters = true;
+      } else {
         assert(Modifier.empty() && Argument.empty() &&
                "Invalid modifier for NamedDecl* argument");
         Qualified = false;
       }
       const NamedDecl *ND = reinterpret_cast<const NamedDecl*>(Val);
       ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), Qualified);
       break;
     }

lib/AST/Decl.cpp

std::string NamedDecl::getQualifiedNameAsString() const {
   printQualifiedName(OS, getASTContext().getPrintingPolicy());
   return OS.str();
 }
 
 void NamedDecl::printQualifiedName(raw_ostream &OS) const {
   printQualifiedName(OS, getASTContext().getPrintingPolicy());
 }
 
+namespace {
+
+/// \brief Class for printing template parameters in diagnostic messages.
+///
+/// Allows a bit more readable reference to templates in the case of several
+/// template levels. For instance, a reference to the template function \c meth
+/// in the code:
+///
+/// \code
+/// template <class T, int Val> struct C1 {
+///   template<typename T1, template<typename TT> class TC> struct C2 {
+///     template <class T2> static void meth();
+///   };
+/// };
+/// \endcode
+///
+/// is printed as C1<T,N>::C2<T1,TT<>>::meth<T2> rather than C1::C2::meth.
+///
+class TemplParamPrinter {
+  unsigned TypePNo;     ///< Sequential number of type parameter.
+  unsigned NonTypePNo;  ///< Sequential number of non-type parameter.
+  unsigned TemplPNo;    ///< Sequential number of template parameter.
+  bool Enabled;         ///< If true, parameters are printed.
+
+public:
+  TemplParamPrinter(bool E)
+    : TypePNo(0), NonTypePNo(0), TemplPNo(0), Enabled(E) {}
+
+  void printTemplateParameters(raw_ostream &OS, const TemplateDecl *Templ) {
+    if (!Enabled)
+      return;
+    OS << "<";
+    TemplateParameterList *TPL = Templ->getTemplateParameters();
+    for (unsigned i = 0, e = TPL->size(); i != e; ++i) {
+      if (i != 0)
+        OS << ",";
+      const Decl *Param = TPL->getParam(i);
+      if (auto *TP = dyn_cast<TemplateTypeParmDecl>(Param)) {
+        if (TP->isParameterPack())
+          OS << "...";
+        OS << 'T';
+        if (TypePNo)
+          OS << TypePNo;
+        TypePNo++;
+      } else if (auto *NT = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+        if (NT->isParameterPack())
+          OS << "...";
+        OS << 'N';
+        if (NonTypePNo)
+          OS << NonTypePNo;
+        NonTypePNo++;
+      } else if (auto *TT = dyn_cast<TemplateTemplateParmDecl>(Param)) {
+        if (TT->isParameterPack())
+          OS << "...";
+        OS << "TT";
+        if (TemplPNo)
+          OS << TemplPNo;
+        OS << "<>";
+        TemplPNo++;
+      }
+    }
+    OS << ">";
+  }
+};
+
+}
+
 void NamedDecl::printQualifiedName(raw_ostream &OS,
                                    const PrintingPolicy &P) const {
   const DeclContext *Ctx = getDeclContext();
 
   if (Ctx->isFunctionOrMethod()) {
     printName(OS);
     return;
   }
 
   typedef SmallVector<const DeclContext *, 8> ContextsTy;
   ContextsTy Contexts;
 
   // Collect contexts.
   while (Ctx && isa<NamedDecl>(Ctx)) {
     Contexts.push_back(Ctx);
     Ctx = Ctx->getParent();
   }
 
+  TemplParamPrinter TPPrinter(P.PrintTemplateParameters);
   for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend();
        I != E; ++I) {
     if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(*I)) {
       OS << Spec->getName();
       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
       TemplateSpecializationType::PrintTemplateArgumentList(OS,
                                                             TemplateArgs.data(),
                                                             TemplateArgs.size(),
                                                             P);
     } else if (const auto *ND = dyn_cast<NamespaceDecl>(*I)) {
       if (P.SuppressUnwrittenScope &&
           (ND->isAnonymousNamespace() || ND->isInline()))
         continue;
       if (ND->isAnonymousNamespace()) {
         OS << (P.MSVCFormatting ? "`anonymous namespace\'"
                                 : "(anonymous namespace)");
       }
       else
         OS << *ND;
     } else if (const auto *RD = dyn_cast<RecordDecl>(*I)) {
       if (!RD->getIdentifier())
         OS << "(anonymous " << RD->getKindName() << ')';
-      else
+      else {
         OS << *RD;
+        if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
+          if (ClassTemplateDecl *Templ = CXXRD->getDescribedClassTemplate())
+            TPPrinter.printTemplateParameters(OS, Templ);
+      }
     } else if (const auto *FD = dyn_cast<FunctionDecl>(*I)) {
       const FunctionProtoType *FT = nullptr;
       if (FD->hasWrittenPrototype())
         FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
 
       OS << *FD << '(';
       if (FT) {
         unsigned NumParams = FD->getNumParams();
if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(*I)) {
       else
         continue;
     } else {
       OS << *cast<NamedDecl>(*I);
     }
     OS << "::";
   }
 
-  if (getDeclName())
-    OS << *this;
-  else
+  if (getDeclName()) {
+    printName(OS);
+    if (auto FD = dyn_cast<FunctionDecl>(this)) {
+      if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
+        TPPrinter.printTemplateParameters(OS, FTD);
+    } else if (auto VD = dyn_cast<VarDecl>(this)) {
+      if (const VarTemplateDecl *VTD = VD->getDescribedVarTemplate())
+        TPPrinter.printTemplateParameters(OS, VTD);
+    }
+  } else
     OS << "(anonymous)";
 }
 
 void NamedDecl::getNameForDiagnostic(raw_ostream &OS,
                                      const PrintingPolicy &Policy,
                                      bool Qualified) const {
   if (Qualified)
     printQualifiedName(OS, Policy);

lib/Sema/SemaTemplateInstantiateDecl.cpp

 /// are required by this instantiation.
 ///
 /// \param DefinitionRequired if true, then we are performing an explicit
 /// instantiation where the body of the function is required. Complain if
 /// there is no such body.
 void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                          FunctionDecl *Function,
                                          bool Recursive,
-                                         bool DefinitionRequired) {
+                                         bool DefinitionRequired,
+                                         bool AtEndOfTU) {
   if (Function->isInvalidDecl() || Function->isDefined())
     return;
 
   // Never instantiate an explicit specialization except if it is a class scope
   // explicit specialization.
   if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
       !Function->getClassScopeSpecializationPattern())
     return;
if (DefinitionRequired) {
         Diag(PatternDecl->getLocation(),
              diag::note_explicit_instantiation_here);
       Function->setInvalidDecl();
     } else if (Function->getTemplateSpecializationKind()
                  == TSK_ExplicitInstantiationDefinition) {
       assert(!Recursive);
       PendingInstantiations.push_back(
         std::make_pair(Function, PointOfInstantiation));
+    } else if (Function->getTemplateSpecializationKind()
+                 == TSK_ImplicitInstantiation) {
+      if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
+        Diag(PointOfInstantiation, diag::warn_func_template_missing)
+          << Function << PatternDecl;
+        if (getLangOpts().CPlusPlus11)
+          Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
+            << Function;
+      }
     }
 
     return;
   }
 
   // C++1y [temp.explicit]p10:
   //   Except for inline functions, declarations with types deduced from their
   //   initializer or return value, and class template specializations, other
void Sema::InstantiateStaticDataMemberDefinition(
                                                  bool Recursive,
                                                  bool DefinitionRequired) {
   InstantiateVariableDefinition(PointOfInstantiation, Var, Recursive,
                                 DefinitionRequired);
 }
 
 void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
                                          VarDecl *Var, bool Recursive,
-                                         bool DefinitionRequired) {
+                                      bool DefinitionRequired, bool AtEndOfTU) {
   if (Var->isInvalidDecl())
     return;
 
   VarTemplateSpecializationDecl *VarSpec =
       dyn_cast<VarTemplateSpecializationDecl>(Var);
   VarDecl *PatternDecl = nullptr, *Def = nullptr;
   MultiLevelTemplateArgumentList TemplateArgs =
       getTemplateInstantiationArgs(Var);
if (DefinitionRequired) {
       Diag(PatternDecl->getLocation(),
            diag::note_explicit_instantiation_here);
       if (VarSpec)
         Var->setInvalidDecl();
     } else if (Var->getTemplateSpecializationKind()
                  == TSK_ExplicitInstantiationDefinition) {
       PendingInstantiations.push_back(
         std::make_pair(Var, PointOfInstantiation));
+    } else if (Var->getTemplateSpecializationKind()
+                 == TSK_ImplicitInstantiation) {
+      // Warn about missing definition at the end of translation unit.
+      if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
+        Diag(PointOfInstantiation, diag::warn_var_template_missing)
+          << Var << PatternDecl;
+        if (getLangOpts().CPlusPlus11)
+          Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
+      }
     }
 
     return;
   }
 
   TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
 
   // Never instantiate an explicit specialization.
while (!PendingLocalImplicitInstantiations.empty() ||
 
     // Instantiate function definitions
     if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
       PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
                                           "instantiating function definition");
       bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
                                 TSK_ExplicitInstantiationDefinition;
       InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
-                                    DefinitionRequired);
+                                    DefinitionRequired, true);
       continue;
     }
 
     // Instantiate variable definitions
     VarDecl *Var = cast<VarDecl>(Inst.first);
 
     assert((Var->isStaticDataMember() ||
             isa<VarTemplateSpecializationDecl>(Var)) &&
while (!PendingLocalImplicitInstantiations.empty() ||
     PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
                                         "instantiating variable definition");
     bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
                               TSK_ExplicitInstantiationDefinition;
 
     // Instantiate static data member definitions or variable template
     // specializations.
     InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
-                                  DefinitionRequired);
+                                  DefinitionRequired, true);
   }
 }
 
 void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
                        const MultiLevelTemplateArgumentList &TemplateArgs) {
   for (auto DD : Pattern->ddiags()) {
     switch (DD->getKind()) {
     case DependentDiagnostic::Access:
       HandleDependentAccessCheck(*DD, TemplateArgs);
       break;
     }
   }
 }

test/CXX/temp/temp.decls/temp.mem/p1.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // expected-no-diagnostics
 
 template <class T> struct A {
   static T cond;
   
   template <class U> struct B {
     static T twice(U value) {
       return (cond ? value + value : value);
     }
   };
 };
+extern template bool A<bool>::cond;
 
 int foo() {
   A<bool>::cond = true;
   return A<bool>::B<int>::twice(4);
 }
 
 namespace PR6376 {
   template<typename T>

test/OpenMP/parallel_ast_print.cpp

 // CHECK-NEXT:   #pragma omp threadprivate(S<int>::TS)
 // CHECK-NEXT: }
 // CHECK:      template <class T = long> struct S {
 // CHECK:        static long TS;
 // CHECK-NEXT:   #pragma omp threadprivate(S<long>::TS)
 // CHECK-NEXT: }
 // CHECK:      template <class T> struct S {
 // CHECK:        static T TS;
 // CHECK-NEXT:   #pragma omp threadprivate(S::TS)
 // CHECK:      };
 
 template <typename T, int C>
 T tmain(T argc, T *argv) {
   T b = argc, c, d, e, f, g;
   static T a;
   S<T> s;
   T arr[C][10], arr1[C];

 #pragma omp for schedule(static)
     for (int idx = 0; idx < 1234; ++idx) {
       //arg.foo = idx;
       idx = arg.foo;
     }
   }
 }
 
+template<typename T>
+T S<T>::TS = 0;
+
 #endif

test/OpenMP/parallel_sections_ast_print.cpp

#pragma omp section
   // CHECK-NEXT: #pragma omp section
   // CHECK-NEXT: foo();
   // CHECK-NEXT: #pragma omp section
   // CHECK-NEXT: foo();
   // CHECK-NEXT: }
   return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x);
 }
 
+template<typename T>
+T S<T>::TS = 0;
+
 #endif

test/OpenMP/target_parallel_ast_print.cpp

 #pragma omp target parallel defaultmap(tofrom: scalar)
 // CHECK-NEXT: #pragma omp target parallel defaultmap(tofrom: scalar)
   foo();
 // CHECK-NEXT: foo();
 
   return tmain<int, 5>(argc, &argc) + tmain<char, 1>(argv[0][0], argv[0]);
 }
 
+extern template int S<int>::TS;
+extern template char S<char>::TS;
+
 #endif

test/OpenMP/task_ast_print.cpp

 // CHECK-NEXT: a = 2;
 #pragma omp task default(none), private(argc, b) firstprivate(argv) if (argc > 0) final(a > 0) depend(inout : a, argv[:argc],arr[:a]) priority(23)
   // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) if(argc > 0) final(a > 0) depend(inout : a,argv[:argc],arr[:a]) priority(23)
   foo();
   // CHECK-NEXT: foo();
   return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x);
 }
 
+extern template int S<int>::TS;
+extern template long S<long>::TS;
+
 #endif

test/OpenMP/teams_ast_print.cpp

 #pragma omp teams default(none), private(argc,b) num_teams(f) firstprivate(argv) reduction(| : c, d) reduction(* : e) thread_limit(f+g)
 // CHECK-NEXT: #pragma omp target
 // CHECK-NEXT: #pragma omp teams default(none) private(argc,b) num_teams(f) firstprivate(argv) reduction(|: c,d) reduction(*: e) thread_limit(f + g)
   foo();
 // CHECK-NEXT: foo();
   return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x);
 }
 
+extern template int S<int>::TS;
+extern template long S<long>::TS;
 #endif

test/OpenMP/threadprivate_ast_print.cpp

int main () {
   static int a;
 // CHECK: static int a;
 #pragma omp threadprivate(a)
 // CHECK-NEXT: #pragma omp threadprivate(a)
   a=2;
   return (foo<int>());
 }
 
+extern template int ST<int>::m;
 #endif

test/SemaCXX/PR10177.cpp

namespace N {
   int j = f<int>();
 }
 
 #else
 // expected-no-diagnostics
 
 namespace { template<typename> extern int n; }
 template<typename T> int g() { return n<int>; }
+namespace { extern template int n<int>; }
 
 #endif
 

test/SemaCXX/undefined-internal.cpp

namespace test5 {
   namespace {
     struct A {};
   }
 
   template <class N> struct B {
     static int var; // expected-warning {{variable 'test5::B<test5::(anonymous namespace)::A>::var' has internal linkage but is not defined}}
     static void foo(); // expected-warning {{function 'test5::B<test5::(anonymous namespace)::A>::foo' has internal linkage but is not defined}}
   };
+  extern template int B<A>::var;
 
   void test() {
     B<A>::var = 0; // expected-note {{used here}}
     B<A>::foo(); // expected-note {{used here}}
   }
 }
 
 namespace test6 {

test/SemaTemplate/undefined-template.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -Wundefined-func-template %s
+
+template <class T> struct C1 {
+  static char s_var_1;
+  static char s_var_2;
+  static void s_func_1();
+  static void s_func_2();
+  void meth_1();
+  void meth_2();
+  template <class T1> static char s_tvar_2;
+  template <class T1> static void s_tfunc_2();
+  template<typename T1> struct C2 {
+    static char s_var_2;
+    static void s_func_2();
+    void meth_2();
+    template <class T2> static char s_tvar_2;
+    template <class T2> void tmeth_2();
+  };
+};
+
+extern template char C1<int>::s_var_2;
+extern template void C1<int>::s_func_2();
+extern template void C1<int>::meth_2();
+extern template char C1<int>::s_tvar_2<char>;
+extern template void C1<int>::s_tfunc_2<char>();
+extern template void C1<int>::C2<long>::s_var_2;
+extern template void C1<int>::C2<long>::s_func_2();
+extern template void C1<int>::C2<long>::meth_2();
+extern template char C1<int>::C2<long>::s_tvar_2<char>;
+extern template void C1<int>::C2<long>::tmeth_2<char>();
+
+char func_01() {
+  return C1<int>::s_var_2;
+}
+
+char func_02() {
+  return C1<int>::s_var_1; // expected-warning{{instantiation of variable 'C1<int>::s_var_1' required here, but 'C1<T>::s_var_1' is not defined}}
+                           // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::s_var_1' is explicitly instantiated in another translation unit}}
+}
+
+char func_03() {
+  return C1<char>::s_var_2; // expected-warning{{instantiation of variable 'C1<char>::s_var_2' required here, but 'C1<T>::s_var_2' is not defined}}
+                            // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<char>::s_var_2' is explicitly instantiated in another translation unit}}
+}
+
+void func_04() {
+  C1<int>::s_func_1(); // expected-warning{{instantiation of function 'C1<int>::s_func_1' required here, but 'C1<T>::s_func_1' is not defined}}
+                       // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::s_func_1' is explicitly instantiated in another translation unit}}
+}
+
+void func_05() {
+  C1<int>::s_func_2();
+}
+
+void func_06() {
+  C1<char>::s_func_2(); // expected-warning{{instantiation of function 'C1<char>::s_func_2' required here, but 'C1<T>::s_func_2' is not defined}}
+                        // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<char>::s_func_2' is explicitly instantiated in another translation unit}}
+}
+
+void func_07(C1<int> *x) {
+  x->meth_1();  // expected-warning{{instantiation of function 'C1<int>::meth_1' required here, but 'C1<T>::meth_1' is not defined}}
+                // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::meth_1' is explicitly instantiated in another translation unit}}
+}
+
+void func_08(C1<int> *x) {
+  x->meth_2();
+}
+
+void func_09(C1<char> *x) {
+  x->meth_1();  // expected-warning{{instantiation of function 'C1<char>::meth_1' required here, but 'C1<T>::meth_1' is not defined}}
+                // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<char>::meth_1' is explicitly instantiated in another translation unit}}
+}
+
+char func_10() {
+  return C1<int>::s_tvar_2<char>;
+}
+
+char func_11() {
+  return C1<int>::s_tvar_2<long>; // expected-warning{{instantiation of variable 'C1<int>::s_tvar_2<long>' required here, but 'C1<T>::s_tvar_2<T1>' is not defined}}
+                                  // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::s_tvar_2<long>' is explicitly instantiated in another translation unit}}
+}
+
+void func_12() {
+  C1<int>::s_tfunc_2<char>();
+}
+
+void func_13() {
+  C1<int>::s_tfunc_2<long>(); // expected-warning{{instantiation of function 'C1<int>::s_tfunc_2<long>' required here, but 'C1<T>::s_tfunc_2<T1>' is not defined}}
+                              // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::s_tfunc_2<long>' is explicitly instantiated in another translation unit}}
+}
+
+char func_14() {
+  return C1<int>::C2<long>::s_var_2;
+}
+
+char func_15() {
+  return C1<int>::C2<char>::s_var_2;  //expected-warning {{instantiation of variable 'C1<int>::C2<char>::s_var_2' required here, but 'C1<T>::C2<T1>::s_var_2' is not defined}}
+                                      // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::C2<char>::s_var_2' is explicitly instantiated in another translation unit}}
+}
+
+void func_16() {
+  C1<int>::C2<long>::s_func_2();
+}
+
+void func_17() {
+  C1<int>::C2<char>::s_func_2(); // expected-warning{{instantiation of function 'C1<int>::C2<char>::s_func_2' required here, but 'C1<T>::C2<T1>::s_func_2' is not defined}}
+                        // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::C2<char>::s_func_2' is explicitly instantiated in another translation unit}}
+}
+
+void func_18(C1<int>::C2<long> *x) {
+  x->meth_2();
+}
+
+void func_19(C1<int>::C2<char> *x) {
+  x->meth_2();   // expected-warning{{instantiation of function 'C1<int>::C2<char>::meth_2' required here, but 'C1<T>::C2<T1>::meth_2' is not defined}}
+                        // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::C2<char>::meth_2' is explicitly instantiated in another translation unit}}
+}
+
+char func_20() {
+  return C1<int>::C2<long>::s_tvar_2<char>;
+}
+
+char func_21() {
+  return C1<int>::C2<long>::s_tvar_2<long>; // expected-warning{{instantiation of variable 'C1<int>::C2<long>::s_tvar_2<long>' required here, but 'C1<T>::C2<T1>::s_tvar_2<T2>' is not defined}}
+                                  // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::C2<long>::s_tvar_2<long>' is explicitly instantiated in another translation unit}}
+}
+
+void func_22(C1<int>::C2<long> *x) {
+  x->tmeth_2<char>();
+}
+
+void func_23(C1<int>::C2<long> *x) {
+  x->tmeth_2<int>();    // expected-warning{{instantiation of function 'C1<int>::C2<long>::tmeth_2<int>' required here, but 'C1<T>::C2<T1>::tmeth_2<T2>' is not defined}}
+                        // expected-note@-1{{add an explicit instantiation declaration to suppress this warning if 'C1<int>::C2<long>::tmeth_2<int>' is explicitly instantiated in another translation unit}}
+}
+
+int main() {
+  return 0;
+}