Add hasTrailingReturn AST matcher

[juliehockett]

Summary

Adds AST matcher for a FunctionDecl that has a trailing return type.

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

5904

I think this may cause failed assertions on code like void f(); when compiled in C mode because that FunctionDecl should have a type of FunctionNoProtoType. You should use getAs<FunctionProtoType>() and test for null.

unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

2121

Spurious semicolon in the test.

[juliehockett]

Updating matcher and fixing semicolons

[aaron.ballman]

LGTM with a minor commenting/documentation nit.

include/clang/ASTMatchers/ASTMatchers.h

5900

Sorry for not noticing this earlier -- spurious semicolon here (don't forget to regenerate the docs too).

[lebedev.ri]

include/clang/ASTMatchers/ASTMatchers.h

5906

There are no negative tests in the unittest that cover this false path.

[juliehockett]

include/clang/ASTMatchers/ASTMatchers.h

5906

Is there a test case you would recommend? I'm not entirely sure what would be appropriate -- the tests compile in C++, yes? So void f(); would just be a normal function declaration (with a prototype, please correct me if I'm wrong).

[lebedev.ri]

include/clang/ASTMatchers/ASTMatchers.h

5906

I'd start by checking what @aaron.ballman has suggested:

EXPECT_TRUE(notMatches("void f();"));

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

5906

You'll need to use notMatchesC() to test that case (so you get a C input file instead of a C++ input file).

[lebedev.ri]

include/clang/ASTMatchers/ASTMatchers.h

5906

Oh, sorry, indeed.
I did mean notMatchesC(), the trailing C was lost during copy-paste.

[juliehockett]

Adding test case -- thank you for the advice!

[aaron.ballman]

LGTM!

docs/LibASTMatchersReference.html

 specified line and
 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
 matches the declaration of A.
 
 Usable as: Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</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('hasTrailingReturn0')"><a name="hasTrailingReturn0Anchor">hasTrailingReturn</a></td><td></td></tr>
+<tr><td colspan="4" class="doc" id="hasTrailingReturn0"><pre>Matches a function declared with a trailing return type.
+
+Example matches Y (matcher = functionDecl(hasTrailingReturn()))
+int X() {}
+auto Y() -&gt; int {}
+</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('isConstexpr1')"><a name="isConstexpr1Anchor">isConstexpr</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations.
 
 Given:
   constexpr int foo = 42;
   constexpr int bar();
 varDecl(isConstexpr())
   matches the declaration of foo.

include/clang/ASTMatchers/ASTMatchers.h

 /// \code
 /// enum X {};
 /// enum class Y {};
 /// \endcode
 AST_MATCHER(EnumDecl, isScoped) {
   return Node.isScoped();
 }
 
+/// \brief Matches a function declared with a trailing return type.
+///
+/// Example matches Y (matcher = functionDecl(hasTrailingReturn()))
+/// \code
+/// int X() {}
+/// auto Y() -> int {}
+/// \endcode
+AST_MATCHER(FunctionDecl, hasTrailingReturn) {
+  if (const auto *F = Node.getType()->getAs<FunctionProtoType>())
+    return F->hasTrailingReturn();
+  return false;
+}
+
 } // namespace ast_matchers
 } // namespace clang
 
 #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasSizeExpr);
   REGISTER_MATCHER(hasSourceExpression);
   REGISTER_MATCHER(hasStaticStorageDuration);
   REGISTER_MATCHER(hasSyntacticForm);
   REGISTER_MATCHER(hasTargetDecl);
   REGISTER_MATCHER(hasTemplateArgument);
   REGISTER_MATCHER(hasThen);
   REGISTER_MATCHER(hasThreadStorageDuration);
+  REGISTER_MATCHER(hasTrailingReturn);
   REGISTER_MATCHER(hasTrueExpression);
   REGISTER_MATCHER(hasTypeLoc);
   REGISTER_MATCHER(hasUnaryOperand);
   REGISTER_MATCHER(hasUnarySelector);
   REGISTER_MATCHER(hasUnderlyingDecl);
   REGISTER_MATCHER(hasUnqualifiedDesugaredType);
   REGISTER_MATCHER(hasValueType);
   REGISTER_MATCHER(ifStmt);

unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

EXPECT_TRUE(notMatches("union x;",
                       cxxRecordDecl(hasDefinition())));
 }
 
 TEST(IsScopedEnum, MatchesScopedEnum) {
   EXPECT_TRUE(matches("enum class X {};", enumDecl(isScoped())));
   EXPECT_TRUE(notMatches("enum X {};", enumDecl(isScoped())));
 }
 
+TEST(HasTrailingReturn, MatchesTrailingReturn) {
+  EXPECT_TRUE(matches("auto Y() -> int { return 0; }",
+                      functionDecl(hasTrailingReturn())));
+  EXPECT_TRUE(matches("auto X() -> int;", functionDecl(hasTrailingReturn())));
+  EXPECT_TRUE(notMatches("int X() { return 0; }", 
+                      functionDecl(hasTrailingReturn())));
+  EXPECT_TRUE(notMatches("int X();", functionDecl(hasTrailingReturn())));
+  EXPECT_TRUE(notMatchesC("void X();", functionDecl(hasTrailingReturn())));
+}
+
+TEST(HasTrailingReturn, MatchesLambdaTrailingReturn) {
+  EXPECT_TRUE(matches(
+          "auto lambda2 = [](double x, double y) -> double {return x + y;};",
+          functionDecl(hasTrailingReturn())));
+  EXPECT_TRUE(notMatches(
+          "auto lambda2 = [](double x, double y) {return x + y;};",
+          functionDecl(hasTrailingReturn())));
+}
+
 } // namespace ast_matchers
 } // namespace clang