[ASTMatcher] Add CXXNewExpr support to hasDeclaration

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

4042

Instead of adding a new traversal matcher for operatorNew, we could use the existing hasDeclaration traversal matcher and provide another overload for it.

The CXXNewExpr does expose the selected operator delete overload as well, so I'm not certain using hasDeclaration is perfect, but it was the first traversal matcher I could think of when trying to go from a new expression to the overloaded operator new declaration chosen for the expression (which is similar to CallExpr usage). @klimek or @sbenza, do you have a preference?

[malcolm.parsons]

Extend hasDeclaration instead.

[aaron.ballman]

I think this is the right way to go, but I know that @klimek and @lukasza have been working on hasDeclaration() issues recently, so I am wondering what their thoughts are as well.

[lukasza]

FWIW, a non-owner LGTM:

• CXXNewExpr seems very similar to CallExpr, so it makes sense that hasDeclaration would behave similarily for both of these expressions (i.e. matching the "callee")
• The issues we've been trying to work through in https://reviews.llvm.org/D24361 mainly revolve around Type and QualType, so I think those issues should not apply to CXXNewExpr matching.

[aaron.ballman]

Assuming @klimek agrees with the design, this LGTM. If you don't hear from Manuel by next Wed, I think you're okay to commit (we can always roll it back post-commit if needed).

[klimek]

Yep, makes sense. Open issues are all about types :)

docs/LibASTMatchersReference.html

Example matches A() in the last line
   class A {
    public:
     A();
   };
   A a = A();
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('operatorNew')"><a name="operatorNewAnchor">operatorNew</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt; InnerMatcher</td></tr>
+<tr><td colspan="4" class="doc" id="operatorNew"><pre>Matches the operator new function declaration that the given new expression calls.
+
+Example matches new expression for B in the last line
+    (matcher = cxxNewExpr(operatorNew(functionDecl(parameterCountIs(2)))))
+  void *operator new(size_t SZ, void *P) noexcept;
+  int *A = new int();
+  char Buffer[sizeof(int)];
+  int *B = new (&amp;Buffer[0]) int();
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasMethod0')"><a name="hasMethod0Anchor">hasMethod</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="hasMethod0"><pre>Matches the first method of a class or struct that satisfies InnerMatcher.
 
 Given:
   class A { void func(); };
   class B { void member(); };
 
 cxxRecordDecl(hasMethod(hasName("func"))) matches the declaration of

include/clang/ASTMatchers/ASTMatchers.h

 ///     void x();
 ///   };
 /// \endcode
 ///   matches A::x but not B::x
 AST_MATCHER(CXXMethodDecl, isVirtualAsWritten) {
   return Node.isVirtualAsWritten();
 }
 
+/// \brief Matches the operator new declaration that the given new expression
+/// calls
+///
+/// Example matches new expression for B in the last line
+///     (matcher = cxxNewExpr(operatorNew(functionDecl(parameterCountIs(2)))))
+/// \code
+///   void *operator new(size_t SZ, void *P) noexcept;
+///   int *A = new int();
+///   char Buffer[sizeof(int)];
+///   int *B = new (&Buffer[0]) int();
+/// \endcode
+AST_MATCHER_P(CXXNewExpr, operatorNew,
+              internal::Matcher<FunctionDecl>, InnerMatcher) {
+  const FunctionDecl *OperatorNew = Node.getOperatorNew();
+  return (OperatorNew != nullptr &&
+          InnerMatcher.matches(*OperatorNew, Finder, Builder));
+}
+
 /// \brief Matches if the given method or class declaration is final.
 ///
 /// Given:
 /// \code
 ///   class A final {};
 ///
 ///   struct B {
 ///     virtual void f();

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(numSelectorArgs);
   REGISTER_MATCHER(ofClass);
   REGISTER_MATCHER(objcInterfaceDecl);
   REGISTER_MATCHER(objcMessageExpr);
   REGISTER_MATCHER(objcObjectPointerType);
   REGISTER_MATCHER(on);
   REGISTER_MATCHER(onImplicitObjectArgument);
   REGISTER_MATCHER(opaqueValueExpr);
+  REGISTER_MATCHER(operatorNew);
   REGISTER_MATCHER(parameterCountIs);
   REGISTER_MATCHER(parenExpr);
   REGISTER_MATCHER(parenListExpr);
   REGISTER_MATCHER(parenType);
   REGISTER_MATCHER(parmVarDecl);
   REGISTER_MATCHER(pointee);
   REGISTER_MATCHER(pointerType);
   REGISTER_MATCHER(predefinedExpr);

unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(
                             hasParameter(0, parmVarDecl(hasName("p2"))))))));
   EXPECT_TRUE(
       notMatches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(functionDecl(
                                hasParameter(0, parmVarDecl(hasName("p3"))))))));
   EXPECT_TRUE(notMatches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(
                                        functionDecl(hasName("bar"))))));
 }
 
+TEST(CXXNewExpr, OperatorNew) {
+  std::string Fragment = "int *A = new int();";
+  EXPECT_TRUE(matches(
+      Fragment, cxxNewExpr(operatorNew(functionDecl(parameterCountIs(1))))));
+
+  EXPECT_TRUE(notMatches(
+      Fragment, cxxNewExpr(operatorNew(functionDecl(parameterCountIs(2))))));
+}
+
 } // namespace ast_matchers
 } // namespace clang