[clang-tools-extra] [clang-tidy] Fix use-trailing-return-type insert location for lambdas (PR #240117)

via cfe-commits cfe-commits at lists.llvm.org
Sun Nov 8 02:58:42 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-clang-tools-extra

Author: awrrrr

<details>
<summary>Changes</summary>

Depends on #<!-- -->240116. GitHub shows that PR's commit here too, so please review only the last commit, "[clang-tidy] Fix use-trailing-return-type insert location for lambdas". I'll rebase this onto main once #<!-- -->240116 lands.

`modernize-use-trailing-return-type` inserted a lambda's trailing return type one character before the body or `requires` clause. When nothing separated the body from the preceding token, that split the token. When the body came from a macro, the check could crash.

| Input | Before | After |
|---|---|---|
| `[](){ return 1; }` | `[]( -> int){ return 1; }` | `[]() -> int{ return 1; }` |
| `[](int i){ return i; }` | `[](int i -> int){ return i; }` | `[](int i) -> int{ return i; }` |
| `[x]() mutable{ return x; }` | `[x]() mutabl -> inte{ return x; }` | `[x]() mutable -> int{ return x; }` |
| `[]{ return 1; }` (C++23) | `[ -> int]{ return 1; }` | `[] -> int{ return 1; }` |
| `[]() /*c*/{ return 1; }` | `[]() /*c* -> int/{ return 1; }` | `[]() -> int /*c*/{ return 1; }` |
| `[]() // c` + newline + `{ return 1; }` | `-> int` lost inside the comment | `[]() -> int // c` |
| `[](int i)requires true { ... }` | `[](int i -> auto)requires true` | `[](int i) -> auto requires true` |
| `#define BODY { return 1; }` then `[] BODY` | assertion `isExpansion() && "Not a macro expansion SLocEntry!"` | warning, no fix |

The crash happened when the body's macro was the first macro expansion in the file: the location one character before the body then belonged to the file instead of an expansion.

The check now inserts the return type after the token before the body or `requires` clause, skipping comments, and adds a space if `requires` follows directly. If the body comes from a macro, it keeps the warning but doesn't offer a fix, unless the lambda is written inside a macro argument, such as `ID([](){ return 1; })`, where the fix still applies.

Because the return type now always goes right after the previous token, two existing expectations change:

- In `use-trailing-return-type-transform-lambdas-no-parameter-clause.cpp`, C++23: `[&x] /* comment */ -> int` becomes `[&x] -> int /* comment */`, matching the pre-C++23 fix `[&x]() -> int /* comment */`.
- In `use-trailing-return-type-transform-lambdas-cxx20.cpp`, a `requires` clause on its own line now gets `noexcept -> auto` at the end of the line above, instead of `-> auto requires ...` on its own line.

Known limitation: if a preprocessor directive sits between the parameter list and the body, the return type now lands after the directive, for example `#endif -> int`, and is ignored. Before this change that case only worked when the body was indented.

Tests: the new `use-trailing-return-type-transform-lambdas-insert-location.cpp` covers C++11 through C++23. It failed on the old code, including the assertion, which needs the macro case to stay the first expansion in the file.

I used Claude Code to help write this change, and I have reviewed all of it myself.

Assisted-by: Claude Code

🤖 Generated with [Claude Code](https://claude.com/claude-code)


---

Patch is 21.38 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/240117.diff


6 Files Affected:

- (modified) clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp (+70-5) 
- (modified) clang-tools-extra/docs/ReleaseNotes.md (+8) 
- (modified) clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp (+2-2) 
- (added) clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-insert-location.cpp (+118) 
- (added) clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-no-parameter-clause.cpp (+62) 
- (modified) clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp (+4-8) 


``````````diff
diff --git a/clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp b/clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp
index b4feecbd22a10c..33b75da965911e 100644
--- a/clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp
@@ -7,9 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "UseTrailingReturnTypeCheck.h"
+#include "../utils/LexerUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/CharInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/FixIt.h"
 #include "llvm/ADT/StringExtras.h"
@@ -363,6 +365,26 @@ findReturnTypeAndCVSourceRange(const FunctionDecl &F, const TypeLoc &ReturnLoc,
   return ReturnTypeRange;
 }
 
+// Returns the end of the token before Loc, so that text inserted there can't
+// split a token or end up in a comment, or an invalid location if that token
+// can't be edited as part of the same lambda.
+static SourceLocation findEndOfPreviousToken(SourceLocation Loc,
+                                             const SourceManager &SM,
+                                             const LangOptions &LangOpts) {
+  if (Loc.isMacroID()) {
+    // What comes before a location at the start of a macro argument isn't
+    // necessarily next to it in the file.
+    if (!SM.isMacroArgExpansion(Loc) ||
+        SM.isAtStartOfImmediateMacroExpansion(Loc))
+      return {};
+    Loc = SM.getSpellingLoc(Loc);
+  }
+
+  const std::optional<Token> PreviousToken =
+      utils::lexer::getPreviousToken(Loc, SM, LangOpts);
+  return PreviousToken ? PreviousToken->getEndLoc() : SourceLocation();
+}
+
 static SourceLocation findLambdaTrailingReturnInsertLoc(
     const CXXMethodDecl *Method, const SourceManager &SM,
     const LangOptions &LangOpts, const ASTContext &Ctx) {
@@ -392,7 +414,7 @@ static SourceLocation findLambdaTrailingReturnInsertLoc(
       }
 
       if (Token.is(tok::kw_requires))
-        return Token.getLocation().getLocWithOffset(-1);
+        return findEndOfPreviousToken(Token.getLocation(), SM, LangOpts);
     }
 
     return {};
@@ -400,11 +422,32 @@ static SourceLocation findLambdaTrailingReturnInsertLoc(
 
   // If no requires clause, insert before the body
   if (const Stmt *Body = Method->getBody())
-    return Body->getBeginLoc().getLocWithOffset(-1);
+    return findEndOfPreviousToken(Body->getBeginLoc(), SM, LangOpts);
 
   return {};
 }
 
+// Returns where a parameter clause can be added to a lambda without one, or an
+// invalid location if specifiers or a requires clause come before the body.
+static SourceLocation
+findLambdaParameterClauseInsertLoc(const LambdaExpr *Lambda,
+                                   const SourceManager &SM,
+                                   const LangOptions &LangOpts) {
+  const TemplateParameterList *TemplateParams =
+      Lambda->getTemplateParameterList();
+  const SourceLocation LastTokenLoc =
+      TemplateParams ? TemplateParams->getRAngleLoc()
+                     : Lambda->getIntroducerRange().getEnd();
+
+  const std::optional<Token> NextToken =
+      Lexer::findNextToken(LastTokenLoc, SM, LangOpts);
+  if (!NextToken ||
+      NextToken->getLocation() != Lambda->getBody()->getBeginLoc())
+    return {};
+
+  return Lexer::getLocForEndOfToken(LastTokenLoc, 0, SM, LangOpts);
+}
+
 static void keepSpecifiers(std::string &ReturnType, std::string &Auto,
                            SourceRange ReturnTypeCVRange, const FunctionDecl &F,
                            const FriendDecl *Fr, const ASTContext &Ctx,
@@ -627,18 +670,40 @@ void UseTrailingReturnTypeCheck::diagOnLambda(
       TransformLambdas == TransformLambda::AllExceptAuto)
     return;
 
+  // Omitting the parameter clause before a trailing return type is only valid
+  // since C++23.
+  if (!Lambda->hasExplicitParameters() && !getLangOpts().CPlusPlus23) {
+    const SourceLocation ParameterClauseInsertLoc =
+        findLambdaParameterClauseInsertLoc(Lambda, *Result.SourceManager,
+                                           getLangOpts());
+    if (ParameterClauseInsertLoc.isValid())
+      diag(Lambda->getBeginLoc(), "use a trailing return type for this lambda")
+          << FixItHint::CreateInsertion(
+                 ParameterClauseInsertLoc,
+                 "() -> " + ReturnType.getAsString(
+                                Result.Context->getPrintingPolicy()));
+    else
+      diag(Lambda->getBeginLoc(), ErrorMessageOnLambda);
+    return;
+  }
+
   const SourceLocation TrailingReturnInsertLoc =
       findLambdaTrailingReturnInsertLoc(Method, *Result.SourceManager,
                                         getLangOpts(), *Result.Context);
 
-  if (TrailingReturnInsertLoc.isValid())
+  if (TrailingReturnInsertLoc.isValid()) {
+    // Don't merge the return type with a directly following 'requires'.
+    const char *NextChar =
+        Result.SourceManager->getCharacterData(TrailingReturnInsertLoc);
     diag(Lambda->getBeginLoc(), "use a trailing return type for this lambda")
         << FixItHint::CreateInsertion(
                TrailingReturnInsertLoc,
                " -> " +
-                   ReturnType.getAsString(Result.Context->getPrintingPolicy()));
-  else
+                   ReturnType.getAsString(Result.Context->getPrintingPolicy()) +
+                   (isAsciiIdentifierContinue(*NextChar) ? " " : ""));
+  } else {
     diag(Lambda->getBeginLoc(), ErrorMessageOnLambda);
+  }
 }
 
 } // namespace clang::tidy::modernize
