[clang-tidy] modernize-use-trailing-return-type support for C++20 concepts and decltype

[bernhardmgruber]

Summary

• fixed flags in RUN declaration in lit test
• added tests for C++20 concepts and requires clause
• added manual tokenization for AutoType return types which are not plain 'auto' to find source range
  • 'const auto'
  • 'Concept<int> auto'
  • 'decltype(auto)'
• improved formatting of documentation
• support for 'decltype(...)'
• added test for bug 44206, which seems to be fixed
• removed stale FIXME

[bernhardmgruber]

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

286–303

Is there an easier way to get the token previous to the function name?

clang-tools-extra/docs/clang-tidy/checks/modernize-use-trailing-return-type.rst

29

I tried 2 online rst editors and they failed to format the code blocks inside the tables. Will this work with the clang documentation?

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

555

How do you want to handle these tests which require C++20? I have seen other checks use a separate file for tests which require a different language version.

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

398–399

Non needed. See readability-redundant-control-flow.

clang-tools-extra/docs/clang-tidy/checks/modernize-use-trailing-return-type.rst

29

In other documentation such examples are sequential. Same below.

[bernhardmgruber]

• split code tables in documentation
• removed unnecessary return statement

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

398–399

Thx!

clang-tools-extra/docs/clang-tidy/checks/modernize-use-trailing-return-type.rst

29

Ok! I will separate the code blocks again.

[njames93]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

555

Yes, move them into a seperate file and specify -std=c++20 in the run line

[bernhardmgruber]

moved C++20 tests to a new file

[bernhardmgruber]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

555

Ok, done. Thx!

[bernhardmgruber]

Ping.

Furthermore: how can I schedule another CI build with the newest version of the diff? When I go to the failed build from Harbormaster and I click restart, it rebuilds an older version of the diff. Thanks for the info!

[njames93]

In D80514#2070843, @bernhardmgruber wrote:

Ping.

Furthermore: how can I schedule another CI build with the newest version of the diff? When I go to the failed build from Harbormaster and I click restart, it rebuilds an older version of the diff. Thanks for the info!

The restart build feature is only really useful when something on trunk caused the failure and will restart the build with the diff it had when the build was first started. The CI should build each time you update the diff, not sure why it isn't, but I don't think there is a special way to fix that. As the failure was caused by the test cases you could try and run ninja check-clang-tools from your build directory to ensure things are working, Alternatively if you upload another diff it should force a new build.

[bernhardmgruber]

Reuploaded diff in an attempt to trigger a CI build.

[njames93]

In D80514#2071056, @bernhardmgruber wrote:

Reuploaded diff in an attempt to trigger a CI build.

It's not working, Still no big issue, when its ready to land just the checks locally

[bernhardmgruber]

In D80514#2071202, @njames93 wrote:

In D80514#2071056, @bernhardmgruber wrote:

Reuploaded diff in an attempt to trigger a CI build.

It's not working, Still no big issue, when its ready to land just the checks locally

That's exactly the issue; the tests run fine on my local machine. I run check_clang_tidy.py manually, since I lack some Unix tools for the full test suite. And the CI build that failed seems to have used the first verison of my diff, which I updated in the meantime. From my point of few the diff is ready. I am just waiting for feedback, a LGTM and a nice person who can commit it for me :)

[bernhardmgruber]

Ping.

[bernhardmgruber]

Ping.

[bernhardmgruber]

Ping.

Is there anything I am not seeing here that you still would like me to do? I feel like you are waiting for something obvious from my side :S.

[aaron.ballman]

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

286–303

There isn't, but if you find you're missing source location information for something, you can also consider modifying Clang to add that source location information and mark this as a dependent patch. It's not clear to me whether that would be worth the effort for this patch or not, but my preference is to avoid these little hacks whenever possible.

294

Should we verify that End is valid before doing this pointer arithmetic with a value derived from it? For instance, what if End points into the scratch buffer because it relies on a macro defined on the command line -- will the logic still work?

431

Why do we need to check that there aren't any nested local qualifiers?

[bernhardmgruber]

