Avoid isImplicit call on object which could be nullptr

[steveire]

Summary

A callExpr whose argument is dependent has a null getCalleeDecl().

[aaron.ballman]

Good catch, LGTM!

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

bool matchesSpecialized(const LabelStmt &Node, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     return matchesDecl(Node.getDecl(), Finder, Builder);
   }
 
   /// Returns whether the inner matcher \c Node. Returns false if \c Node
   /// is \c NULL.
   bool matchesDecl(const Decl *Node, ASTMatchFinder *Finder,
                    BoundNodesTreeBuilder *Builder) const {
-    if (Finder->isTraversalIgnoringImplicitNodes() && Node->isImplicit())
-      return false;
-    return Node != nullptr && this->InnerMatcher.matches(
-                                  DynTypedNode::create(*Node), Finder, Builder);
+    return Node != nullptr &&
+           !(Finder->isTraversalIgnoringImplicitNodes() &&
+             Node->isImplicit()) &&
+           this->InnerMatcher.matches(DynTypedNode::create(*Node), Finder,
+                                      Builder);
   }
 };
 
 /// IsBaseType<T>::value is true if T is a "base" type in the AST
 /// node class hierarchies.
 template <typename T>
 struct IsBaseType {
   static const bool value =

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

)cpp";
   EXPECT_TRUE(
       matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
                                       hasArgument(0, floatLiteral())))));
 
   EXPECT_TRUE(
       matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
                                       hasAnyArgument(floatLiteral())))));
 
+  EXPECT_TRUE(matches(
+      R"cpp(
+void takesBool(bool){}
+
+template <typename T>
+void neverInstantiatedTemplate() {
+  takesBool(T{});
+}
+)cpp",
+      traverse(TK_IgnoreUnlessSpelledInSource,
+               callExpr(unless(callExpr(hasDeclaration(functionDecl())))))));
+
   EXPECT_TRUE(
       matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                             hasType(builtinType())))));
 
   EXPECT_TRUE(
       matches(VarDeclCode,
               functionDecl(hasName("foo"),
                            traverse(TK_AsIs, hasDescendant(floatLiteral())))));