diff --git a/clang-tools-extra/docs/ReleaseNotes.md b/clang-tools-extra/docs/ReleaseNotes.md
index 679ca9ecbb4a39..fdcbad372118ae 100644
--- a/clang-tools-extra/docs/ReleaseNotes.md
+++ b/clang-tools-extra/docs/ReleaseNotes.md
@@ -329,6 +329,14 @@ infrastructure are described first, followed by tool-specific sections.
   - Kept diagnostics but suppressed unsafe fix-its when no safe
     result-preserving rewrite is available.
 
+- Improved {doc}`modernize-use-trailing-return-type
+  <clang-tidy/checks/modernize/use-trailing-return-type>` check by adding `()`
+  to fixes for lambdas without a parameter clause before C++23, and not offering
+  a fix when that would need specifiers to be moved. The check also no longer
+  crashes on a lambda whose body comes from a macro, and no longer inserts the
+  return type inside the preceding token or comment, such as in
+  `[](){ return 1; }`.
+
 - Improved {doc}`performance-inefficient-algorithm
   <clang-tidy/checks/performance/inefficient-algorithm>` check to no longer
   produce a fix with the container or the searched-for value missing, such as
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp
index 24f135054fded7..7f773fa3954878 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-cxx20.cpp
@@ -25,7 +25,7 @@ void test_lambda_positive() {
     requires std::floating_point<T> && std::floating_point<U>
   { return x * y; };
   // CHECK-MESSAGES: :[[@LINE-3]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
-  // CHECK-FIXES: auto l5 = []<typename T, typename U>(T x, U y) constexpr noexcept
-  // CHECK-FIXES:   -> auto requires std::floating_point<T> && std::floating_point<U>
+  // CHECK-FIXES: auto l5 = []<typename T, typename U>(T x, U y) constexpr noexcept -> auto
+  // CHECK-FIXES:   requires std::floating_point<T> && std::floating_point<U>
   // CHECK-FIXES: { return x * y; };
 }
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-insert-location.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-insert-location.cpp
new file mode 100644
index 00000000000000..5e86ff8c4b6afa
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-insert-location.cpp
@@ -0,0 +1,118 @@
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s modernize-use-trailing-return-type %t
+// RUN: %check_clang_tidy -check-suffixes=,CXX20 -std=c++20 %s modernize-use-trailing-return-type %t
+// RUN: %check_clang_tidy -check-suffixes=,CXX20,CXX23 -std=c++23-or-later %s modernize-use-trailing-return-type %t
+
+// The return type has to go after the last token before the body, however that
+// token is separated from the body.
+
+#define ID(x) x
+#define APPLY_BODY(body) []() body
+#define PARENS ()
+#define BODY { return 1; }
+#define PARENS_AND_BODY () { return 1; }
+#define WHOLE_LAMBDA []() { return 1; }
+
+// This has to stay the first macro expansion in the file: the character before
+// the body then isn't part of any macro expansion, which used to crash.
+auto first_macro_expansion = [] BODY;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+// CHECK-FIXES: auto first_macro_expansion = [] BODY;
+
+void test_body_in_macro() {
+  auto l1 = []() BODY;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l1 = []() BODY;
+
+  auto l2 = [] PARENS_AND_BODY;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l2 = [] PARENS_AND_BODY;
+
+  auto l3 = WHOLE_LAMBDA;
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l3 = WHOLE_LAMBDA;
+
+  auto l4 = APPLY_BODY({ return 1; });
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l4 = APPLY_BODY({ return 1; });
+}
+
+void test_no_space_before_body() {
+  int x = 0;
+
+  auto l1 = [](){ return 1; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l1 = []() -> int{ return 1; };
+
+  auto l2 = [](int i){ return i; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l2 = [](int i) -> int{ return i; };
+
+  auto l3 = [x]() mutable{ return x; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l3 = [x]() mutable -> int{ return x; };
+
+  auto l4 = []() noexcept{ return 1; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l4 = []() noexcept -> int{ return 1; };
+
+  auto l5 = [] PARENS{ return 1; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l5 = [] PARENS -> int{ return 1; };
+
+#if __cplusplus >= 202302L
+  auto l6 = []{ return 1; };
+  // CHECK-MESSAGES-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-CXX23: auto l6 = [] -> int{ return 1; };
+#endif
+}
+
+void test_comment_before_body() {
+  auto l1 = []() /* comment */{ return 1; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l1 = []() -> int /* comment */{ return 1; };
+
+  auto l2 = []() /* comment */ { return 1; };
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l2 = []() -> int /* comment */ { return 1; };
+
+  auto l3 = []() // comment
+  // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l3 = []() -> int // comment
+  { return 1; };
+}
+
+void test_lambda_in_macro_argument() {
+  auto l1 = ID([]() { return 1; });
+  // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l1 = ID([]() -> int { return 1; });
+
+  auto l2 = ID([](){ return 1; });
+  // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l2 = ID([]() -> int{ return 1; });
+
+  auto l3 = ID(ID([](){ return 1; }));
+  // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES: auto l3 = ID(ID([]() -> int{ return 1; }));
+}
+
+#if __cplusplus >= 202002L
+template <typename T>
+void test_requires_clause(T t) {
+  auto l1 = [](int i)requires true { return i; };
+  // CHECK-MESSAGES-CXX20: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-CXX20: auto l1 = [](int i) -> auto requires true { return i; };
+
+  auto l2 = [](int i) /* comment */requires true { return i; };
+  // CHECK-MESSAGES-CXX20: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-CXX20: auto l2 = [](int i) -> auto /* comment */requires true { return i; };
+
+  auto l3 = [](int i) // comment
+  // CHECK-MESSAGES-CXX20: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-CXX20: auto l3 = [](int i) -> auto // comment
+    requires true { return i; };
+}
+
+auto generic_no_space = []<typename T>(T t){ return 1; };
+// CHECK-MESSAGES-CXX20: :[[@LINE-1]]:25: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+// CHECK-FIXES-CXX20: auto generic_no_space = []<typename T>(T t) -> auto{ return 1; };
+#endif
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-no-parameter-clause.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-no-parameter-clause.cpp
new file mode 100644
index 00000000000000..914992dbcb1ffd
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas-no-parameter-clause.cpp
@@ -0,0 +1,62 @@
+// RUN: %check_clang_tidy -check-suffix=BEFORE-CXX23 -std=c++11,c++14,c++17 %s modernize-use-trailing-return-type %t -- -- -Wno-c++23-extensions
+// RUN: %check_clang_tidy -check-suffixes=BEFORE-CXX23,CXX20 -std=c++20 %s modernize-use-trailing-return-type %t -- -- -Wno-c++23-extensions
+// RUN: %check_clang_tidy -check-suffixes=CXX23 -std=c++23-or-later %s modernize-use-trailing-return-type %t
+
+// A lambda can only omit its parameter clause before a trailing return type
+// since C++23 (P1102R2), so the fix has to add '()' in earlier language modes.
+
+#define LAMBDA_BODY { return 1; }
+
+void test_no_parameter_clause() {
+  int x = 0;
+
+  auto l1 = [] {};
+  // CHECK-MESSAGES-BEFORE-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-MESSAGES-CXX23: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-BEFORE-CXX23: auto l1 = []() -> void {};
+  // CHECK-FIXES-CXX23: auto l1 = [] -> void {};
+
+  auto l2 = [] { return 1; };
+  // CHECK-MESSAGES-BEFORE-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-MESSAGES-CXX23: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-BEFORE-CXX23: auto l2 = []() -> int { return 1; };
+  // CHECK-FIXES-CXX23: auto l2 = [] -> int { return 1; };
+
+  auto l3 = [&x] /* comment */ { return x; };
+  // CHECK-MESSAGES-BEFORE-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-MESSAGES-CXX23: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-BEFORE-CXX23: auto l3 = [&x]() -> int /* comment */ { return x; };
+  // CHECK-FIXES-CXX23: auto l3 = [&x] -> int /* comment */ { return x; };
+
+  // Specifiers would have to follow '()', so don't offer a fix before C++23.
+  auto l4 = [x] mutable { return x; };
+  // CHECK-MESSAGES-BEFORE-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-MESSAGES-CXX23: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-BEFORE-CXX23: auto l4 = [x] mutable { return x; };
+  // CHECK-FIXES-CXX23: auto l4 = [x] mutable -> int { return x; };
+
+#if __cplusplus < 202302L
+  auto l6 = []{ return 1; };
+  // CHECK-MESSAGES-BEFORE-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-BEFORE-CXX23: auto l6 = []() -> int{ return 1; };
+
+  auto l7 = [] LAMBDA_BODY;
+  // CHECK-MESSAGES-BEFORE-CXX23: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-BEFORE-CXX23: auto l7 = [] LAMBDA_BODY;
+#endif
+
+#if __cplusplus >= 202002L
+  auto l5 = []<typename T = int> { return T{}; };
+  // CHECK-MESSAGES-CXX20: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-MESSAGES-CXX23: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-CXX20: auto l5 = []<typename T = int>() -> auto { return T{}; };
+  // CHECK-FIXES-CXX23: auto l5 = []<typename T = int> -> auto { return T{}; };
+
+  // A requires clause would have to come before '()', so don't offer a fix
+  // before C++23.
+  auto l8 = []<typename T = int> requires true { return T{}; };
+  // CHECK-MESSAGES-CXX20: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-MESSAGES-CXX23: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
+  // CHECK-FIXES-CXX20: auto l8 = []<typename T = int> requires true { return T{}; };
+#endif
+}
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp
index 7570ca3008aeb5..3036c4477d39ff 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/use-trailing-return-type-transform-lambdas.cpp
@@ -14,10 +14,6 @@
 #include <vector>
 
 void test_lambda_positive() {
-  auto l01 = [] {};
-  // CHECK-MESSAGES-ALL: :[[@LINE-1]]:14: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
-  // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:14: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
-  // CHECK-FIXES-ALL: auto l01 = [] -> void {};
   auto l1 = []() {};
   // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
   // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
@@ -55,14 +51,14 @@ void test_lambda_positive() {
   // CHECK-MESSAGES-ALL: :[[@LINE-1]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
   // CHECK-MESSAGES-NOAUTO: :[[@LINE-2]]:13: warning: use a trailing return type for this lambda [modernize-use-trailing-return-type]
   // CHECK-FIXES-ALL: auto l8 = [&capture_int]() -> int { return capt...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/240117


More information about the cfe-commits mailing list