Fix crash-on-invalid bug in template instantiation.

[klimek]

Summary

When a template is instantiated after a fatal error has occurred,
template instantiation is aborted. In that case, we need to mark the
instantiated decl as invalid, otherwise we try to access it later.

[klimek]

Ping.

[rsmith]

lib/Sema/SemaTemplateInstantiate.cpp

1930–1939

Is it sufficient to move this block of code to after the bail-out below? It seems like the problem may be that we've done some amount of the instantiation work (storing the TSK on the specialization) before we bail out, and so the AST is left in an inconsistent state.

[meadori]

This fix LGTM, but I do wonder about one thing. The following pattern seems to occur all over Sema:

InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl);
  if (Inst.isInvalid())
    ...

For example, in Sema::InstantiateEnum. Why aren't we marking decls invalid in those other places?

[rsmith]

lib/Sema/SemaTemplateInstantiate.cpp

2273–2297

Better solution: just delete all of this code.

[klimek]

That works! \o/

[klimek]

Submitted the deletion as r240752.

lib/Sema/SemaTemplateInstantiate.cpp

Sema::InstantiateClass(SourceLocation PointOfInstantiation,
   CXXRecordDecl *PatternDef
     = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
   if (DiagnoseUninstantiableTemplate(*this, PointOfInstantiation, Instantiation,
                                 Instantiation->getInstantiatedFromMemberClass(),
                                      Pattern, PatternDef, TSK, Complain))
     return true;
   Pattern = PatternDef;
 
   // \brief Record the point of instantiation.
   if (MemberSpecializationInfo *MSInfo 
         = Instantiation->getMemberSpecializationInfo()) {
     MSInfo->setTemplateSpecializationKind(TSK);
     MSInfo->setPointOfInstantiation(PointOfInstantiation);
   } else if (ClassTemplateSpecializationDecl *Spec 
         = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
     Spec->setTemplateSpecializationKind(TSK);
     Spec->setPointOfInstantiation(PointOfInstantiation);
   }
 
   InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
-  if (Inst.isInvalid())
+  if (Inst.isInvalid()) {
+    Instantiation->setInvalidDecl(true);
     return true;
+  }
 
   // Enter the scope of this instantiation. We don't use
   // PushDeclContext because we don't have a scope.
   ContextRAII SavedContext(*this, Instantiation);
   EnterExpressionEvaluationContext EvalContext(*this, 
                                                Sema::PotentiallyEvaluated);
 
   // If this is an instantiation of a local class, merge this local

 bool Sema::InstantiateClassTemplateSpecialization(
     SourceLocation PointOfInstantiation,
     ClassTemplateSpecializationDecl *ClassTemplateSpec,
     TemplateSpecializationKind TSK, bool Complain) {
   // Perform the actual instantiation on the canonical declaration.
   ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
                                          ClassTemplateSpec->getCanonicalDecl());
 
   // Check whether we have already instantiated or specialized this class
   // template specialization.
   if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) {
     if (ClassTemplateSpec->getSpecializationKind() == 
           TSK_ExplicitInstantiationDeclaration &&
         TSK == TSK_ExplicitInstantiationDefinition) {
       // An explicit instantiation definition follows an explicit instantiation
       // declaration (C++0x [temp.explicit]p10); go ahead and perform the
       // explicit instantiation.
       ClassTemplateSpec->setSpecializationKind(TSK);
       
       // If this is an explicit instantiation definition, mark the
       // vtable as used.
       if (TSK == TSK_ExplicitInstantiationDefinition &&
           !ClassTemplateSpec->isInvalidDecl())
         MarkVTableUsed(PointOfInstantiation, ClassTemplateSpec, true);
 
       return false;
     }
     
     // We can only instantiate something that hasn't already been
     // instantiated or specialized. Fail without any diagnostics: our
     // caller will provide an error message.    
     return true;
   }
 
   if (ClassTemplateSpec->isInvalidDecl())
     return true;
   
   ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
   CXXRecordDecl *Pattern = nullptr;
 
   // C++ [temp.class.spec.match]p1:

test/SemaTemplate/instantiate-explicitly-after-fatal.cpp

+// RUN: not %clang_cc1 -fsyntax-only -std=c++11 -ferror-limit 1 %s 2>&1 | FileCheck %s
+unknown_type foo(unknown_type);
+// CHECK: fatal error: too many errors emitted, stopping now
+
+template <typename>
+class Bar {};
+
+extern template class Bar<int>;
+template class Bar<int>;