Add new ASTMatcher that matches dynamic exception specifications.

[hintonda]

Summary

Add new ASTMatcher that matches dynamic exception specifications.

[alexfh]

Please add tests, re-generate documentation and add the matcher to the dynamic matchers registry. See http://reviews.llvm.org/D19871 for an example.

[hintonda]

• Added test, re-generated documentation, and add new matcher to the dynamic matchers registry.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

3229

It's a bit odd to expose this on the declaration instead of the type since the AST carries this information on the type, not the declaration. I definitely see the utility in not having to go from the decl to the type in an AST matcher, though. Can you expose it on both FunctionDecl and FunctionProtoType instead?

[hintonda]

include/clang/ASTMatchers/ASTMatchers.h

3229

It's modeled on the isNoThrow matcher directly below which used FunctionDecl, so I used it for this one too.

Did you want me change this one to use FunctionProtoType or add 2 matchers, one using FunctionDecl and another one using FunctionProtoType?

[aaron.ballman]

LGTM!

include/clang/ASTMatchers/ASTMatchers.h

3229

Ah, good point about isNoThrow. I would say leave it as FunctionDecl for now and maybe a follow-on patch (not requesting you do this work, btw) can convert it to be a polymorphic matcher that accepts FunctionDecl and FunctionProtoType.

[hintonda]

Great, thanks. Btw, I don't have commit access, so could you land it for me?

[hintonda]

• Added new isThrow matcher to complement isNoThrow, and changed hadDynamicExceptionSpec to take a parameter, e.g., isThrow() or isNoThrow().

[aaron.ballman]

I'm not keen on the new direction this patch has taken. hasDynamicExceptionSpec(isThrow()) is quite novel. What is the problem you are trying to solve with this?

include/clang/ASTMatchers/ASTMatchers.h

3251

I'm not comfortable with this matcher; users can use unless(isNoThrow()) to get this behavior already.

[hintonda]

Great, unless() was what I was missing. I'll refactor along those lines.

As for what I'm trying to achieve, I want a set containing "throw()" and another set containing "throw(something)". If there's a cleaner way to achieve that with an existing matcher, please let me know.

[aaron.ballman]

In D20052#430903, @hintonda wrote:

Great, unless() was what I was missing. I'll refactor along those lines.

As for what I'm trying to achieve, I want a set containing "throw()" and another set containing "throw(something)". If there's a cleaner way to achieve that with an existing matcher, please let me know.

allOf(hasDynamicExceptionSpecification(), isNoThrow()) gets you "throw()" and allOf(hasDynamicExceptionSpecification(), unless(isNoThrow()) gets you "throw(something)", doesn't it?

[hintonda]

Great, that's exactly what I needed. I'll revert back to the previous version.

[hintonda]

Revert back to previous version.

[aaron.ballman]

Okay, back to looking good. :-) I will commit on your behalf, since I'm back to somewhere with source access again.

[hintonda]

Great, thanks again. This has been a great learning experience.

[aaron.ballman]

Thank you for the work on this! I've commit in r269662

docs/LibASTMatchersReference.html

But given
   template <> class X<A> {}; X<A> x;
 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
   does not match, as X<A> is an explicit template specialization.
 
 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isThrow0')"><a name="isThrow0Anchor">isThrow</a></td><td></td></tr>
+<tr><td colspan="4" class="doc" id="isThrow0"><pre>Matches functions that have a throwing exception specification.
+
+Given:
+  void f();
+  void g() noexcept;
+  void h() throw();
+  void i() throw(int);
+  void j() noexcept(false);
+functionDecl(isThrow())
+  matches the declarations of f, i, and j but not g or h.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isVariadic0')"><a name="isVariadic0Anchor">isVariadic</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isVariadic0"><pre>Matches if a function declaration is variadic.
 
 Example matches f, but not g or h. The function i will not match, even when
 compiled in C mode.
   void f(...);
   void g(int);
   template &lt;typename... Ts&gt; void h(Ts...);
