Fix a crash while traversing base classes

After llvm/llvm-project#158109 we started seeing cases that were previously `DependentTemplateSpecializationType` become `TemplateSpecializationType` where the `getAsTemplateDecl` returns nullptr.

The documentation had always said that getAsTemplateDecl could be nullptr, but perhaps it was harder to see when diverted to the separate `DependentTemplateSpecializationType` type.

PiperOrigin-RevId: 810993821
Change-Id: Ic59d9775617d4ebb12df85381d5b1f072d856dc5

Author: Googler

nullability/type_nullability.cc

@@ -79,13 +79,16 @@ static const CXXRecordDecl *absl_nullable getSmartPointerBaseClass(
         // return the `CXXRecordDecl` of the underlying template -- it's the
         // best we can do.
         if (BaseClass == nullptr) {
-          if (const auto *TST =
+          if (const auto* TST =
                   Base.getType()->getAs<TemplateSpecializationType>()) {
-            // If the base class is a template template parameter, we can
-            // retrieve the template decl, but not the templated decl, so don't
-            // assert presence during the cast.
-            BaseClass = dyn_cast_if_present<CXXRecordDecl>(
-                TST->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());
+            // If the base class template name is a dependent name, the template
+            // decl will be null.
+            if (const auto* TD = TST->getTemplateName().getAsTemplateDecl())
+              // And, if the base class is a template template parameter, we can
+              // retrieve the template decl, but not the templated decl, so
+              // don't assert presence during the cast.
+              BaseClass =
+                  dyn_cast_if_present<CXXRecordDecl>(TD->getTemplatedDecl());
 
             // We need to be careful here: Once we start looking at underlying
             // templates, we may walk into cycles, as a template may derive from

nullability/type_nullability_test.cc

@@ -340,6 +340,26 @@ TEST_F(UnderlyingRawPointerTest, BaseClassIsTemplateTemplateParameter) {
   EXPECT_EQ(underlyingRawPointerType(Target->getUnderlyingType()), QualType());
 }
 
+TEST_F(UnderlyingRawPointerTest, BaseClassIsDependentOnUnresolvedParameter) {
+  // This is a crash repro for b/447116132.
+  TestAST AST(R"cc(
+    template <typename T>
+    struct Other {
+      template <typename U>
+      struct With {};
+    };
+
+    template <typename Base>
+    struct Derived : public Other<Base>::template With<Base> {
+      using Target = Derived;
+    };
+  )cc");
+
+  const auto* Target = selectFirst<TypeAliasDecl>(
+      "T", match(typeAliasDecl(hasName("Target")).bind("T"), AST.context()));
+  EXPECT_EQ(underlyingRawPointerType(Target->getUnderlyingType()), QualType());
+}
+
 TEST_F(UnderlyingRawPointerTest, BaseClassIsTemplateInstantation) {
   // This is a regression test. We did not recognize `target` as a smart pointer
   // type because we did not check the template argument of the smart pointer