[clang-tidy] Fix false positives in `fuchsia-trailing-return` check involving deduction guides

[fwolff]

Summary

Fixes PR#47614. Deduction guides, implicit or user-defined, look like function declarations in the AST. They aren't really functions, though, and they always have a trailing return type, so it doesn't make sense to issue this warning for them.

[juliehockett]

Apologies, i's been a good long while since I was active in this area. @phosek is the most likely to know who would be the best contact in the future.

[aaron.ballman]

LGTM! Can you add a release note about the bug fix?

[fwolff]

In D113828#3164016, @aaron.ballman wrote:

LGTM! Can you add a release note about the bug fix?

Done. Thank you for the review! Can you also commit it for me? You can use name and email as in 6259016361345e09f0607ef4e037e00bcbe4bd40. Thanks!

[aaron.ballman]

In D113828#3165101, @fwolff wrote:

In D113828#3164016, @aaron.ballman wrote:

LGTM! Can you add a release note about the bug fix?

Done. Thank you for the review! Can you also commit it for me? You can use name and email as in 6259016361345e09f0607ef4e037e00bcbe4bd40. Thanks!

I've commit on your behalf in 844a8d3cecb4cc40e5d9694bcf111518910ea2ff, thanks! Btw, you might want to consider obtaining your own commit privileges now that you have several patches under your belt. For more information on that, see: https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

clang-tools-extra/clang-tidy/fuchsia/TrailingReturnCheck.cpp

 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace fuchsia {
 
-namespace {
-AST_MATCHER(FunctionDecl, hasTrailingReturn) {
-  return Node.getType()->castAs<FunctionProtoType>()->hasTrailingReturn();
-}
-} // namespace
-
 void TrailingReturnCheck::registerMatchers(MatchFinder *Finder) {
   // Functions that have trailing returns are disallowed, except for those
   // using decltype specifiers and lambda with otherwise unutterable
   // return types.
   Finder->addMatcher(
       functionDecl(hasTrailingReturn(),
                    unless(anyOf(returns(decltypeType()),
-                                hasParent(cxxRecordDecl(isLambda())))))
+                                hasParent(cxxRecordDecl(isLambda())),
+                                cxxDeductionGuideDecl())))
           .bind("decl"),
       this);
 }
 
 void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *D = Result.Nodes.getNodeAs<Decl>("decl"))
+  if (const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl"))
     diag(D->getBeginLoc(),
-         "a trailing return type is disallowed for this type of declaration");
+         "a trailing return type is disallowed for this function declaration");
 }
 
 } // namespace fuchsia
 } // namespace tidy
 } // namespace clang

clang-tools-extra/test/clang-tidy/checkers/fuchsia-trailing-return.cpp

-// RUN: %check_clang_tidy %s fuchsia-trailing-return %t
+// RUN: %check_clang_tidy -std=c++17-or-later %s fuchsia-trailing-return %t
 
 int add_one(const int arg) { return arg; }
 
 auto get_add_one() -> int (*)(const int) {
-  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: a trailing return type is disallowed for this type of declaration
+  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: a trailing return type is disallowed for this function declaration
   // CHECK-NEXT: auto get_add_one() -> int (*)(const int) {
   return add_one;
 }
 
 auto lambda = [](double x, double y) {return x + y;};
 
 auto lambda2 = [](double x, double y) -> double {return x + y;};
 
 int main() {
   get_add_one()(5);
   return 0;
 }
 
 template <typename T1, typename T2>
 auto fn(const T1 &lhs, const T2 &rhs) -> decltype(lhs + rhs) {
   return lhs + rhs;
 }
+
+// Now check that implicit and explicit C++17 deduction guides don't trigger this warning (PR#47614).
+
+template <typename T>
+struct ImplicitDeductionGuides {
+  ImplicitDeductionGuides(const T &);
+};
+
+template <typename A, typename B>
+struct pair {
+  A first;
+  B second;
+};
+
+template <typename T>
+struct UserDefinedDeductionGuides {
+  UserDefinedDeductionGuides(T);
+  template <typename T1, typename T2>
+  UserDefinedDeductionGuides(T1, T2);
+};
+
+template <typename T1, typename T2>
+UserDefinedDeductionGuides(T1, T2) -> UserDefinedDeductionGuides<pair<T1, T2>>;
+
+void foo() {
+  ImplicitDeductionGuides X(42);
+  UserDefinedDeductionGuides s(1, "abc");
+}