[clang-tidy] Update fuchsia-multiple-inheritance to not fail

[juliehockett]

Summary

Updating the fuchsia-multiple-inheritance to gracefully handle unknown record types (e.g. templatized classes) by simply continuing, rather than asserting and failing.

Fixes PR36052.

[hokein]

LGTM

clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

bool MultipleInheritanceCheck::isInterface(const CXXRecordDecl *Node) {
   bool PreviousIsInterfaceResult;
   if (getInterfaceStatus(Node, PreviousIsInterfaceResult))
     return PreviousIsInterfaceResult;
 
   // To be an interface, all base classes must be interfaces as well.
   for (const auto &I : Node->bases()) {
     if (I.isVirtual()) continue;
     const auto *Ty = I.getType()->getAs<RecordType>();
-    assert(Ty && "RecordType of base class is unknown");
+    if (!Ty) continue;
     const RecordDecl *D = Ty->getDecl()->getDefinition();
     if (!D) continue;
     const auto *Base = cast<CXXRecordDecl>(D);
     if (!isInterface(Base)) {
       addNodeToInterfaceMap(Node, false);
       return false;
     }
   }

 }
 
 void MultipleInheritanceCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) {
     // Check against map to see if if the class inherits from multiple
     // concrete classes
     unsigned NumConcrete = 0;
     for (const auto &I : D->bases()) {
-      if (I.isVirtual() || I.getType()->getAs<TemplateTypeParmType>()) continue;
+      if (I.isVirtual()) continue;
       const auto *Ty = I.getType()->getAs<RecordType>();
-      assert(Ty && "RecordType of base class is unknown");
+      if (!Ty) continue;
       const auto *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition());
       if (!isInterface(Base)) NumConcrete++;
     }
     
     // Check virtual bases to see if there is more than one concrete 
     // non-virtual base.
     for (const auto &V : D->vbases()) {
       const auto *Ty = V.getType()->getAs<RecordType>();
-      assert(Ty && "RecordType of base class is unknown");
+      if (!Ty) continue;
       const auto *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition());
       if (!isInterface(Base)) NumConcrete++;
     }
 
     if (NumConcrete > 1) {
       diag(D->getLocStart(),
            "inheriting mulitple classes that aren't "
            "pure virtual is discouraged");
     }
   }
 }
 
 }  // namespace fuchsia
 }  // namespace tidy
 }  // namespace clang

test/clang-tidy/fuchsia-multiple-inheritance.cpp

 
 struct Static_Base_2 {};
 struct V13 : virtual Static_Base_2 { static void f(); };
 struct V14 : virtual Static_Base_2 { static void g(); };
 struct D8 : V13, V14 {};
 
 template<typename T> struct A : T {};
 template<typename T> struct B : virtual T {};
+
+template<typename> struct C {};
+template<typename T> struct D : C<T> {};