[Clang] Recover GLTemplateParameterList for generic lambdas in RebuildLambdaScopeInfo #118176
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
clang
|
@llvm/pr-subscribers-clang Author: Younan Zhang (zyn0217) ChangesThe NTTP argument appearing inside a trailing return type of a generic lambda would have to check for potential lambda captures, where the function needs GLTemplateParameterList of the current LSI to tell whether the lambda is generic. The lambda scope in this context is rebuilt by the LambdaScopeForCallOperatorInstantiationRAII when substituting the lambda operator during template argument deduction. Thus, I think the template parameter list should be preserved in the rebuilding process, as it seems otherwise innocuous to me. Fixes #115931 Full diff: https://github.com/llvm/llvm-project/pull/118176.diff 3 Files Affected:
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 8bd06fadfdc984..e8e8a8cff76e45 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -714,6 +714,8 @@ Bug Fixes to C++ Support
assumption if they also occur inside of a dependent lambda. (#GH114787)
- Clang now uses valid deduced type locations when diagnosing functions with trailing return type
missing placeholder return type. (#GH78694)
+- Fixed an incorrect lambda scope of generic lambdas that caused Clang to crash when computing potential lambda
+ captures at the end of a full expression. (#GH115931)
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 74b0e5ad23bd48..75389d6ba7bfd8 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -15504,10 +15504,25 @@ LambdaScopeInfo *Sema::RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator) {
LSI->CallOperator = CallOperator;
LSI->Lambda = LambdaClass;
LSI->ReturnType = CallOperator->getReturnType();
- // This function in calls in situation where the context of the call operator
- // is not entered, so we set AfterParameterList to false, so that
+ // When this function is called in situation where the context of the call
+ // operator is not entered, we set AfterParameterList to false, so that
// `tryCaptureVariable` finds explicit captures in the appropriate context.
- LSI->AfterParameterList = false;
+ //
+ // There is also at least a situation as in FinishTemplateArgumentDeduction(),
+ // where we would set the CurContext to the lambda operator before
+ // substituting into it. In this case the flag needs to be true such that
+ // tryCaptureVariable can correctly handle potential captures thereof.
+ LSI->AfterParameterList = CurContext == CallOperator;
+ // GLTemplateParameterList is necessary for getCurGenericLambda() which is
+ // used at the point of dealing with potential captures.
+ //
+ // We don't use LambdaClass->isGenericLambda() because this value doesn't
+ // flip for instantiated generic lambdas, where no FunctionTemplateDecls are
+ // associated. (Technically, we could recover that list from their
+ // instantiation patterns, but for now, the GLTemplateParameterList seems
+ // unnecessary in these cases.)
+ if (FunctionTemplateDecl *FTD = CallOperator->getDescribedFunctionTemplate())
+ LSI->GLTemplateParameterList = FTD->getTemplateParameters();
const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
if (LCD == LCD_None)
diff --git a/clang/test/SemaCXX/lambda-capture-type-deduction.cpp b/clang/test/SemaCXX/lambda-capture-type-deduction.cpp
index a86f3018989927..234cb6806f041a 100644
--- a/clang/test/SemaCXX/lambda-capture-type-deduction.cpp
+++ b/clang/test/SemaCXX/lambda-capture-type-deduction.cpp
@@ -298,6 +298,22 @@ void __trans_tmp_1() {
}
+namespace GH115931 {
+
+struct Range {};
+
+template <Range>
+struct LengthPercentage {};
+
+void reflectSum() {
+ Range resultR;
+ [&] (auto) -> LengthPercentage<resultR> {
+ return {};
+ }(0);
+}
+
+} // namespace GH115931
+
namespace GH47400 {
struct Foo {};
|
erichkeane
approved these changes
Dec 2, 2024
|
thanks for the review :) |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/59/builds/9095 Here is the relevant piece of the build log for the reference |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
The NTTP argument appearing inside a trailing return type of a generic lambda would have to check for potential lambda captures, where the function needs GLTemplateParameterList of the current LSI to tell whether the lambda is generic.
The lambda scope in this context is rebuilt by the LambdaScopeForCallOperatorInstantiationRAII when substituting the lambda operator during template argument deduction. Thus, I think the template parameter list should be preserved in the rebuilding process, as it seems otherwise innocuous to me.
Fixes #115931