[clang] Fix crash on visiting null nestedNameSpecifier.

[hokein]

Summary

Fix https://github.com/clangd/clangd/issues/293

[sammccall]

clang/lib/Sema/SemaTemplate.cpp

5926

Do you have an idea of how we're getting here with a null qualifier?
AIUI DependentNameType is a type that's a name with a dependent qualifier. If the qualifier doesn't exist, it's not dependent. Is this a recovery path, where the qualifier doesn't exist because it contains an error? (Like the ABC<t> in your test where ABC can't be resolved).

(Docs do reference MSVC-compat cases where the qualifier need not be dependent, and maybe need not exist, but neither the linked bug nor the test use msvc-compat)

5987

nit: this is just assert(NNS), the message doesn't say anything else.

[hokein]

address review comment.

[hokein]

clang/lib/Sema/SemaTemplate.cpp

5926

right, the crash only happens on DependentTemplateSpecializationType. I made this change initially when trying the fix the crash (they look quite suspicious).

It can be ran on a recovery path, but I just checked all call sides, qualifier can not be null for DependentNameType (even for the MSVC mode). Reverted the change here.

clang/lib/Sema/SemaTemplate.cpp

 
 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
                                               const InjectedClassNameType* T) {
   return VisitTagDecl(T->getDecl());
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
                                                    const DependentNameType* T) {
   return VisitNestedNameSpecifier(T->getQualifier());
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
                                  const DependentTemplateSpecializationType* T) {
-  return VisitNestedNameSpecifier(T->getQualifier());
+  if (auto *Q = T->getQualifier())
+    return VisitNestedNameSpecifier(Q);
+  return false;
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
                                                    const PackExpansionType* T) {
   return Visit(T->getPattern());
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
if (!Tag->hasNameForLinkage()) {
     return true;
   }
 
   return false;
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
                                                     NestedNameSpecifier *NNS) {
+  assert(NNS);
   if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
     return true;
 
   switch (NNS->getKind()) {
   case NestedNameSpecifier::Identifier:
   case NestedNameSpecifier::Namespace:
   case NestedNameSpecifier::NamespaceAlias:
   case NestedNameSpecifier::Global:

clang/test/Parser/cxx-template-decl.cpp

namespace AnnotateAfterInvalidTemplateId {
   template<int I> struct A<I, 0> { }; // expected-note {{I = 0}}
 
   void f() { A<0, 0>::f(); } // expected-error {{ambiguous partial specializations}}
 }
 
 namespace PR45063 {
   template<class=class a::template b<>> struct X {}; // expected-error {{undeclared identifier 'a'}}
 }
+
+namespace NoCrashOnEmptyNestedNameSpecifier {
+  template <typename FnT,
+            typename T = typename ABC<FnT>::template arg_t<0>> // expected-error {{no template named 'ABC'}}
+  void foo(FnT) {}
+}