• Added two more tests with a macro supplied on the command line
• Rebased onto master

[aaron.ballman]

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

431

I'm still wondering about this.

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

0–1

The change to the language standard line makes me wonder if the fixme below it is now stale, or if the test will fail in C++20 mode.

[bernhardmgruber]

Great, it seems I forgot to submit the inline comments. Sorry about that!

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

286–303

Thank you for the hint! I considered this for the concept location in an AutoReturnType and the expression inside a decltype AutoReturnType. Unfortunately I could not wrap my head around what is going on in SemaType.cpp :/

294

That sounded like a scary scenario! Fortunately, expandIfMacroId even expands source locations inside the scratch buffer correctly into a location in a real file. I added two tests for it and they seem to pass. Thank you for the hint!

431

Because I would like the check to rewrite e.g. const auto f(); into auto f() -> const auto;. If I omit the check for nested local qualifiers, then those kind of declarations would be skipped.

[bernhardmgruber]

Removed probably stale FIXME.

[bernhardmgruber]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

0–1

I just ran the tests again using python .\check_clang_tidy.py -std=c++20 .\checkers\modernize-use-trailing-return-type.cpp modernize-use-trailing-return-type aa -- -- -DCOMMAND_LINE_INT=int and I did not see mentioning of the use of an uninitialized variable. But I run on Windows, maybe the issue just surfaces on another OS? Is there a way to trigger the CI again?

I removed the FIXME in question in the hope the issue resolved itself.

[bernhardmgruber]

Ping.

[aaron.ballman]

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

431

Because I would like the check to rewrite e.g. const auto f(); into auto f() -> const auto;. If I omit the check for nested local qualifiers, then those kind of declarations would be skipped.

I don't think I understand why that's desirable though? What is it about the qualifier that makes it worthwhile to repeat the type like that?

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

0–1

But I run on Windows, maybe the issue just surfaces on another OS? Is there a way to trigger the CI again?

I also run on Windows so I can't easily test the behavior elsewhere for you. The CI will get triggered on new patch uploads, but I still don't always trust it. The bots are usually a more reliable source of CI truth but we have no way to speculatively trigger all the bots.

[riccibruno]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

0–1

I can run it for you with asan/msan.

[riccibruno]

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

0–1

No warning with either asan or msan on x86-64 linux with clang 10.

[bernhardmgruber]

Btw: what is the general rule for Phabricator reviews here when to tick the Done checkbox of a comment? What is the semantic of this checkbox? Is the ticked state the same for everyone?

Thank you for the help!

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

431

Thank you for insisting on that peculiarity! The choice is stylistically motivated to align function names:

auto f() -> int;
auto g() -> std::vector<float>;
auto& h();
const auto k();
decltype(auto) l();

vs.

auto f() -> int;
auto g() -> std::vector<float>;
auto h() -> auto&;
auto k() -> const auto; 
auto l() -> decltype(auto);

But judging from your response, this might be a surprise to users. Would you prefer having an option to enable/disable this behavior?

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

0–1

Thank you @riccibruno for verifying that for me!

[aaron.ballman]

In D80514#2206019, @bernhardmgruber wrote:

Btw: what is the general rule for Phabricator reviews here when to tick the Done checkbox of a comment? What is the semantic of this checkbox? Is the ticked state the same for everyone?

