[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