Given
   for (;;) {}
 hasBody(compoundStmt())
   matches 'for (;;) {}'
 with compoundStmt()
   matching '{}'
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasDynamicExceptionSpec0')"><a name="hasDynamicExceptionSpec0Anchor">hasDynamicExceptionSpec</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="hasDynamicExceptionSpec0"><pre>Matches functions that have a dynamic exception specification.
+
+Given:
+  void f();
+  void g() noexcept;
+  void h() noexcept(true);
+  void i() noexcept(false);
+  void j() throw();
+  void k() throw(int);
+  void l() throw(...);
+functionDecl(hasDynamicExceptionSpec(isThrow()))
+  matches the declarations of k and l, but not f, g, h, i, or j.
+functionDecl(hasDynamicExceptionSpec(isNoThrow()))
+  only matches the declaration of j.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasParameter0')"><a name="hasParameter0Anchor">hasParameter</a></td><td>unsigned N, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="hasParameter0"><pre>Matches the n'th parameter of a function declaration.
 
 Given
   class X { void f(int x) {} };
 cxxMethodDecl(hasParameter(0, hasType(varDecl())))
   matches f(int x) {}
 with hasParameter(...)

include/clang/ASTMatchers/ASTMatchers.h

 ///   class B { ~B() = default; };
 /// \endcode
 /// functionDecl(isDefaulted())
 ///   matches the declaration of ~B, but not ~A.
 AST_MATCHER(FunctionDecl, isDefaulted) {
   return Node.isDefaulted();
 }
 
+/// \brief Matches functions that have a dynamic exception specification.
+///
+/// Given:
+/// \code
+///   void f();
+///   void g() noexcept;
+///   void h() noexcept(true);
+///   void i() noexcept(false);
+///   void j() throw();
+///   void k() throw(int);
+///   void l() throw(...);
+/// \endcode
+/// functionDecl(hasDynamicExceptionSpec(isThrow()))
+///   matches the declarations of k and l, but not f, g, h, i, or j.
+/// functionDecl(hasDynamicExceptionSpec(isNoThrow()))
+///   only matches the declaration of j.
+AST_MATCHER_P(FunctionDecl, hasDynamicExceptionSpec,
+              internal::Matcher<FunctionDecl>, InnerMatcher) {
+  const auto *FnTy = Node.getType()->getAs<FunctionProtoType>();
+  if (FnTy && FnTy->hasDynamicExceptionSpec())
+    return InnerMatcher.matches(Node, Finder, Builder);
+  return false;
+}
+
+/// \brief Matches functions that have a throwing exception specification.
+///
+/// Given:
+/// \code
+///   void f();
+///   void g() noexcept;
+///   void h() throw();
+///   void i() throw(int);
+///   void j() noexcept(false);
+/// \endcode
+/// functionDecl(isThrow())
+///   matches the declarations of f, i, and j but not g or h.
+AST_MATCHER(FunctionDecl, isThrow) {
+  if (const auto *FnTy = Node.getType()->getAs<FunctionProtoType>())
+    return !FnTy->isNothrow(Node.getASTContext());
+  return false;
+}
+
 /// \brief Matches functions that have a non-throwing exception specification.
 ///
 /// Given:
 /// \code
 ///   void f();
 ///   void g() noexcept;
 ///   void h() throw();
 ///   void i() throw(int);

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasCondition);
   REGISTER_MATCHER(hasConditionVariableStatement);
   REGISTER_MATCHER(hasDecayedType);
   REGISTER_MATCHER(hasDeclaration);
   REGISTER_MATCHER(hasDeclContext);
   REGISTER_MATCHER(hasDeducedType);
   REGISTER_MATCHER(hasDescendant);
   REGISTER_MATCHER(hasDestinationType);
+  REGISTER_MATCHER(hasDynamicExceptionSpec);
   REGISTER_MATCHER(hasEitherOperand);
   REGISTER_MATCHER(hasElementType);
   REGISTER_MATCHER(hasElse);
   REGISTER_MATCHER(hasFalseExpression);
   REGISTER_MATCHER(hasGlobalStorage);
   REGISTER_MATCHER(hasImplicitDestinationType);
   REGISTER_MATCHER(hasIncrement);
   REGISTER_MATCHER(hasIndex);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(isInteger);
   REGISTER_MATCHER(isIntegral);
   REGISTER_MATCHER(isInTemplateInstantiation);
   REGISTER_MATCHER(isListInitialization);
   REGISTER_MATCHER(isMemberInitializer);
   REGISTER_MATCHER(isMoveAssignmentOperator);
   REGISTER_MATCHER(isMoveConstructor);
   REGISTER_MATCHER(isNoThrow);