I don't think we have any hard-and-fast rules for it and I suspect the ticked state differs from review to review. Personally, I appreciate when the person who was asked to do some work is the one to check the Done box signalling that they think it's done (whether it's an author fixing a comment from a reviewer or a reviewer answering a question from an author, etc). This tells me "hey, someone thinks this is done, go look at it and comment if you disagree." However, I am guessing others have a different workflow.

I don't think I have any further concerns with this patch, so LGTM.

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

431

But judging from your response, this might be a surprise to users. Would you prefer having an option to enable/disable this behavior?

Maybe it will be, maybe it won't. :-D The reason I was surprised was because it feels like a formatting related choice rather than a modernization related choice. However, I've always struggled to understand the utility of this check (it's one I disable in every .clang-tidy configuration file I can), so my reasoning may be flawed. I feel like the goal of this check isn't to format code nicely, it's to modernize to using a trailing return type where that adds clarity. But I don't think auto& func() changing into auto func() -> auto& adds clarity (I think it removes clarity because the second signature is strictly more complex than the first), and similar for qualifiers. However, I think the exact same thing about int func() changing into auto func() -> int.

Given that we document this function to rewrite all functions to a trailing return type signature, I guess the behavior you've proposed here is consistent with that goal and so I'm fine with it.

[bernhardmgruber]

Thank you for the time to review this!

Could you please also commit it for me? Thank you!

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

431

However, I've always struggled to understand the utility of this check (it's one I disable in every .clang-tidy configuration file I can)

I am sorry to hear that, but I have heard this from many other people as well. I am sometimes questioning myself whether it was a mistake to put this check into clang-tidy and annoy a lot of people. It might have been better as a standalone tool.

I feel like the goal of this check isn't to format code nicely, it's to modernize to using a trailing return type where that adds clarity.

I like that thinking! I started with trailing return types as a stylistic choice, but I soon realized that it indeed can add clarity by shifting away complicated return types to the end of a line where they bother me less.

But I don't think auto& func() changing into auto func() -> auto& adds clarity (I think it removes clarity because the second signature is strictly more complex than the first).

With regard to clarity, you are right. And I noted down now that I shall add an option to prevent some of these rewrites. Thank you for the feedback!

[aaron.ballman]

I've commit on your behalf in 345053390ac17dd4a2e759de9e0e24c2605035db, thank you for the patch!

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

431

I am sorry to hear that, but I have heard this from many other people as well. I am sometimes questioning myself whether it was a mistake to put this check into clang-tidy and annoy a lot of people. It might have been better as a standalone tool.

FWIW, I don't question whether it was a mistake to add it. I just figure it wasn't targeted at me, and that's fine too. I can see the utility for people who want that kind of declaration style.

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.h

private:
   SourceLocation findTrailingReturnTypeSourceLocation(
       const FunctionDecl &F, const FunctionTypeLoc &FTL, const ASTContext &Ctx,
       const SourceManager &SM, const LangOptions &LangOpts);
   llvm::Optional<SmallVector<ClassifiedToken, 8>>
   classifyTokensBeforeFunctionName(const FunctionDecl &F, const ASTContext &Ctx,
                                    const SourceManager &SM,
                                    const LangOptions &LangOpts);
   SourceRange findReturnTypeAndCVSourceRange(const FunctionDecl &F,
+                                             const TypeLoc &ReturnLoc,
                                              const ASTContext &Ctx,
                                              const SourceManager &SM,
                                              const LangOptions &LangOpts);
-  bool keepSpecifiers(std::string &ReturnType, std::string &Auto,
+  void keepSpecifiers(std::string &ReturnType, std::string &Auto,
                       SourceRange ReturnTypeCVRange, const FunctionDecl &F,
                       const FriendDecl *Fr, const ASTContext &Ctx,
                       const SourceManager &SM, const LangOptions &LangOpts);
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNTYPECHECK_H

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

Result = Result || hasAnyNestedLocalQualifiers(
                            Type->castAs<PointerType>()->getPointeeType());
   if (Type->isReferenceType())
     Result = Result || hasAnyNestedLocalQualifiers(
                            Type->castAs<ReferenceType>()->getPointeeType());
   return Result;
 }
 
 SourceRange UseTrailingReturnTypeCheck::findReturnTypeAndCVSourceRange(
-    const FunctionDecl &F, const ASTContext &Ctx, const SourceManager &SM,
-    const LangOptions &LangOpts) {
+    const FunctionDecl &F, const TypeLoc &ReturnLoc, const ASTContext &Ctx,
+    const SourceManager &SM, const LangOptions &LangOpts) {
 
   // We start with the range of the return type and expand to neighboring
   // qualifiers (const, volatile and restrict).
   SourceRange ReturnTypeRange = F.getReturnTypeSourceRange();
   if (ReturnTypeRange.isInvalid()) {
     // Happens if e.g. clang cannot resolve all includes and the return type is
     // unknown.
     diag(F.getLocation(), Message);
     return {};
   }
 
+  // If the return type is a constrained 'auto' or 'decltype(auto)', we need to
+  // include the tokens after the concept. Unfortunately, the source range of an
+  // AutoTypeLoc, if it is constrained, does not include the 'auto' or
+  // 'decltype(auto)'. If the return type is a plain 'decltype(...)', the
+  // source range only contains the first 'decltype' token.
+  auto ATL = ReturnLoc.getAs<AutoTypeLoc>();
+  if ((ATL && (ATL.isConstrained() ||
+               ATL.getAutoKeyword() == AutoTypeKeyword::DecltypeAuto)) ||
+      ReturnLoc.getAs<DecltypeTypeLoc>()) {
+    SourceLocation End =
+        expandIfMacroId(ReturnLoc.getSourceRange().getEnd(), SM);
+    SourceLocation BeginNameF = expandIfMacroId(F.getLocation(), SM);
+
+    // Extend the ReturnTypeRange until the last token before the function
+    // name.
+    std::pair<FileID, unsigned> Loc = SM.getDecomposedLoc(End);
+    StringRef File = SM.getBufferData(Loc.first);
+    const char *TokenBegin = File.data() + Loc.second;
+    Lexer Lexer(SM.getLocForStartOfFile(Loc.first), LangOpts, File.begin(),
+                TokenBegin, File.end());
+    Token T;
+    SourceLocation LastTLoc = End;
+    while (!Lexer.LexFromRawLexer(T) &&
+           SM.isBeforeInTranslationUnit(T.getLocation(), BeginNameF)) {
+      LastTLoc = T.getLocation();
+    }
+    ReturnTypeRange.setEnd(LastTLoc);
+  }
+
   // If the return type has no local qualifiers, it's source range is accurate.
   if (!hasAnyNestedLocalQualifiers(F.getReturnType()))
     return ReturnTypeRange;
 
   // Include qualifiers to the left and right of the return type.
   llvm::Optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
       classifyTokensBeforeFunctionName(F, Ctx, SM, LangOpts);
   if (!MaybeTokens)
SourceRange UseTrailingReturnTypeCheck::findReturnTypeAndCVSourceRange(
 
   assert(!ReturnTypeRange.getBegin().isMacroID() &&
          "Return type source range begin must not be a macro");
   assert(!ReturnTypeRange.getEnd().isMacroID() &&
          "Return type source range end must not be a macro");
   return ReturnTypeRange;
 }
 
-bool UseTrailingReturnTypeCheck::keepSpecifiers(
+void UseTrailingReturnTypeCheck::keepSpecifiers(
     std::string &ReturnType, std::string &Auto, SourceRange ReturnTypeCVRange,
     const FunctionDecl &F, const FriendDecl *Fr, const ASTContext &Ctx,
     const SourceManager &SM, const LangOptions &LangOpts) {
   // Check if there are specifiers inside the return type. E.g. unsigned
   // inline int.
   const auto *M = dyn_cast<CXXMethodDecl>(&F);
   if (!F.isConstexpr() && !F.isInlineSpecified() &&
       F.getStorageClass() != SC_Extern && F.getStorageClass() != SC_Static &&
       !Fr && !(M && M->isVirtualAsWritten()))
-    return true;
+    return;
 
   // Tokenize return type. If it contains macros which contain a mix of
   // qualifiers, specifiers and types, give up.
   llvm::Optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
       classifyTokensBeforeFunctionName(F, Ctx, SM, LangOpts);
   if (!MaybeTokens)
-    return false;
+    return;
 
   // Find specifiers, remove them from the return type, add them to 'auto'.
   unsigned int ReturnTypeBeginOffset =
       SM.getDecomposedLoc(ReturnTypeCVRange.getBegin()).second;
   size_t InitialAutoLength = Auto.size();
   unsigned int DeletedChars = 0;
   for (ClassifiedToken CT : *MaybeTokens) {
     if (SM.isBeforeInTranslationUnit(CT.T.getLocation(),
while (TOffsetInRT + TLengthWithWS < ReturnType.size() &&
            llvm::isSpace(ReturnType[TOffsetInRT + TLengthWithWS]))
       TLengthWithWS++;
     std::string Specifier = ReturnType.substr(TOffsetInRT, TLengthWithWS);
     if (!llvm::isSpace(Specifier.back()))
       Specifier.push_back(' ');
     Auto.insert(Auto.size() - InitialAutoLength, Specifier);
     ReturnType.erase(TOffsetInRT, TLengthWithWS);
     DeletedChars += TLengthWithWS;
   }
-
-  return true;
 }
 
 void UseTrailingReturnTypeCheck::registerMatchers(MatchFinder *Finder) {
-  auto F = functionDecl(unless(anyOf(hasTrailingReturn(), returns(voidType()),
-                                     returns(autoType()), cxxConversionDecl(),
-                                     cxxMethodDecl(isImplicit()))))
+  auto F = functionDecl(
+               unless(anyOf(hasTrailingReturn(), returns(voidType()),
+                            cxxConversionDecl(), cxxMethodDecl(isImplicit()))))
                .bind("Func");
 
   Finder->addMatcher(F, this);
   Finder->addMatcher(friendDecl(hasDescendant(F)).bind("Friend"), this);
 }
 
 void UseTrailingReturnTypeCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
   this->PP = PP;
 }
 
 void UseTrailingReturnTypeCheck::check(const MatchFinder::MatchResult &Result) {
   assert(PP && "Expected registerPPCallbacks() to have been called before so "
                "preprocessor is available");
 
   const auto *F = Result.Nodes.getNodeAs<FunctionDecl>("Func");
   const auto *Fr = Result.Nodes.getNodeAs<FriendDecl>("Friend");
   assert(F && "Matcher is expected to find only FunctionDecls");
 
   if (F->getLocation().isInvalid())
     return;
 
+  // Skip functions which return just 'auto'.
+  const auto *AT = F->getDeclaredReturnType()->getAs<AutoType>();
+  if (AT != nullptr && !AT->isConstrained() &&
+      AT->getKeyword() == AutoTypeKeyword::Auto &&
+      !hasAnyNestedLocalQualifiers(F->getDeclaredReturnType()))
+    return;
+
   // TODO: implement those
   if (F->getDeclaredReturnType()->isFunctionPointerType() ||
       F->getDeclaredReturnType()->isMemberFunctionPointerType() ||
-      F->getDeclaredReturnType()->isMemberPointerType() ||
-      F->getDeclaredReturnType()->getAs<DecltypeType>() != nullptr) {
+      F->getDeclaredReturnType()->isMemberPointerType()) {
     diag(F->getLocation(), Message);
     return;
   }
 
   const ASTContext &Ctx = *Result.Context;
   const SourceManager &SM = *Result.SourceManager;
   const LangOptions &LangOpts = getLangOpts();
 
if (InsertionLoc.isInvalid()) {
     diag(F->getLocation(), Message);
     return;
   }
 
   // Using the declared return type via F->getDeclaredReturnType().getAsString()
   // discards user formatting and order of const, volatile, type, whitespace,
   // space before & ... .
   SourceRange ReturnTypeCVRange =
-      findReturnTypeAndCVSourceRange(*F, Ctx, SM, LangOpts);
+      findReturnTypeAndCVSourceRange(*F, FTL.getReturnLoc(), Ctx, SM, LangOpts);
   if (ReturnTypeCVRange.isInvalid())
     return;
 
   // Check if unqualified names in the return type conflict with other entities
   // after the rewrite.
   // FIXME: this could be done better, by performing a lookup of all
   // unqualified names in the return type in the scope of the function. If the
   // lookup finds a different entity than the original entity identified by the

clang-tools-extra/docs/clang-tidy/checks/modernize-use-trailing-return-type.rst

 
 .. code-block:: c++
 
   auto f1() -> int;
   inline auto f2(int arg) -> int noexcept;
   virtual auto f3() const && -> float = delete;
 
 Known Limitations
 -----------------
 
 The following categories of return types cannot be rewritten currently:
+
 * function pointers
 * member function pointers
 * member pointers
-* decltype, when it is the top level expression
 
 Unqualified names in the return type might erroneously refer to different entities after the rewrite.
 Preventing such errors requires a full lookup of all unqualified names present in the return type in the scope of the trailing return type location.
 This location includes e.g. function parameter names and members of the enclosing class (including all inherited classes).
 Such a lookup is currently not implemented.
 
 Given the following piece of code
 
 .. code-block:: c++
 
-  struct Object { long long value; };
-  Object f(unsigned Object) { return {Object * 2}; }
+  struct S { long long value; };
+  S f(unsigned S) { return {S * 2}; }
   class CC {
-    int Object;
-    struct Object m();
+    int S;
+    struct S m();
   };
-  Object CC::m() { return {0}; }
+  S CC::m() { return {0}; }
 
 a careless rewrite would produce the following output:
 
 .. code-block:: c++
 
-  struct Object { long long value; };
-  auto f(unsigned Object) -> Object { return {Object * 2}; } // error
+  struct S { long long value; };
+  auto f(unsigned S) -> S { return {S * 2}; } // error
   class CC {
-    int Object;
-    auto m() -> struct Object;
+    int S;
+    auto m() -> struct S;
   };
-  auto CC::m() -> Object { return {0}; } // error
+  auto CC::m() -> S { return {0}; } // error
 
-This code fails to compile because the Object in the context of f refers to the equally named function parameter.
-Similarly, the Object in the context of m refers to the equally named class member.
-The check can currently only detect a clash with a function parameter name.
+This code fails to compile because the S in the context of f refers to the equally named function parameter.
+Similarly, the S in the context of m refers to the equally named class member.
+The check can currently only detect and avoid a clash with a function parameter name.

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type-cxx20.cpp

+// RUN: %check_clang_tidy -std=c++20 %s modernize-use-trailing-return-type %t
+
+namespace std {
+template <typename T, typename U>
+struct is_same { static constexpr auto value = false; };
+
+template <typename T>
+struct is_same<T, T> { static constexpr auto value = true; };
+
+template <typename T>
+concept floating_point = std::is_same<T, float>::value || std::is_same<T, double>::value || std::is_same<T, long double>::value;
+}
+
+//
+// Concepts
+//
+
+std::floating_point auto con1();
+// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto con1() -> std::floating_point auto;{{$}}
+
+std::floating_point auto con1() { return 3.14f; }
+// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto con1() -> std::floating_point auto { return 3.14f; }{{$}}
+
+namespace a {
+template <typename T>
+concept Concept = true;
+
+template <typename T, typename U>
+concept BinaryConcept = true;
+}
+
+a::Concept decltype(auto) con2();
+// CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto con2() -> a::Concept decltype(auto);{{$}}
+
+a::BinaryConcept<int> decltype(auto) con3();
+// CHECK-MESSAGES: :[[@LINE-1]]:38: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto con3() -> a::BinaryConcept<int> decltype(auto);{{$}}
+
+const std::floating_point auto* volatile con4();
+// CHECK-MESSAGES: :[[@LINE-1]]:42: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto con4() -> const std::floating_point auto* volatile;{{$}}
+
+template <typename T>
+int req1(T t) requires std::floating_point<T>;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto req1(T t) -> int requires std::floating_point<T>;{{$}}
+
+template <typename T>
+T req2(T t) requires requires { t + t; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+  // CHECK-FIXES: {{^}}auto req2(T t) -> T requires requires { t + t; };{{$}}

clang-tools-extra/test/clang-tidy/checkers/modernize-use-trailing-return-type.cpp

-// RUN: %check_clang_tidy -std=c++14,c++17 %s modernize-use-trailing-return-type %t -- -- -fdeclspec -fexceptions
-// FIXME: Fix the checker to work in C++20 mode, it is performing a
-// use-of-uninitialized-value.
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-use-trailing-return-type %t -- -- -fdeclspec -fexceptions -DCOMMAND_LINE_INT=int
 
 namespace std {
     template <typename T>
     class vector;
 
     template <typename T, int N>
     class array;
 
     class string;
 
+    class ostream;
+
     template <typename T>
     auto declval() -> T;
 }
 
 //
 // Functions
 //
 

 static const char* const * const * const e12(void* user_data);
 // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}static auto e12(void* user_data) -> const char* const * const * const;{{$}}
 struct A e13();
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}auto e13() -> struct A;{{$}}
 
 //
-// decltype (unsupported if top level expression)
+// deduced return types
 //
 
+const auto ded1();
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto ded1() -> const auto;{{$}}
+const auto& ded2();
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto ded2() -> const auto&;{{$}}
+
+decltype(auto) ded3();
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto ded3() -> decltype(auto);{{$}}
+
+
 decltype(1 + 2) dec1() { return 1 + 2; }
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
-// TODO: source range of DecltypeTypeLoc not yet implemented
-// _HECK-FIXES: {{^}}auto dec1() -> decltype(1 + 2) { return 1 + 2; }{{$}}
+// CHECK-FIXES: {{^}}auto dec1() -> decltype(1 + 2) { return 1 + 2; }{{$}}
 template <typename F, typename T>
 decltype(std::declval<F>(std::declval<T>)) dec2(F f, T t) { return f(t); }
 // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
-// TODO: source range of DecltypeTypeLoc not yet implemented
-// _HECK-FIXES: {{^}}auto dec2(F f, T t) -> decltype(std::declval<F>(std::declval<T>)) { return f(t); }{{$}}
+// CHECK-FIXES: {{^}}auto dec2(F f, T t) -> decltype(std::declval<F>(std::declval<T>)) { return f(t); }{{$}}
 template <typename T>
 typename decltype(std::declval<T>())::value_type dec3();
 // CHECK-MESSAGES: :[[@LINE-1]]:50: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}auto dec3() -> typename decltype(std::declval<T>())::value_type;{{$}}
 template <typename T>
 decltype(std::declval<T>())* dec4();
 // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}auto dec4() -> decltype(std::declval<T>())*;{{$}}

 #define CONST_CAT con##st
 CONST_CAT int& h19();
 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}auto h19() -> CONST_CAT int&;{{$}}
 #define CONST_F_MACRO WRAP(CONST_CAT)
 CONST_F_MACRO int& h19();
 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}auto h19() -> CONST_F_MACRO int&;{{$}}
+// Macro COMMAND_LINE_INT is defined on the command line via: -DCOMMAND_LINE_INT=int
+const COMMAND_LINE_INT& h20();
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto h20() -> const COMMAND_LINE_INT&;{{$}}
+decltype(COMMAND_LINE_INT{}) h21();
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}auto h21() -> decltype(COMMAND_LINE_INT{});{{$}}
 
 //
 // Name collisions
 //
 struct Object { long long value; };
 
 Object j1(unsigned Object) { return {Object * 2}; }
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use a trailing return type for this function [modernize-use-trailing-return-type]

 // CHECK-FIXES: {{^}}    auto g() -> ::Object;{{$}}
 };
 Object DD::g() {
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
 // CHECK-FIXES: {{^}}auto DD::g() -> Object {{{$}}
     return {0};
 }
 
+//
+// bug 44206, no rewrite should happen due to collision with parameter name
+//
+
+using std::ostream;
+ostream& operator<<(ostream& ostream, int i);
+// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use a trailing return type for this function [modernize-use-trailing-return-type]
+// CHECK-FIXES: {{^}}ostream& operator<<(ostream& ostream, int i);{{$}}
 
 //
 // Samples which do not trigger the check
 //
 
 auto f() -> int;
 auto f(int) -> int;
 auto f(int arg) -> int;
 auto f(int arg1, int arg2, int arg3) -> int;
 auto f(int arg1, int arg2, int arg3, ...) -> int;
 template <typename T> auto f(T t) -> int;
 
 auto ff();
-decltype(auto) fff();
 
 void c();
 void c(int arg);
 void c(int arg) { return; }
 
 struct D2 : B {
     D2();
     virtual ~D2();