ASTMatcher for Attr

[jpienaar]

Summary

Add a matcher for decls that has a specific attribute.

[klimek]

include/clang/ASTMatchers/ASTMatchers.h

3669–3672

If we have this matcher, do the specialized ones still provide enough value? I was expecting us to either go for the specialized ones, or provide a generic one. Having both in the interface seems odd...

[jpienaar]

Removed specialized attribute matchers in favor of retaining generic one.

include/clang/ASTMatchers/ASTMatchers.h

3669–3672

Agreed. I'll remove the specialized ones.

[klimek]

lib/ASTMatchers/Dynamic/Registry.cpp

185–187

And now that I see how this affects the dynamic matchers, I wonder how we're going to fix that up - that is, we'll need to teach the dynamic matchers to understand the possible clang attributes somehow.

[jpienaar]

Re-implemented by having hasAttr take a parameter of type attr::Kind instead to avoid using templates and ease register dynamic matcher.

[klimek]

lib/ASTMatchers/Dynamic/Marshallers.h

79–88 ↗

(On Diff #12785)

And that's enough to make the dynamic matchers work? Can you add an example to the dynamic matchers test? Thx!

[jpienaar]

Interface to dynamic matcher using hasAttr now uses a string specification of the attribute instead of requiring the numerical enum value.

[jpienaar]

Small cleanup.

[klimek]

+richard, since this is now touching lib/Basic...

Looks good to me, but I want Richard to take a look whether this makes sense or should be solved differently.

[jpienaar]

Moved getAttrKind to a private method of ArgTypeTraints<attr::Kind>.

[jpienaar]

Changed iterator type to const.

[klimek]

Nice, LG. Let me know if you need me to submit.

[jpienaar]

Thanks, I would need you to submit.

[klimek]

Thx! Committed as r216379.

docs/LibASTMatchersReference.html

 </pre></td></tr>
 
 
+<tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('hasAttr0')"><a name="hasAttr0Anchor">hasAttr</a></td><td></td></tr>
+<tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
+
+Given
+  __attribute__((device)) void f() { ... }
+decl(hasAttr&lt;clang::CUDADeviceAttr&gt;()) matches the function declaration of
+f.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt<a href="http://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('hasCudaDeviceAttr0')"><a name="hasCudaDeviceAttr0Anchor">hasCudaDeviceAttr</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="hasCudaDeviceAttr0"><pre>Matches declaration that has CUDA device attribute.
 

include/clang/ASTMatchers/ASTMatchers.h

   return InnerMatcher.matches(*Node.getLHS(), Finder, Builder);
 }
 
+/// \brief Matches declaration that has a given attribute.
+///
+/// Given
+/// \code
+///   __attribute__((device)) void f() { ... }
+/// \endcode
+/// decl(hasAttr<clang::CUDADeviceAttr>()) matches the function declaration of
+/// f.
+template <typename Attr>
+inline internal::Matcher<Decl> hasAttr() {
+  return internal::HasAttrMatcher<Decl, Attr>();
+}
+
 /// \brief Matches CUDA kernel call expression.
 ///
 /// Example matches,

 ///   __attribute__((device)) void f() { ... }
 /// \endcode
 /// matches the function declaration of f.
-AST_MATCHER(Decl, hasCudaDeviceAttr) {
-  return Node.hasAttr<clang::CUDADeviceAttr>();
+inline internal::Matcher<Decl> hasCudaDeviceAttr() {
+  return hasAttr<CUDADeviceAttr>();
 }
 
 /// \brief Matches declaration that has CUDA host attribute.

 ///   __attribute__((host)) void f() { ... }
 /// \endcode
 /// matches the function declaration of f.
-AST_MATCHER(Decl, hasCudaHostAttr) {
-  return Node.hasAttr<clang::CUDAHostAttr>();
+inline internal::Matcher<Decl> hasCudaHostAttr() {
+  return hasAttr<CUDAHostAttr>();
 }
 
 /// \brief  Matches declaration that has CUDA global attribute.

 ///   __attribute__((global)) void f() { ... }
 /// \endcode
 /// matches the function declaration of f.
-AST_MATCHER(Decl, hasCudaGlobalAttr) {
-  return Node.hasAttr<clang::CUDAGlobalAttr>();
+inline internal::Matcher<Decl> hasCudaGlobalAttr() {
+  return hasAttr<CUDAGlobalAttr>();
 }
 
 } // end namespace ast_matchers

include/clang/ASTMatchers/ASTMatchersInternal.h

   ast_type_traits::DynTypedNode Node;
 };
 
+/// \brief Matches declarations have an attribute of type \c Attr
+template <typename T, typename Attr,
+          typename ReturnTypesF = void(internal::TypeList<Decl>)>
+class HasAttrMatcher : public SingleNodeMatcherInterface<T> {
+  static_assert(std::is_same<T, Decl>::value,
+                "unsupported class for matcher");
+public:
+  typedef typename ExtractFunctionArgMeta<ReturnTypesF>::type ReturnTypes;
+  operator Matcher<T>() const {
+    static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
+                  "right polymorphic conversion");
+    return Matcher<T>(new HasAttrMatcher<T, Attr, ReturnTypesF>());
+  }
+  bool matchesNode(const T &Node) const override {
+    return matchesSpecialized(Node);
+  }
+private:
+  bool matchesSpecialized(const Decl &Node) const {
+    return Node.hasAttr<Attr>();
+  }
+};
+
 } // end namespace internal
 } // end namespace ast_matchers
 } // end namespace clang

lib/ASTMatchers/Dynamic/Registry.cpp

   //
   // Polymorphic + argument overload:
   // findAll
+  // hasAttr
   //
   // Other:
   // equals

unittests/ASTMatchers/ASTMatchersTest.cpp

   EXPECT_TRUE(matches("void f() { int i; }", CannotMemoize));
 }
 
+TEST(DeclarationMatcher, HasAttr) {
+  EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};",
+                      decl(hasAttr<WarnUnusedAttr>())));
+  EXPECT_FALSE(matches("struct X {};",
+                       decl(hasAttr<WarnUnusedAttr>())));
+}
+
 TEST(DeclarationMatcher, MatchCudaDecl) {
   EXPECT_TRUE(matchesWithCuda("__global__ void f() { }"
                               "void g() { f<<<1, 2>>>(); }",