+  REGISTER_MATCHER(isThrow);
   REGISTER_MATCHER(isOverride);
   REGISTER_MATCHER(isPrivate);
   REGISTER_MATCHER(isProtected);
   REGISTER_MATCHER(isPublic);
   REGISTER_MATCHER(isPure);
   REGISTER_MATCHER(isStruct);
   REGISTER_MATCHER(isTemplateInstantiation);
   REGISTER_MATCHER(isUnion);

unittests/ASTMatchers/ASTMatchersTest.cpp

 
 TEST(IsDeleted, MatchesDeletedFunctionDeclarations) {
   EXPECT_TRUE(
       notMatches("void Func();", functionDecl(hasName("Func"), isDeleted())));
   EXPECT_TRUE(matches("void Func() = delete;",
                       functionDecl(hasName("Func"), isDeleted())));
 }
 
+TEST(IsThrow, MatchesThrowFunctionDeclarations) {
+  EXPECT_TRUE(matches("void f();", functionDecl(isThrow())));
+  EXPECT_TRUE(matches("void f() throw(int);", functionDecl(isThrow())));
+  EXPECT_TRUE(
+      matches("void f() noexcept(false);", functionDecl(isThrow())));
+  EXPECT_TRUE(notMatches("void f() throw();", functionDecl(isThrow())));
+  EXPECT_TRUE(notMatches("void f() noexcept;", functionDecl(isThrow())));
+}
+
 TEST(IsNoThrow, MatchesNoThrowFunctionDeclarations) {
   EXPECT_TRUE(notMatches("void f();", functionDecl(isNoThrow())));
   EXPECT_TRUE(notMatches("void f() throw(int);", functionDecl(isNoThrow())));
   EXPECT_TRUE(
       notMatches("void f() noexcept(false);", functionDecl(isNoThrow())));
   EXPECT_TRUE(matches("void f() throw();", functionDecl(isNoThrow())));
   EXPECT_TRUE(matches("void f() noexcept;", functionDecl(isNoThrow())));
 }

 }
 
 TEST(HasDestinationType, MatchesSimpleCase) {
   EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
                       cxxStaticCastExpr(hasDestinationType(
                           pointsTo(TypeMatcher(anything()))))));
 }
 
+TEST(hasDynamicExceptionSpec, MatchesDynamicExceptionSpecifications) {
+  EXPECT_TRUE(notMatches("void f();",
+                         functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(notMatches("void f();",
+                         functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+  EXPECT_TRUE(notMatches("void g() noexcept;",
+                         functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(notMatches("void g() noexcept;",
+                         functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+  EXPECT_TRUE(notMatches("void h() noexcept(true);",
+                         functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(notMatches("void h() noexcept(true);",
+                         functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+  EXPECT_TRUE(notMatches("void i() noexcept(false);",
+                         functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(notMatches("void i() noexcept(false);",
+                         functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+
+  EXPECT_TRUE(notMatches("void j() throw();",
+                         functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(matches("void j() throw();",
+                      functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+  EXPECT_TRUE(matches("void k() throw(int);",
+                      functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(notMatches("void k() throw(int);",
+                         functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+  EXPECT_TRUE(matches("void l() throw(...);",
+                      functionDecl(hasDynamicExceptionSpec(isThrow()))));
+  EXPECT_TRUE(notMatches("void l() throw(...);",
+                         functionDecl(hasDynamicExceptionSpec(isNoThrow()))));
+}
+
 TEST(HasImplicitDestinationType, MatchesSimpleCase) {
   // This test creates an implicit const cast.
   EXPECT_TRUE(matches("int x; const int i = x;",
                       implicitCastExpr(
                           hasImplicitDestinationType(isInteger()))));
   // This test creates an implicit array-to-pointer cast.
   EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
                       implicitCastExpr(hasImplicitDestinationType(