Tested x86_64-pc-linux-gnu, applying to trunk.
-- 8< --
Here when we went to mangle the constraints of from<0>, the outer lambda has
no mangling scope, but the inner one was treated as having the outer one as
its scope. And mangling the outer one means mangling its constraints, which
include the inner one. So infinite recursion.
But a lambda closure type isn't a scope that anything should have for
mangling, the inner lambda should also have no mangling scope.
PR c++/119175
gcc/cp/ChangeLog:
* mangle.cc (decl_mangling_context): Look through lambda type.
gcc/testsuite/ChangeLog:
* g++.dg/cpp2a/concepts-lambda23.C: New test.
---
gcc/cp/mangle.cc | 6 ++++++
gcc/testsuite/g++.dg/cpp2a/concepts-lambda23.C | 12 ++++++++++++
2 files changed, 18 insertions(+)
create mode 100644 gcc/testsuite/g++.dg/cpp2a/concepts-lambda23.C
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index 02129c6b89a..3d5e96b2c94 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -1048,6 +1048,12 @@ decl_mangling_context (tree decl)
tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
if (extra)
return extra;
+ tcontext = CP_DECL_CONTEXT (decl);
+ if (LAMBDA_TYPE_P (tcontext))
+ /* Lambda type context means this lambda appears between the
+ lambda-introducer and the open brace of another lambda (c++/119175).
+ That isn't a real scope; look further into the enclosing scope. */
+ return decl_mangling_context (TYPE_NAME (tcontext));
}
else if (template_type_parameter_p (decl))
/* template type parms have no mangling context. */
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-lambda23.C
b/gcc/testsuite/g++.dg/cpp2a/concepts-lambda23.C
new file mode 100644
index 00000000000..f44212031dd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts-lambda23.C
@@ -0,0 +1,12 @@
+// PR c++/119175
+// { dg-do compile { target c++20 } }
+
+template<int = 0>
+static void from() requires requires {
+ []<int> requires requires { [] {}; } {};
+}
+{}
+
+int main() {
+ from();
+}
base-commit: 911973a784aab34e13c683545f28177d0d7716cd
--
2.49.0
