Add an AST matcher for null pointers

[aaron.ballman]

Summary

There are several ways to specify a null pointer constant. C++11 has nullptr, GNU has the __null extension, and there's always NULL/0. This AST matcher will match on anything that generates a null pointer value, without requiring the user to figure out how to spell that with existing matchers.

[sbenza]

include/clang/ASTMatchers/ASTMatchers.h

4821

Use AST_MATCHER_FUNCTION instead, where the return value is the matcher (instead of the application of the matcher).
It is simpler to write and since it has no arguments it will memoize the matcher and construct it only once.

4821

Maybe use Expr::isNullPointerConstant?

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

4821

Ah, interesting! I hadn't known about that macro. Thank you.

4821

Oh, hey, that's easier still! Would I still use AST_MATCHER_FUNCTION in that case though, or should that remain a simple AST_MATCHER?

[sbenza]

include/clang/ASTMatchers/ASTMatchers.h

4821

One or the other.
The _FUNCTION macro is for when the matcher itself is just a matcher expression. Saves typing and CPU.
Generating the temporary matchers on each match is expensive as they do memory allocation.
If you use Expr::isNullPointerConstant you won't be making any matchers.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

4821

One interesting problem I ran into with using Expr::isNullPointerConstant is that it makes the matcher overly aggressive with nullptr. Given:

AST_MATCHER(Expr, nullPointerConstant) {
  QualType QT = Node.getType();
  if (QT->isNullPtrType())
    return true;

  return QT->isPointerType() &&
         Node.isNullPointerConstant(Finder->getASTContext(),
                                    Expr::NPC_NeverValueDependent);
}

If you attempt to match somePtr = nullptr; with expr(nullPointerConstant()), you will get two matches. One for the initializer expression of the declaration, and one for the implicit cast expression. However, with somePtr = __null or somePtr = 0, you only get a single match (for the initializer expression). This seems like surprising behavior, but I'm not quite certain of the best way to address it, if it should be addressed at all.

[aaron.ballman]

Using the AST_MATCHER_FUNCTION macro instead.

Using Expr::isNullPointerConstant() turns out to have strange behavior with implicit casts and nullptr, and also requires further restrictions (for instance, it claims the initializer for int i = 0 is a null pointer constant, which is strictly true, but practically useless).

[sbenza]

include/clang/ASTMatchers/ASTMatchers.h

4838

is this expr() necessary?

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

4838

Yes, without it I get errors about not having a matching overload for hasParent().

[sbenza]

include/clang/ASTMatchers/ASTMatchers.h

4838

Sorry, I meant the one around integerLiteral().

[aaron.ballman]

Removed an unnecessary expr() matcher.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

4838

Ah, good catch! No, that one was not required, I've removed it.

[aaron.ballman]

Thanks for the review and suggestions! I've commit in r261008.

docs/LibASTMatchersReference.html

 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('nullPointerConstant0')"><a name="nullPointerConstant0Anchor">nullPointerConstant</a></td><td></td></tr>
+<tr><td colspan="4" class="doc" id="nullPointerConstant0"><pre>Matches expressions that resolve to a null pointer constant, such as
+GNU's __null, C++11's nullptr, or C's NULL macro.
+
+Given:
+  void *v1 = NULL;
+  void *v2 = nullptr;
+  void *v3 = __null; GNU extension
+  char *cp = (char *)0;
+  int *ip = 0;
+  int i = 0;
+expr(nullPointerConstant())
+  matches the initializer for v1, v2, v3, cp, and ip. Does not match the
+  initializer for i.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;</td><td class="name" onclick="toggle('equals1')"><a name="equals1Anchor">equals</a></td><td>ValueT  Value</td></tr>
 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value.
 

include/clang/ASTMatchers/ASTMatchers.h

   Stmt,
   CUDAKernelCallExpr> cudaKernelCallExpr;
 
+
+/// \brief Matches expressions that resolve to a null pointer constant, such as
+/// GNU's __null, C++11's nullptr, or C's NULL macro.
+///
+/// Given:
+/// \code
+///   void *v1 = NULL;
+///   void *v2 = nullptr;
+///   void *v3 = __null; // GNU extension
+///   char *cp = (char *)0;
+///   int *ip = 0;
+///   int i = 0;
+/// \endcode
+/// expr(nullPointerConstant())
+///   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
+///   initializer for i.
+AST_MATCHER_FUNCTION(internal::Matcher<Expr>, nullPointerConstant) {
+  return anyOf(
+      gnuNullExpr(), cxxNullPtrLiteralExpr(),
+      integerLiteral(equals(0), hasParent(expr(hasType(pointerType())))));
+}
 } // end namespace ast_matchers
 } // end namespace clang
 

lib/ASTMatchers/Dynamic/Registry.cpp

   REGISTER_MATCHER(namesType);
   REGISTER_MATCHER(nestedNameSpecifier);
   REGISTER_MATCHER(nestedNameSpecifierLoc);
+  REGISTER_MATCHER(nullPointerConstant);
   REGISTER_MATCHER(nullStmt);
   REGISTER_MATCHER(numSelectorArgs);
   REGISTER_MATCHER(ofClass);

unittests/ASTMatchers/ASTMatchersTest.cpp

                       )));
 }
 
+TEST(NullPointerConstants, Basic) {
+  EXPECT_TRUE(matches("#define NULL ((void *)0)\n"
+                      "void *v1 = NULL;", expr(nullPointerConstant())));
+  EXPECT_TRUE(matches("void *v2 = nullptr;", expr(nullPointerConstant())));
+  EXPECT_TRUE(matches("void *v3 = __null;", expr(nullPointerConstant())));
+  EXPECT_TRUE(matches("char *cp = (char *)0;", expr(nullPointerConstant())));
+  EXPECT_TRUE(matches("int *ip = 0;", expr(nullPointerConstant())));
+  EXPECT_TRUE(notMatches("int i = 0", expr(nullPointerConstant())));
+}
+
 } // end namespace ast_matchers
 } // end namespace clang