[clang] Fail for empty names in is*DerivedFrom matchers.

[aaron.ballman]

LGTM, thank you for this!

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// \endcode
 AST_MATCHER_P(CXXRecordDecl, isDerivedFrom,
               internal::Matcher<NamedDecl>, Base) {
   return Finder->classIsDerivedFrom(&Node, Base, Builder, /*Directly=*/false);
 }
 
 /// Overloaded method as shortcut for \c isDerivedFrom(hasName(...)).
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isDerivedFrom, std::string, BaseName, 1) {
-  assert(!BaseName.empty());
+  if (BaseName.empty())
+    return false;
   return isDerivedFrom(hasName(BaseName)).matches(Node, Finder, Builder);
 }
 
 /// Similar to \c isDerivedFrom(), but also matches classes that directly
 /// match \c Base.
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isSameOrDerivedFrom,
                        internal::Matcher<NamedDecl>, Base, 0) {
   return Matcher<CXXRecordDecl>(anyOf(Base, isDerivedFrom(Base)))
       .matches(Node, Finder, Builder);
 }
 
 /// Overloaded method as shortcut for
 /// \c isSameOrDerivedFrom(hasName(...)).
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isSameOrDerivedFrom, std::string,
                        BaseName, 1) {
-  assert(!BaseName.empty());
+  if (BaseName.empty())
+    return false;
   return isSameOrDerivedFrom(hasName(BaseName)).matches(Node, Finder, Builder);
 }
 
 /// Matches C++ classes that are directly derived from a class matching \c Base.
 ///
 /// Note that a class is not considered to be derived from itself.
 ///
 /// Example matches Y, C (Base == hasName("X"))

 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isDirectlyDerivedFrom,
                        internal::Matcher<NamedDecl>, Base, 0) {
   return Finder->classIsDerivedFrom(&Node, Base, Builder, /*Directly=*/true);
 }
 
 /// Overloaded method as shortcut for \c isDirectlyDerivedFrom(hasName(...)).
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isDirectlyDerivedFrom, std::string,
                        BaseName, 1) {
-  assert(!BaseName.empty());
+  if (BaseName.empty())
+    return false;
   return isDirectlyDerivedFrom(hasName(BaseName))
       .matches(Node, Finder, Builder);
 }
 /// Matches the first method of a class or struct that satisfies \c
 /// InnerMatcher.
 ///
 /// Given:
 /// \code

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST(DeclarationMatcher, ClassIsDerived) {
 
   EXPECT_TRUE(matches(
     "template<typename T> class X {};"
       "template<typename T> using Z = X<T>;"
       "template <typename T> class Y : Z<T> {};",
     cxxRecordDecl(isDerivedFrom(namedDecl(hasName("X"))))));
 }
 
+TEST(DeclarationMatcher, IsDerivedFromEmptyName) {
+  const char *const Code = "class X {}; class Y : public X {};";
+  EXPECT_TRUE(notMatches(Code, cxxRecordDecl(isDerivedFrom(""))));
+  EXPECT_TRUE(notMatches(Code, cxxRecordDecl(isDirectlyDerivedFrom(""))));
+  EXPECT_TRUE(notMatches(Code, cxxRecordDecl(isSameOrDerivedFrom(""))));
+}
+
 TEST(DeclarationMatcher, IsLambda) {
   const auto IsLambda = cxxMethodDecl(ofClass(cxxRecordDecl(isLambda())));
   EXPECT_TRUE(matches("auto x = []{};", IsLambda));
   EXPECT_TRUE(notMatches("struct S { void operator()() const; };", IsLambda));
 }
 
 TEST(Matcher, BindMatchedNodes) {
   DeclarationMatcher ClassX = has(recordDecl(hasName("::X")).bind("x"));