Implement mangling rules for C++20 concepts and requires-expressions.

[rsmith]

Summary

This implements proposals from:

• https://github.com/itanium-cxx-abi/cxx-abi/issues/24: mangling for constraints, requires-clauses, requires-expressions.
• https://github.com/itanium-cxx-abi/cxx-abi/issues/31: requires-clauses and template parameters in a lambda expression are mangled into the <lambda-sig>.
• https://github.com/itanium-cxx-abi/cxx-abi/issues/47 (STEP 3): mangling for template argument is prefixed by mangling of template parameter declaration if it's not "obvious", for example because the template parameter is constrained (we already implemented STEP 1 and STEP 2).

This changes the manglings for a few cases:

• Functions and function templates with constraints.
• Function templates with template parameters with deduced types: typename<auto N> void f();
• Function templates with template template parameters where the argument has a different template-head: template<template<typename...T>> void f(); f<std::vector>();

In each case where a mangling changed, the change fixes a mangling collision.

Note that only function templates are affected, not class templates or variable
templates, and only new constructs (template parameters with deduced types,
constrained templates) and esoteric constructs (templates with template
template parameters with non-matching template template arguments, most of
which Clang still does not accept by default due to
-frelaxed-template-template-args not being enabled by default), so the risk
to ABI stability from this change is relatively low. Nonetheless,
-fclang-abi-compat=17 can be used to restore the old manglings for cases
which we could successfully but incorrectly mangle before.

Fixes #48216, #49884, #61273

[rsmith]

Here's the diff to test_demangle.pass.cpp:

--- a/libcxxabi/test/test_demangle.pass.cpp
+++ b/libcxxabi/test/test_demangle.pass.cpp
@@ -29995,10 +29995,10 @@ const char* cases[][2] =
     {"_Z15test_uuidofTypeI10TestStructEvDTu8__uuidofT_EE", "void test_uuidofType<TestStruct>(decltype(__uuidof(TestStruct)))"},
     {"_Z15test_uuidofExprI9HasMemberEvDTu8__uuidofXsrT_6memberEEE", "void test_uuidofExpr<HasMember>(decltype(__uuidof(HasMember::member)))"},
 
-    // C++2a char8_t:
+    // C++20 char8_t:
     {"_ZTSPDu", "typeinfo name for char8_t*"},
 
-    // C++2a lambda-expressions:
+    // C++20 lambda-expressions:
     {"_ZNK1xMUlTyT_E_clIiEEDaS_", "auto x::'lambda'<typename $T>($T)::operator()<int>(x) const"},
     {"_ZNK1xMUlTnPA3_ivE_clILS0_0EEEDav", "auto x::'lambda'<int (*$N) [3]>()::operator()<(int [3])0>() const"},
     {"_ZNK1xMUlTyTtTyTnT_TpTnPA3_TL0__ETpTyvE_clIi1XJfEEEDav", "auto x::'lambda'<typename $T, template<typename $T0, $T $N, $T0 (*...$N0) [3]> typename $TT, typename ...$T1>()::operator()<int, X, float>() const"},
@@ -30015,8 +30015,10 @@ const char* cases[][2] =
     // See https://github.com/itanium-cxx-abi/cxx-abi/issues/106.
     {"_ZN1XIZ1fIiEvOT_EUlS2_DpT0_E_EclIJEEEvDpT_", "void X<void f<int>(int&&)::'lambda'(int&&, auto...)>::operator()<>()"},
     {"_ZZZZN6abcdef9abcdefghi29abcdefabcdefabcdefabcefabcdef27xxxxxxxxxxxxxxxxxxxxxxxxxxxEN4absl8DurationERKNSt3__u12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS1_19yyyyyyyyyyyyyyyyyyyEENK3$_5clEvENKUlvE_clEvE6zzzzzz", "abcdef::abcdefghi::abcdefabcdefabcdefabcefabcdef::xxxxxxxxxxxxxxxxxxxxxxxxxxx(absl::Duration, std::__u::basic_string<char, std::__u::char_traits<char>, std::__u::allocator<char>> const&, abcdef::abcdefghi::abcdefabcdefabcdefabcefabcdef::yyyyyyyyyyyyyyyyyyy*)::$_5::operator()() const::'lambda'()::operator()() const::zzzzzz"},
+    // See https://github.com/itanium-cxx-abi/cxx-abi/issues/165.
+    {"_ZN1C1fIiEEvDTtlNS_UlT_TL0__E_EEE", "void C::f<int>(decltype(C::'lambda'(int, auto){}))"},
 
-    // C++2a class type non-type template parameters:
+    // C++20 class type non-type template parameters:
     {"_Z1fIXtl1BLPi0ELi1EEEEvv", "void f<B{(int*)0, 1}>()"},
     {"_Z1fIXtl1BLPi32EEEEvv", "void f<B{(int*)32}>()"},
     {"_Z1fIXtl1BrcPiLi0EEEEvv", "void f<B{reinterpret_cast<int*>(0)}>()"},
@@ -30089,6 +30091,51 @@ const char* cases[][2] =
     {"_ZW1ML4Oink", "Oink@M"},
     {"_ZW1ML1fi", "f@M(int)"},
 
+    // C++20 concepts, see https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+    {"_Z2f0IiE1SIX1CIT_EEEv", "S<C<int>> f0<int>()"},
+    {"_ZN5test21AIiEF1fEzQ4TrueIT_E", "test2::A<int>::friend f(...) requires True<T>"},
+    {"_ZN5test2F1gIvEEvzQaa4TrueIT_E4TrueITL0__E", "void test2::friend g<void>(...) requires True<T> && True<TL0_>"},
+    {"_ZN5test21hIvEEvzQ4TrueITL0__E", "void test2::h<void>(...) requires True<TL0_>"},
+    {"_ZN5test2F1iIvQaa4TrueIT_E4TrueITL0__EEEvz", "void test2::friend i<void>(...)"},
+    {"_ZN5test21jIvQ4TrueITL0__EEEvz", "void test2::j<void>(...)"},
+    {"_ZN5test2F1kITk4TruevQ4TrueIT_EEEvz", "void test2::friend k<void>(...)"},
+    {"_ZN5test21lITk4TruevEEvz", "void test2::l<void>(...)"},
+    {"_ZN5test31dITnDaLi0EEEvv", "void test3::d<0>()"},
+    {"_ZN5test31eITnDcLi0EEEvv", "void test3::e<0>()"},
+    {"_ZN5test31fITnDk1CLi0EEEvv", "void test3::f<0>()"},
+    {"_ZN5test31gITnDk1DIiELi0EEEvv", "void test3::g<0>()"},
+    {"_ZN5test31hIiTnDk1DIT_ELi0EEEvv", "void test3::h<int, 0>()"},
+    {"_ZN5test31iIiEEvDTnw_Dk1CpicvT__EEE", "void test3::i<int>(decltype(new C auto((int)())))"},
+    {"_ZN5test31jIiEEvDTnw_DK1CpicvT__EEE", "void test3::j<int>(decltype(new C decltype(auto)((int)())))"},
+    {"_ZN5test41fITk1CiEEvv", "void test4::f<int>()"},
+    {"_ZN5test41gITk1DIiEiEEvv", "void test4::g<int>()"},
+    {"_ZN5test51fINS_1XEEEvv", "void test5::f<test5::X>()"},
+    {"_ZN5test51fITtTyTnTL0__ENS_1YEEEvv", "void test5::f<test5::Y>()"},
+    {"_ZN5test51fITtTyTnTL0__ENS_1ZEEEvv", "void test5::f<test5::Z>()"},
+    {"_ZN5test51gITtTyTnTL0__Q1CIS1_EENS_1XEEEvv", "void test5::g<test5::X>()"},
+    {"_ZN5test51gINS_1YEEEvv", "void test5::g<test5::Y>()"},
+    {"_ZN5test51gITtTyTnTL0__Q1CIS1_EENS_1ZEEEvv", "void test5::g<test5::Z>()"},
+    {"_ZN5test51hITtTk1CTnTL0__ENS_1XEEEvv", "void test5::h<test5::X>()"},
+    {"_ZN5test51hITtTk1CTnTL0__ENS_1YEEEvv", "void test5::h<test5::Y>()"},
+    {"_ZN5test51hINS_1ZEEEvv", "void test5::h<test5::Z>()"},
+    {"_ZN5test51iITpTtTk1CTnTL0__EJNS_1XENS_1YENS_1ZEEEEvv", "void test5::i<test5::X, test5::Y, test5::Z>()"},
+    {"_ZN5test51iITpTtTk1CTnTL0__EJNS_1YENS_1ZENS_1XEEEEvv", "void test5::i<test5::Y, test5::Z, test5::X>()"},
+    {"_ZN5test51iIJNS_1ZENS_1XENS_1YEEEEvv", "void test5::i<test5::Z, test5::X, test5::Y>()"},
+    {"_ZN5test51pINS_1AEEEvv", "void test5::p<test5::A>()"},
+    {"_ZN5test51pITtTpTyENS_1BEEEvv", "void test5::p<test5::B>()"},
+    {"_ZN5test51qITtTyTyENS_1AEEEvv", "void test5::q<test5::A>()"},
+    {"_ZN5test51qINS_1BEEEvv", "void test5::q<test5::B>()"},
+    {"_ZN5test61fITk1CiEEvT_", "void test6::f<int>(int)"},
+    {"_ZN5test61gIiTk1DIT_EiEEvT0_", "void test6::g<int, int>(int)"},
+    {"_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E_clIiiEEDaS3_Q1CIDtfp_EE", "auto void test7::f<int>()::'lambda'<typename $T> requires C<T> && C<TL0_> (auto)::operator()<int, int>(auto) const requires C<decltype(fp)>"},
+    {"_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E0_clIiiEEDaS3_Qaa1CIDtfp_EELb1E", "auto void test7::f<int>()::'lambda0'<typename $T> requires C<T> && C<TL0_> (auto)::operator()<int, int>(auto) const requires C<decltype(fp)> && true"},
+    {"_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E1_clIiiEEDaS3_Q1CIDtfp_EE", "auto void test7::f<int>()::'lambda1'<typename $T> requires C<T> && C<TL0_> (auto)::operator()<int, int>(auto) const requires C<decltype(fp)>"},
+    {"_ZZN5test71fIiEEvvENKUlTyT0_E_clIiiEEDaS1_", "auto void test7::f<int>()::'lambda'<typename $T>(auto)::operator()<int, int>(auto) const"},
+
+    // C++20 requires expressions, see https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+    {"_Z1fIiEviQrqXcvT__EXfp_Xeqfp_cvS0__EXplcvS0__ELi1ER5SmallXmicvS0__ELi1ENXmlcvS0__ELi2ENR11SmallerThanILi1234EETS0_T1XIS0_ETNS3_4typeETS2_IiEQ11SmallerThanIS0_Li256EEE", "void f<int>(int) requires requires { (T)(); fp; fp == (T)(); {(T)() + 1} -> Small; {(T)() - 1} noexcept; {(T)() * 2} noexcept -> SmallerThan<1234>; typename T; typename X<T>; typename X<T>::type; typename X<int>; requires SmallerThan<T, 256>; }"},
+    {"_Z1gIiEviQrQT__XplfL0p_fp_E", "void g<int>(int) requires requires (T) { fp + fp; }"},
+
     // Special Substs a, b, d, i, o, s (not including std::)
     {"_Z1fSaIiE", "f(std::allocator<int>)"},
     {"_Z1fSbIiE", "f(std::basic_string<int>)"},

Unfortunately, Arcanist both insists on uploading "full context" (that is, the entire 5.2MB file, almost all of which is unchanged), and refuses to upload "very large" diffs, so it's not able to upload this small change to Phabricator for review.

[erichkeane]

I can't really review the libcxxabi parts, or the llvm-demangler parts, but everything looks right to me. I've got a pair of quick questions, otherwise I think this is going to be fine for me.

Note the extra paren changes are something I think are valuable, but I'm trying to figure out their meaning in thsi patch.

clang/include/clang/AST/ExprConcepts.h

529

Is this an unrelated change? Are paren locations required for mangling?

clang/lib/AST/ItaniumMangle.cpp

5271

What is happening here? What are we deriving from the validity of the paren? Or is this differentiating:

requires (something) vs requires C<T> sorta thing?

[rsmith]

clang/include/clang/AST/ExprConcepts.h

529

requires (params) { blah; } has a different mangling from requires { blah; } -- in particular, the former introduces a new level of function parameters, so references to enclosing function parameters are numbered differently in the two. This applies even if params is empty or void (requires () { ... } and requires (void) { ... } are both valid).

We previously generated the same AST for requires { ... } and requires () { ... }, which meant we couldn't mangle this correctly. Tracking the parens (or at least their existence) fixes that (and also improves the AST fidelity for tooling).

clang/lib/AST/ItaniumMangle.cpp

5271

Yes, the rq form is for requires expressions without a parameter list, and the rQ form is for requires expressions with a parameter list.

[erichkeane]

clang/include/clang/AST/ExprConcepts.h

529

Tracking the parens (or at least their existence) fixes tha

it seems you test that via the LParenLoc, which is why I'm surprised about the addition of the RParenLoc? I have no problem with the addition of the RParenLoc for the below reason, but was trying to figure out the significance toward the mangling.

and also improves the AST fidelity for tooling

This I definitely get, was just trying to figure out why it was in a patch for mangling.

[royjacobson]

I agree it doesn't affect too much code, but people do instantiate templates manually sometimes. IIUC, linking against shared libraries would break if that library does explicit instantiations of constrained functions. That concerns me a bit.

Also, do you know if GCC developers are planning on implementing this change as well?

[rsmith]

In D147655#4248800, @royjacobson wrote:

I agree it doesn't affect too much code, but people do instantiate templates manually sometimes. IIUC, linking against shared libraries would break if that library does explicit instantiations of constrained functions. That concerns me a bit.

There has not been any stable ABI from any compiler targeting the Itanium C++ ABI for constrained templates prior to this change. I don't think we need to worry too much about people using unfinished compiler features being broken when those features are finished.

From an ABI perspective, I think the other cases that I called out are more interesting than the constrained templates side of things: this changes the mangling for non-type template parameters with deduced types, non-type template parameters with instantiation-dependent types, and template template parameters that don't match their template template arguments, in the template parameter list of a function template. The latter two of those changes can in principle affect code dating back to C++98. There might be a case for putting those changes in particular behind a flag. @rjmccall I would particularly appreciate your feedback on that concern.

Also, do you know if GCC developers are planning on implementing this change as well?

I have no reason to think they would not follow the cross-vendor ABI specification, though I'll ping them explicitly. The ABI proposals haven't been accepted yet; I'm not intending to land this change until the proposals have reached consensus in the Itanium C++ ABI group.

clang/include/clang/AST/ExprConcepts.h

529

Yeah, we don't really need to track the RParenLoc, or the LParenLoc for that matter, as part of this mangling change, we just need any way to get the "were there parens?" information.

[royjacobson]

In D147655#4250056, @rsmith wrote:

There has not been any stable ABI from any compiler targeting the Itanium C++ ABI for constrained templates prior to this change. I don't think we need to worry too much about people using unfinished compiler features being broken when those features are finished.

The ABI has been stable for quite some time and people have been using concepts with it for almost 3 years now. I'm not sure we can still break ABI this easily. But then, I also have no data to say we can't.

The ABI proposals haven't been accepted yet; I'm not intending to land this change until the proposals have reached consensus in the Itanium C++ ABI group.

Thanks for clarifying!

[aaron.ballman]

In D147655#4250922, @royjacobson wrote:

In D147655#4250056, @rsmith wrote:

There has not been any stable ABI from any compiler targeting the Itanium C++ ABI for constrained templates prior to this change. I don't think we need to worry too much about people using unfinished compiler features being broken when those features are finished.

The ABI has been stable for quite some time and people have been using concepts with it for almost 3 years now. I'm not sure we can still break ABI this easily. But then, I also have no data to say we can't.

We've never claimed full support for concepts, so those folks would be relying on an unstable ABI. However, if it turns out this causes significant pain in practice, perhaps we could use ABI tags to give folks the older ABI? I'd prefer to avoid that in this case given that the feature isn't yet fully supported (I don't like the idea of setting a precedent for relying on the ABI of incomplete features in general), but concepts is a sufficiently important use case that I could imagine doing it as a one-off if needed.

The ABI proposals haven't been accepted yet; I'm not intending to land this change until the proposals have reached consensus in the Itanium C++ ABI group.

Thanks for clarifying!

[rsmith]

In D147655#4251042, @aaron.ballman wrote:

In D147655#4250922, @royjacobson wrote:

In D147655#4250056, @rsmith wrote:

There has not been any stable ABI from any compiler targeting the Itanium C++ ABI for constrained templates prior to this change. I don't think we need to worry too much about people using unfinished compiler features being broken when those features are finished.

The ABI has been stable for quite some time and people have been using concepts with it for almost 3 years now. I'm not sure we can still break ABI this easily. But then, I also have no data to say we can't.

We've never claimed full support for concepts, so those folks would be relying on an unstable ABI. However, if it turns out this causes significant pain in practice, perhaps we could use ABI tags to give folks the older ABI? I'd prefer to avoid that in this case given that the feature isn't yet fully supported (I don't like the idea of setting a precedent for relying on the ABI of incomplete features in general), but concepts is a sufficiently important use case that I could imagine doing it as a one-off if needed.

This patch already extends -fclang-abi-compat to retain the old manglings so that users can stay on an old (broken) ABI if they need to. I don't think we need to do more than that for the concepts mangling changes.

The ABI proposals haven't been accepted yet; I'm not intending to land this change until the proposals have reached consensus in the Itanium C++ ABI group.

The corresponding (confirmed) GCC bug report that they don't implement these mangling rules yet is: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100825

This patch supersedes https://reviews.llvm.org/D126818 (apologies for the duplicated work, @erichkeane -- I didn't find that before I started working on this).

[rsmith]

• Add release notes.

[erichkeane]

In D147655#4251984, @rsmith wrote:

In D147655#4251042, @aaron.ballman wrote:

In D147655#4250922, @royjacobson wrote:

In D147655#4250056, @rsmith wrote:

There has not been any stable ABI from any compiler targeting the Itanium C++ ABI for constrained templates prior to this change. I don't think we need to worry too much about people using unfinished compiler features being broken when those features are finished.

The ABI has been stable for quite some time and people have been using concepts with it for almost 3 years now. I'm not sure we can still break ABI this easily. But then, I also have no data to say we can't.

We've never claimed full support for concepts, so those folks would be relying on an unstable ABI. However, if it turns out this causes significant pain in practice, perhaps we could use ABI tags to give folks the older ABI? I'd prefer to avoid that in this case given that the feature isn't yet fully supported (I don't like the idea of setting a precedent for relying on the ABI of incomplete features in general), but concepts is a sufficiently important use case that I could imagine doing it as a one-off if needed.

This patch already extends -fclang-abi-compat to retain the old manglings so that users can stay on an old (broken) ABI if they need to. I don't think we need to do more than that for the concepts mangling changes.

The ABI proposals haven't been accepted yet; I'm not intending to land this change until the proposals have reached consensus in the Itanium C++ ABI group.

The corresponding (confirmed) GCC bug report that they don't implement these mangling rules yet is: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100825

This patch supersedes https://reviews.llvm.org/D126818 (apologies for the duplicated work, @erichkeane -- I didn't find that before I started working on this).

No problem! This is a much more complete solution, and mine was held up on waiting for the Itanium ABI group to come to a consensus anyway (and fell by the wayside).

[rsmith]

Ping. Are there any further concerns here? (This obviously needs to be merged with trunk, and the -fclang-abi-compat= checks and release notes need to be updated to match the latest release version.)

[rsmith]

• Merge

[dyung]

Hi @rsmith, we have an internal test where your change seems to have changed the mangling in C++17 mode and wanted to check if that was intentional.

Consider the following code:

// Literals in templates
#include <cstddef>
template <typename T, T I> T returnit() {return I;};
enum colour { RED = -3, GREEN, BLUE};
// use long type for enumeration
enum bigcolour { YELLOW = (1l << 32), CYAN, MAGENTA};
void callreturnit() {
    auto a = returnit<int, 4>();
    auto b = returnit<unsigned int, 4>();
    auto c = returnit<long, 4>();
    auto d = returnit<unsigned long, 4>();
    auto e = returnit<long long, -456789>();
    auto f = returnit<bool, true>();
    auto g = returnit<bool, false>();
    auto n = returnit<std::nullptr_t, nullptr>();
    auto cg = returnit<colour, GREEN>();
    auto cy = returnit<bigcolour, YELLOW>();
}

The compiler in C++17 mode now seems to differently mangle each instance:

function	before	after
returnit<int, 4>();	_Z8returnitIiLi4EET_v	_Z8returnitIiTnT_Li4EES0_v
returnit<unsigned int, 4>();	_Z8returnitIjLj4EET_v	_Z8returnitIjTnT_Lj4EES0_v
returnit<long, 4>();	_Z8returnitIlLl4EET_v	_Z8returnitIlTnT_Ll4EES0_v
returnit<unsigned long, 4>();	_Z8returnitImLm4EET_v	_Z8returnitImTnT_Lm4EES0_v
returnit<long long, -456789>();	_Z8returnitIxLxn456789EET_v	_Z8returnitIxTnT_Lxn456789EES0_v
returnit<bool, true>();	_Z8returnitIbLb1EET_v	_Z8returnitIbTnT_Lb1EES0_v
returnit<bool, false>();	_Z8returnitIbLb0EET_v	_Z8returnitIbTnT_Lb0EES0_v
returnit<std::nullptr_t, nullptr>();	_Z8returnitIDnLDn0EET_v	_Z8returnitIDnTnT_LDn0EES0_v
returnit<colour, GREEN>();	_Z8returnitI6colourLS0_n2EET_v	_Z8returnitI6colourTnT_LS0_n2EES1_v
returnit<bigcolour, YELLOW>();	_Z8returnitI9bigcolourLS0_4294967296EET_v	_Z8returnitI9bigcolourTnT_LS0_4294967296EES1_v

Are these changes in non-C++20 mode intentional?

[rsmith]

In D147655#4649864, @dyung wrote:

Hi @rsmith, we have an internal test where your change seems to have changed the mangling in C++17 mode and wanted to check if that was intentional.

[...]

Are these changes in non-C++20 mode intentional?

Yes, they're intentional. Unfortunately we could have mangling collisions here when using the old ABI rule; these two different templates would have the same mangling:

template <typename T, T I> T returnit() {return I;};
template <typename T, int I> T returnit() { return I; }

But... it looks like this case is missing from the list of affected cases in the change description and the release notes. Sorry about that. Release notes updated in rGaaa79a59317f859485d701d1eb68ac4cb213e1d1.

[rjmccall]

Hey, Richard. It looks like your new tests are failing on Apple's buildbots, I'm guessing because the default ABI compatibility mode is older.

[rjmccall]

I've been informed that Apple's change to the default ABI compatibility mode is in our private fork, so this is not your problem; sorry for the noise.

I'm not sure why we decided to do that privately; I'll see if we can fix that.

[dyung]

In D147655#4650663, @rjmccall wrote:

I've been informed that Apple's change to the default ABI compatibility mode is in our private fork, so this is not your problem; sorry for the noise.

I'm not sure why we decided to do that privately; I'll see if we can fix that.

We (Sony) also use an older ABI and I am working on a patch to be committed upstream to fix this for our target.

[rjmccall]

Yeah, the more I think about this, the more I think that while (1) Apple should upstream its use of an older default, regardless (2) the existence of any targets at all with an older default means that tests like this always need to be using -fclang-abi-compat=latest.

[rsmith]

In D147655#4650666, @rjmccall wrote:

Yeah, the more I think about this, the more I think that while (1) Apple should upstream its use of an older default, regardless (2) the existence of any targets at all with an older default means that tests like this always need to be using -fclang-abi-compat=latest.

Seems reasonable. I went ahead and made that change in rG940850066290a484144db80f09e6c19709f5fe49.

I think we could probably limit this to just the test using %itanium_abi_triple, but there's also an affected test specifying -triple=x86_64-apple-darwin9, so that might not be enough for your needs. Also, I suppose some vendors might want to carry a patch that changes the default globally rather than on a per-target basis. So I just changed all the tests that touch the new mangling.

[probinson]

Hi @rsmith,

these two different templates would have the same mangling:

template <typename T, T I> T returnit() {return I;};
template <typename T, int I> T returnit() { return I; }

I tried compiling long foo() { return returnit<long, 4>(); } with these two templates, and got different manglings.
_Z8returnitIlLl4EET_v and
_Z8returnitIlLi4EET_v

Am I misunderstanding something about the problem with the old mangling rules?

[rjmccall]

In D147655#4650964, @probinson wrote:

Hi @rsmith,

these two different templates would have the same mangling:

template <typename T, T I> T returnit() {return I;};
template <typename T, int I> T returnit() { return I; }

I tried compiling long foo() { return returnit<long, 4>(); } with these two templates, and got different manglings.
_Z8returnitIlLl4EET_v and
_Z8returnitIlLi4EET_v

Am I misunderstanding something about the problem with the old mangling rules?

You need to do returnit<int, 4>.

[probinson]

You need to do returnit<int, 4>.

Doh! Thanks. Those two instantiations could have different function bodies, but would have the same mangled name. Got it.

clang/docs/ReleaseNotes.rst

 C/C++ Language Potentially Breaking Changes
 -------------------------------------------
 
 - The default extension name for PCH generation (``-c -xc-header`` and ``-c
   -xc++-header``) is now ``.pch`` instead of ``.gch``.
 
 C++ Specific Potentially Breaking Changes
 -----------------------------------------
+- The name mangling rules for function templates has been changed to take into
+  account the possibility that functions could be overloaded on their template
+  parameter lists or requires-clauses. This causes mangled names to change for
+  function templates in the following cases:
+    - When the function has any constraints, whether from constrained template
+      parameters or requires-clauses.
+    - When the template parameter list includes a deduced type -- either
+      ``auto``, ``decltype(auto)``, or a deduced class template specialization
+      type.
+    - When a template template parameter is given a template template argument
+      that has a different template parameter list.
+  This fixes a number of issues where valid programs would be rejected due to
+  mangling collisions, or would in some cases be silently miscompiled. Clang
+  will use the old manglings if ``-fclang-abi-compat=17`` or lower is
+  specified.
+  (`#48216 <https://github.com/llvm/llvm-project/issues/48216>`_),
+  (`#49884 <https://github.com/llvm/llvm-project/issues/49884>`_), and
+  (`#61273 <https://github.com/llvm/llvm-project/issues/61273>`_)
 
 ABI Changes in This Version
 ---------------------------
 - Following the SystemV ABI for x86-64, ``__int128`` arguments will no longer
   be split between a register and a stack slot.
 
 What's New in Clang |release|?
 ==============================

clang/include/clang/AST/ExprConcepts.h

class RequiresExpr final : public Expr,
     llvm::TrailingObjects<RequiresExpr, ParmVarDecl *,
                           concepts::Requirement *> {
   friend TrailingObjects;
   friend class ASTStmtReader;
 
   unsigned NumLocalParameters;
   unsigned NumRequirements;
   RequiresExprBodyDecl *Body;
+  SourceLocation LParenLoc;
+  SourceLocation RParenLoc;
   SourceLocation RBraceLoc;
 
   unsigned numTrailingObjects(OverloadToken<ParmVarDecl *>) const {
     return NumLocalParameters;
   }
 
   unsigned numTrailingObjects(OverloadToken<concepts::Requirement *>) const {
     return NumRequirements;
   }
 
   RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
-               RequiresExprBodyDecl *Body,
+               RequiresExprBodyDecl *Body, SourceLocation LParenLoc,
                ArrayRef<ParmVarDecl *> LocalParameters,
+               SourceLocation RParenLoc,
                ArrayRef<concepts::Requirement *> Requirements,
                SourceLocation RBraceLoc);
   RequiresExpr(ASTContext &C, EmptyShell Empty, unsigned NumLocalParameters,
                unsigned NumRequirements);
 
 public:
-  static RequiresExpr *
-  Create(ASTContext &C, SourceLocation RequiresKWLoc,
-         RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> LocalParameters,
+  static RequiresExpr *Create(ASTContext &C, SourceLocation RequiresKWLoc,
+                              RequiresExprBodyDecl *Body,
+                              SourceLocation LParenLoc,
+                              ArrayRef<ParmVarDecl *> LocalParameters,
+                              SourceLocation RParenLoc,
                               ArrayRef<concepts::Requirement *> Requirements,
                               SourceLocation RBraceLoc);
   static RequiresExpr *
   Create(ASTContext &C, EmptyShell Empty, unsigned NumLocalParameters,
          unsigned NumRequirements);
 
   ArrayRef<ParmVarDecl *> getLocalParameters() const {
     return {getTrailingObjects<ParmVarDecl *>(), NumLocalParameters};
   }
 
assert(!isValueDependent() &&
            "setSatisfied called on a dependent RequiresExpr");
     RequiresExprBits.IsSatisfied = IsSatisfied;
   }
 
   SourceLocation getRequiresKWLoc() const {
     return RequiresExprBits.RequiresKWLoc;
   }
 
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+  SourceLocation getRParenLoc() const { return RParenLoc; }
   SourceLocation getRBraceLoc() const { return RBraceLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == RequiresExprClass;
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return RequiresExprBits.RequiresKWLoc;

clang/include/clang/Basic/LangOptions.h

enum class ClangABI {
 
     /// Attempt to be ABI-compatible with code generated by Clang 15.0.x.
     /// This causes clang to:
     ///   - Reverse the implementation for DR692, DR1395 and DR1432.
     ///   - pack non-POD members of packed structs.
     ///   - consider classes with defaulted special member functions non-pod.
     Ver15,
 
+    /// Attempt to be ABI-compatible with code generated by Clang 17.0.x.
+    /// This causes clang to revert some fixes to its implementation of the
+    /// Itanium name mangling scheme, with the consequence that overloaded
+    /// function templates are mangled the same if they differ only by:
+    ///   - constraints
+    ///   - whether a non-type template parameter has a deduced type
+    ///   - the parameter list of a template template parameter
+    Ver17,
+
     /// Conform to the underlying platform's C and C++ ABIs as closely
     /// as we can.
     Latest
   };
 
   enum class CoreFoundationABI {
     /// No interoperability ABI has been specified
     Unspecified,

clang/include/clang/Sema/Sema.h

   BuildTypeRequirement(
       concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
   concepts::NestedRequirement *BuildNestedRequirement(Expr *E);
   concepts::NestedRequirement *
   BuildNestedRequirement(StringRef InvalidConstraintEntity,
                          const ASTConstraintSatisfaction &Satisfaction);
   ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,
                                RequiresExprBodyDecl *Body,
+                               SourceLocation LParenLoc,
                                ArrayRef<ParmVarDecl *> LocalParameters,
+                               SourceLocation RParenLoc,
                                ArrayRef<concepts::Requirement *> Requirements,
                                SourceLocation ClosingBraceLoc);
 
   //===--------------------------------------------------------------------===//
   // C++ Variadic Templates (C++0x [temp.variadic])
   //===--------------------------------------------------------------------===//
 
   /// Determine whether an unexpanded parameter pack might be permitted in this

clang/lib/AST/ExprConcepts.cpp

static bool RequirementContainsError(concepts::Requirement *R) {
   if (auto *NestedReq = dyn_cast<concepts::NestedRequirement>(R))
     return !NestedReq->hasInvalidConstraint() &&
            NestedReq->getConstraintExpr() &&
            NestedReq->getConstraintExpr()->containsErrors();
   return false;
 }
 
 RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
-                           RequiresExprBodyDecl *Body,
+                           RequiresExprBodyDecl *Body, SourceLocation LParenLoc,
                            ArrayRef<ParmVarDecl *> LocalParameters,
+                           SourceLocation RParenLoc,
                            ArrayRef<concepts::Requirement *> Requirements,
                            SourceLocation RBraceLoc)
     : Expr(RequiresExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
       NumLocalParameters(LocalParameters.size()),
-      NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) {
+      NumRequirements(Requirements.size()), Body(Body), LParenLoc(LParenLoc),
+      RParenLoc(RParenLoc), RBraceLoc(RBraceLoc) {
   RequiresExprBits.IsSatisfied = false;
   RequiresExprBits.RequiresKWLoc = RequiresKWLoc;
   bool Dependent = false;
   bool ContainsUnexpandedParameterPack = false;
   for (ParmVarDecl *P : LocalParameters) {
     Dependent |= P->getType()->isInstantiationDependentType();
     ContainsUnexpandedParameterPack |=
         P->getType()->containsUnexpandedParameterPack();

 }
 
 RequiresExpr::RequiresExpr(ASTContext &C, EmptyShell Empty,
                            unsigned NumLocalParameters,
                            unsigned NumRequirements)
   : Expr(RequiresExprClass, Empty), NumLocalParameters(NumLocalParameters),
     NumRequirements(NumRequirements) { }
 
-RequiresExpr *
-RequiresExpr::Create(ASTContext &C, SourceLocation RequiresKWLoc,
-                     RequiresExprBodyDecl *Body,
-                     ArrayRef<ParmVarDecl *> LocalParameters,
-                     ArrayRef<concepts::Requirement *> Requirements,
-                     SourceLocation RBraceLoc) {
+RequiresExpr *RequiresExpr::Create(
+    ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body,
+    SourceLocation LParenLoc, ArrayRef<ParmVarDecl *> LocalParameters,
+    SourceLocation RParenLoc, ArrayRef<concepts::Requirement *> Requirements,
   void *Mem =
       C.Allocate(totalSizeToAlloc<ParmVarDecl *, concepts::Requirement *>(
                      LocalParameters.size(), Requirements.size()),
                  alignof(RequiresExpr));
-  return new (Mem) RequiresExpr(C, RequiresKWLoc, Body, LocalParameters,
-                                Requirements, RBraceLoc);
+  return new (Mem)
+      RequiresExpr(C, RequiresKWLoc, Body, LParenLoc, LocalParameters,
+                   RParenLoc, Requirements, RBraceLoc);
 }
 
 RequiresExpr *
 RequiresExpr::Create(ASTContext &C, EmptyShell Empty,
                      unsigned NumLocalParameters, unsigned NumRequirements) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<ParmVarDecl *, concepts::Requirement *>(
                      NumLocalParameters, NumRequirements),
                  alignof(RequiresExpr));
   return new (Mem) RequiresExpr(C, Empty, NumLocalParameters, NumRequirements);
 }

clang/lib/AST/ItaniumMangle.cpp

class CXXNameMangler {
   bool DisableDerivedAbiTags = false;
 
   /// The "structor" is the top-level declaration being mangled, if
   /// that's not a template specialization; otherwise it's the pattern
   /// for that specialization.
   const NamedDecl *Structor;
   unsigned StructorType = 0;
 
+  // An offset to add to all template parameter depths while mangling. Used
+  // when mangling a template parameter list to see if it matches a template
+  // template parameter exactly.
+  unsigned TemplateDepthOffset = 0;
+
   /// The next substitution sequence number.
   unsigned SeqID = 0;
 
   class FunctionTypeDepthState {
     unsigned Bits = 0;
 
     enum { InResultTypeMask = 1 };
 
class CXXNameMangler {
   AbiTagState *AbiTags = nullptr;
   AbiTagState AbiTagsRoot;
 
   llvm::DenseMap<uintptr_t, unsigned> Substitutions;
   llvm::DenseMap<StringRef, unsigned> ModuleSubstitutions;
 
   ASTContext &getASTContext() const { return Context.getASTContext(); }
 
+  bool isCompatibleWith(LangOptions::ClangABI Ver) {
+    return Context.getASTContext().getLangOpts().getClangABICompat() <= Ver;
+  }
+
   bool isStd(const NamespaceDecl *NS);
   bool isStdNamespace(const DeclContext *DC);
 
   const RecordDecl *GetLocalClassDecl(const Decl *D);
   bool isSpecializedAs(QualType S, llvm::StringRef Name, QualType A);
   bool isStdCharSpecialization(const ClassTemplateSpecializationDecl *SD,
                                llvm::StringRef Name, bool HasAllocator);
 
CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_)
         Substitutions(Outer.Substitutions),
         ModuleSubstitutions(Outer.ModuleSubstitutions) {}
 
   CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_)
       : CXXNameMangler(Outer, (raw_ostream &)Out_) {
     NullOut = true;
   }
 
+  struct WithTemplateDepthOffset { unsigned Offset; };
+  CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out,
+                 WithTemplateDepthOffset Offset)
+      : CXXNameMangler(C, Out) {
+    TemplateDepthOffset = Offset.Offset;
+  }
+
   raw_ostream &getStream() { return Out; }
 
   void disableDerivedAbiTags() { DisableDerivedAbiTags = true; }
   static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C, const VarDecl *VD);
 
   void mangle(GlobalDecl GD);
   void mangleCallOffset(int64_t NonVirtual, int64_t Virtual);
   void mangleNumber(const llvm::APSInt &I);
private:
   void mangleDeviceStubName(const IdentifierInfo *II);
   void mangleSourceNameWithAbiTags(
       const NamedDecl *ND, const AbiTagList *AdditionalAbiTags = nullptr);
   void mangleLocalName(GlobalDecl GD,
                        const AbiTagList *AdditionalAbiTags);
   void mangleBlockForPrefix(const BlockDecl *Block);
   void mangleUnqualifiedBlock(const BlockDecl *Block);
   void mangleTemplateParamDecl(const NamedDecl *Decl);
+  void mangleTemplateParameterList(const TemplateParameterList *Params);
+  void mangleTypeConstraint(const ConceptDecl *Concept,
+                            ArrayRef<TemplateArgument> Arguments);
+  void mangleTypeConstraint(const TypeConstraint *Constraint);
+  void mangleRequiresClause(const Expr *RequiresClause);
   void mangleLambda(const CXXRecordDecl *Lambda);
   void mangleNestedName(GlobalDecl GD, const DeclContext *DC,
                         const AbiTagList *AdditionalAbiTags,
                         bool NoFunction=false);
   void mangleNestedName(const TemplateDecl *TD,
                         ArrayRef<TemplateArgument> Args);
   void mangleNestedNameWithClosurePrefix(GlobalDecl GD,
                                          const NamedDecl *PrefixND,
void mangleMemberExpr(const Expr *base, bool isArrow,
                         NestedNameSpecifier *qualifier,
                         NamedDecl *firstQualifierLookup,
                         DeclarationName name,
                         const TemplateArgumentLoc *TemplateArgs,
                         unsigned NumTemplateArgs,
                         unsigned knownArity);
   void mangleCastExpression(const Expr *E, StringRef CastEncoding);
   void mangleInitListElements(const InitListExpr *InitList);
+  void mangleRequirement(SourceLocation RequiresExprLoc,
+                         const concepts::Requirement *Req);
   void mangleExpression(const Expr *E, unsigned Arity = UnknownArity,
                         bool AsTemplateArg = false);
   void mangleCXXCtorType(CXXCtorType T, const CXXRecordDecl *InheritedFrom);
   void mangleCXXDtorType(CXXDtorType T);
 
+  struct TemplateArgManglingInfo;
   void mangleTemplateArgs(TemplateName TN,
                           const TemplateArgumentLoc *TemplateArgs,
                           unsigned NumTemplateArgs);
   void mangleTemplateArgs(TemplateName TN, ArrayRef<TemplateArgument> Args);
   void mangleTemplateArgs(TemplateName TN, const TemplateArgumentList &AL);
+  void mangleTemplateArg(TemplateArgManglingInfo &Info, unsigned Index,
+                         TemplateArgument A);
   void mangleTemplateArg(TemplateArgument A, bool NeedExactType);
   void mangleTemplateArgExpr(const Expr *E);
   void mangleValueInTemplateArg(QualType T, const APValue &V, bool TopLevel,
                                 bool NeedExactType = false);
 
   void mangleTemplateParameter(unsigned Depth, unsigned Index);
 
   void mangleFunctionParam(const ParmVarDecl *parm);
if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
       isa<OMPDeclareMapperDecl>(DC)) {
     return getEffectiveDeclContext(cast<Decl>(DC));
   }
 
   if (const auto *VD = dyn_cast<VarDecl>(D))
     if (VD->isExternC())
       return getASTContext().getTranslationUnitDecl();
 
-  if (const auto *FD = dyn_cast<FunctionDecl>(D))
+  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isExternC())
       return getASTContext().getTranslationUnitDecl();
+    // Member-like constrained friends are mangled as if they were members of
+    // the enclosing class.
+    if (FD->isMemberLikeConstrainedFriend() &&
+        getASTContext().getLangOpts().getClangABICompat() >
+            LangOptions::ClangABI::Ver17)
+      return D->getLexicalDeclContext()->getRedeclContext();
+  }
 
   return DC->getRedeclContext();
 }
 
 bool ItaniumMangleContextImpl::isInternalLinkageDecl(const NamedDecl *ND) {
   if (ND && ND->getFormalLinkage() == InternalLinkage &&
       !ND->isExternallyVisible() &&
       getEffectiveDeclContext(ND)->isFileContext() &&
if (FD->hasAttr<EnableIfAttr>()) {
     FunctionTypeDepthState Saved = FunctionTypeDepth.push();
     Out << "Ua9enable_ifI";
     for (AttrVec::const_iterator I = FD->getAttrs().begin(),
                                  E = FD->getAttrs().end();
          I != E; ++I) {
       EnableIfAttr *EIA = dyn_cast<EnableIfAttr>(*I);
       if (!EIA)
         continue;
-      if (Context.getASTContext().getLangOpts().getClangABICompat() >
-          LangOptions::ClangABI::Ver11) {
-        mangleTemplateArgExpr(EIA->getCond());
-      } else {
+      if (isCompatibleWith(LangOptions::ClangABI::Ver11)) {
         // Prior to Clang 12, we hardcoded the X/E around enable-if's argument,
         // even though <template-arg> should not include an X/E around
         // <expr-primary>.
         Out << 'X';
         mangleExpression(EIA->getCond());
         Out << 'E';
+      } else {
+        mangleTemplateArgExpr(EIA->getCond());
       }
     }
     Out << 'E';
     FunctionTypeDepth.pop(Saved);
   }
 
   // When mangling an inheriting constructor, the bare function type used is
   // that of the inherited constructor.
void CXXNameMangler::mangleUnresolvedName(
   if (TemplateArgs)
     mangleTemplateArgs(TemplateName(), TemplateArgs, NumTemplateArgs);
 }
 
 void CXXNameMangler::mangleUnqualifiedName(
     GlobalDecl GD, DeclarationName Name, const DeclContext *DC,
     unsigned KnownArity, const AbiTagList *AdditionalAbiTags) {
   const NamedDecl *ND = cast_or_null<NamedDecl>(GD.getDecl());
-  //  <unqualified-name> ::= [<module-name>] <operator-name>
+  //  <unqualified-name> ::= [<module-name>] [F] <operator-name>
   //                     ::= <ctor-dtor-name>
-  //                     ::= [<module-name>] <source-name>
+  //                     ::= [<module-name>] [F] <source-name>
   //                     ::= [<module-name>] DC <source-name>* E
 
   if (ND && DC && DC->isFileContext())
     mangleModuleName(ND);
 
+  // A member-like constrained friend is mangled with a leading 'F'.
+  // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+  auto *FD = dyn_cast<FunctionDecl>(ND);
+  auto *FTD = dyn_cast<FunctionTemplateDecl>(ND);
+  if ((FD && FD->isMemberLikeConstrainedFriend()) ||
+      (FTD && FTD->getTemplatedDecl()->isMemberLikeConstrainedFriend())) {
+    if (!isCompatibleWith(LangOptions::ClangABI::Ver17))
+      Out << 'F';
+  }
+
   unsigned Arity = KnownArity;
   switch (Name.getNameKind()) {
   case DeclarationName::Identifier: {
     const IdentifierInfo *II = Name.getAsIdentifierInfo();
 
     // We mangle decomposition declarations as the names of their bindings.
     if (auto *DD = dyn_cast<DecompositionDecl>(ND)) {
       // FIXME: Non-standard mangling for decomposition declarations:
if (II) {
       //
       // Don't bother with the L marker for names in anonymous namespaces; the
       // 12_GLOBAL__N_1 mangling is quite sufficient there, and this better
       // matches GCC anyway, because GCC does not treat anonymous namespaces as
       // implying internal linkage.
       if (Context.isInternalLinkageDecl(ND))
         Out << 'L';
 
-      auto *FD = dyn_cast<FunctionDecl>(ND);
       bool IsRegCall = FD &&
                        FD->getType()->castAs<FunctionType>()->getCallConv() ==
                            clang::CC_X86RegCall;
       bool IsDeviceStub =
           FD && FD->hasAttr<CUDAGlobalAttr>() &&
           GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
       if (IsDeviceStub)
         mangleDeviceStubName(II);
else
     manglePrefix(DC);
   mangleUnqualifiedBlock(Block);
 }
 
 void CXXNameMangler::mangleUnqualifiedBlock(const BlockDecl *Block) {
   // When trying to be ABI-compatibility with clang 12 and before, mangle a
   // <data-member-prefix> now, with no substitutions and no <template-args>.
   if (Decl *Context = Block->getBlockManglingContextDecl()) {
-    if (getASTContext().getLangOpts().getClangABICompat() <=
-            LangOptions::ClangABI::Ver12 &&
+    if (isCompatibleWith(LangOptions::ClangABI::Ver12) &&
         (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
         Context->getDeclContext()->isRecord()) {
       const auto *ND = cast<NamedDecl>(Context);
       if (ND->getIdentifier()) {
         mangleSourceNameWithAbiTags(ND);
         Out << 'M';
       }
     }
void CXXNameMangler::mangleUnqualifiedBlock(const BlockDecl *Block) {
   }
   Out << "Ub";
   if (Number > 0)
     Out << Number - 1;
   Out << '_';
 }
 
 // <template-param-decl>
-//   ::= Ty                              # template type parameter
-//   ::= Tn <type>                       # template non-type parameter
-//   ::= Tt <template-param-decl>* E     # template template parameter
-//   ::= Tp <template-param-decl>        # template parameter pack
+//   ::= Ty                                  # template type parameter
+//   ::= Tk <concept name> [<template-args>] # constrained type parameter
+//   ::= Tn <type>                           # template non-type parameter
+//   ::= Tt <template-param-decl>* E [Q <requires-clause expr>]
+//                                           # template template parameter
+//   ::= Tp <template-param-decl>            # template parameter pack
 void CXXNameMangler::mangleTemplateParamDecl(const NamedDecl *Decl) {
+  // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/47.
   if (auto *Ty = dyn_cast<TemplateTypeParmDecl>(Decl)) {
     if (Ty->isParameterPack())
       Out << "Tp";
+    const TypeConstraint *Constraint = Ty->getTypeConstraint();
+    if (Constraint && !isCompatibleWith(LangOptions::ClangABI::Ver17)) {
+      // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+      Out << "Tk";
+      mangleTypeConstraint(Constraint);
+    } else {
       Out << "Ty";
+    }
   } else if (auto *Tn = dyn_cast<NonTypeTemplateParmDecl>(Decl)) {
     if (Tn->isExpandedParameterPack()) {
       for (unsigned I = 0, N = Tn->getNumExpansionTypes(); I != N; ++I) {
         Out << "Tn";
         mangleType(Tn->getExpansionType(I));
       }
     } else {
       QualType T = Tn->getType();
       if (Tn->isParameterPack()) {
         Out << "Tp";
         if (auto *PackExpansion = T->getAs<PackExpansionType>())
           T = PackExpansion->getPattern();
       }
       Out << "Tn";
       mangleType(T);
     }
   } else if (auto *Tt = dyn_cast<TemplateTemplateParmDecl>(Decl)) {
     if (Tt->isExpandedParameterPack()) {
       for (unsigned I = 0, N = Tt->getNumExpansionTemplateParameters(); I != N;
-           ++I) {
-        Out << "Tt";
-        for (auto *Param : *Tt->getExpansionTemplateParameters(I))
-          mangleTemplateParamDecl(Param);
-        Out << "E";
-      }
+           ++I)
+        mangleTemplateParameterList(Tt->getExpansionTemplateParameters(I));
     } else {
       if (Tt->isParameterPack())
         Out << "Tp";
-      Out << "Tt";
-      for (auto *Param : *Tt->getTemplateParameters())
-        mangleTemplateParamDecl(Param);
-      Out << "E";
-    }
+      mangleTemplateParameterList(Tt->getTemplateParameters());
+    }
+  }
+}
+
+void CXXNameMangler::mangleTemplateParameterList(
+    const TemplateParameterList *Params) {
+  for (auto *Param : *Params)
+  mangleRequiresClause(Params->getRequiresClause());
+
+void CXXNameMangler::mangleTypeConstraint(
+    const ConceptDecl *Concept, ArrayRef<TemplateArgument> Arguments) {
+  const DeclContext *DC = Context.getEffectiveDeclContext(Concept);
+  if (!Arguments.empty())
+    mangleTemplateName(Concept, Arguments);
+  else if (DC->isTranslationUnit() || isStdNamespace(DC))
+    mangleUnscopedName(Concept, DC, nullptr);
+  else
+    mangleNestedName(Concept, DC, nullptr);
+}
+
+void CXXNameMangler::mangleTypeConstraint(const TypeConstraint *Constraint) {
+  llvm::SmallVector<TemplateArgument, 8> Args;
+  if (Constraint->getTemplateArgsAsWritten()) {
+    for (const TemplateArgumentLoc &ArgLoc :
+         Constraint->getTemplateArgsAsWritten()->arguments())
+      Args.push_back(ArgLoc.getArgument());
+  }
+  return mangleTypeConstraint(Constraint->getNamedConcept(), Args);
+}
+
+void CXXNameMangler::mangleRequiresClause(const Expr *RequiresClause) {
+  // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+  if (RequiresClause && !isCompatibleWith(LangOptions::ClangABI::Ver17)) {
+    Out << 'Q';
+    mangleExpression(RequiresClause);
   }
 }
 
 void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) {
   // When trying to be ABI-compatibility with clang 12 and before, mangle a
   // <data-member-prefix> now, with no substitutions.
   if (Decl *Context = Lambda->getLambdaContextDecl()) {
-    if (getASTContext().getLangOpts().getClangABICompat() <=
-            LangOptions::ClangABI::Ver12 &&
+    if (isCompatibleWith(LangOptions::ClangABI::Ver12) &&
         (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
         !isa<ParmVarDecl>(Context)) {
       if (const IdentifierInfo *Name
             = cast<NamedDecl>(Context)->getIdentifier()) {
         mangleSourceName(Name);
         const TemplateArgumentList *TemplateArgs = nullptr;
         if (GlobalDecl TD = isTemplate(cast<NamedDecl>(Context), TemplateArgs))
           mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) {
 
   assert(Number > 0 && "Lambda should be mangled as an unnamed class");
   if (Number > 1)
     mangleNumber(Number - 2);
   Out << '_';
 }
 
 void CXXNameMangler::mangleLambdaSig(const CXXRecordDecl *Lambda) {
+  // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/31.
   for (auto *D : Lambda->getLambdaExplicitTemplateParameters())
     mangleTemplateParamDecl(D);
+
+  // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+  if (auto *TPL = Lambda->getGenericLambdaTemplateParameterList())
+    mangleRequiresClause(TPL->getRequiresClause());
+
   auto *Proto =
       Lambda->getLambdaTypeInfo()->getType()->castAs<FunctionProtoType>();
   mangleBareFunctionType(Proto, /*MangleReturnType=*/false,
                          Lambda->getLambdaStaticInvoker());
 }
 
 void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
   switch (qualifier->getKind()) {
void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     manglePrefix(QualType(qualifier->getAsType(), 0));
     return;
 
   case NestedNameSpecifier::Identifier:
     // Clang 14 and before did not consider this substitutable.
-    bool Clang14Compat = getASTContext().getLangOpts().getClangABICompat() <=
-                         LangOptions::ClangABI::Ver14;
+    bool Clang14Compat = isCompatibleWith(LangOptions::ClangABI::Ver14);
     if (!Clang14Compat && mangleSubstitution(qualifier))
       return;
 
     // Member expressions can have these without prefixes, but that
     // should end up in mangleUnresolvedPrefix instead.
     assert(qualifier->getPrefix());
     manglePrefix(qualifier->getPrefix());
 
void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) {
   if (TemplateDecl *TD = Template.getAsTemplateDecl())
     return mangleTemplatePrefix(TD);
 
   DependentTemplateName *Dependent = Template.getAsDependentTemplateName();
   assert(Dependent && "unexpected template name kind");
 
   // Clang 11 and before mangled the substitution for a dependent template name
   // after already having emitted (a substitution for) the prefix.
-  bool Clang11Compat = getASTContext().getLangOpts().getClangABICompat() <=
-                       LangOptions::ClangABI::Ver11;
+  bool Clang11Compat = isCompatibleWith(LangOptions::ClangABI::Ver11);
   if (!Clang11Compat && mangleSubstitution(Template))
     return;
 
   if (NestedNameSpecifier *Qualifier = Dependent->getQualifier())
     manglePrefix(Qualifier);
 
   if (Clang11Compat && mangleSubstitution(Template))
     return;
else
       mangleUnqualifiedName(GD.getWithDecl(ND->getTemplatedDecl()), DC,
                             nullptr);
   }
 
   addSubstitution(ND);
 }
 
 const NamedDecl *CXXNameMangler::getClosurePrefix(const Decl *ND) {
-  if (getASTContext().getLangOpts().getClangABICompat() <=
-      LangOptions::ClangABI::Ver12)
+  if (isCompatibleWith(LangOptions::ClangABI::Ver12))
     return nullptr;
 
   const NamedDecl *Context = nullptr;
   if (auto *Block = dyn_cast<BlockDecl>(ND)) {
     Context = dyn_cast_or_null<NamedDecl>(Block->getBlockManglingContextDecl());
   } else if (auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
     if (RD->isLambda())
       Context = dyn_cast_or_null<NamedDecl>(RD->getLambdaContextDecl());
if (MangleReturnType) {
     mangleType(ReturnTy);
 
     FunctionTypeDepth.leaveResultType();
   }
 
   if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
     //   <builtin-type> ::= v   # void
     Out << 'v';
-
-    FunctionTypeDepth.pop(saved);
-    return;
-  }
-
+  } else {
     assert(!FD || FD->getNumParams() == Proto->getNumParams());
     for (unsigned I = 0, E = Proto->getNumParams(); I != E; ++I) {
       // Mangle extended parameter info as order-sensitive qualifiers here.
       if (Proto->hasExtParameterInfos() && FD == nullptr) {
         mangleExtParameterInfo(Proto->getExtParameterInfo(I));
       }
 
       // Mangle the type.
       QualType ParamTy = Proto->getParamType(I);
       mangleType(Context.getASTContext().getSignatureParameterType(ParamTy));
 
       if (FD) {
         if (auto *Attr = FD->getParamDecl(I)->getAttr<PassObjectSizeAttr>()) {
-        // Attr can only take 1 character, so we can hardcode the length below.
+          // Attr can only take 1 character, so we can hardcode the length
+          // below.
           assert(Attr->getType() <= 9 && Attr->getType() >= 0);
           if (Attr->isDynamic())
             Out << "U25pass_dynamic_object_size" << Attr->getType();
           else
             Out << "U17pass_object_size" << Attr->getType();
         }
       }
     }
 
-  FunctionTypeDepth.pop(saved);
-
     // <builtin-type>      ::= z  # ellipsis
     if (Proto->isVariadic())
       Out << 'z';
   }
 
+  if (FD) {
+    FunctionTypeDepth.enterResultType();
+    mangleRequiresClause(FD->getTrailingRequiresClause());
+  }
+
+  FunctionTypeDepth.pop(saved);
+}
+
 // <type>            ::= <class-enum-type>
 // <class-enum-type> ::= <name>
 void CXXNameMangler::mangleType(const UnresolvedUsingType *T) {
   mangleName(T->getDecl());
 }
 
 // <type>            ::= <class-enum-type>
 // <class-enum-type> ::= <name>

 
 void CXXNameMangler::mangleType(const AutoType *T) {
   assert(T->getDeducedType().isNull() &&
          "Deduced AutoType shouldn't be handled here!");
   assert(T->getKeyword() != AutoTypeKeyword::GNUAutoType &&
          "shouldn't need to mangle __auto_type!");
   // <builtin-type> ::= Da # auto
   //                ::= Dc # decltype(auto)
+  //                ::= Dk # constrained auto
+  //                ::= DK # constrained decltype(auto)
+  if (T->isConstrained() && !isCompatibleWith(LangOptions::ClangABI::Ver17)) {
+    Out << (T->isDecltypeAuto() ? "DK" : "Dk");
+    mangleTypeConstraint(T->getTypeConstraintConcept(),
+                         T->getTypeConstraintArguments());
+  } else {
     Out << (T->isDecltypeAuto() ? "Dc" : "Da");
   }
+}
 
 void CXXNameMangler::mangleType(const DeducedTemplateSpecializationType *T) {
   QualType Deduced = T->getDeducedType();
   if (!Deduced.isNull())
     return mangleType(Deduced);
 
   TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl();
   assert(TD && "shouldn't form deduced TST unless we know we have a template");

 
 void CXXNameMangler::mangleInitListElements(const InitListExpr *InitList) {
   if (auto *Syntactic = InitList->getSyntacticForm())
     InitList = Syntactic;
   for (unsigned i = 0, e = InitList->getNumInits(); i != e; ++i)
     mangleExpression(InitList->getInit(i));
 }
 
+void CXXNameMangler::mangleRequirement(SourceLocation RequiresExprLoc,
+                                       const concepts::Requirement *Req) {
+  using concepts::Requirement;
+
+  // TODO: We can't mangle the result of a failed substitution. It's not clear
+  // whether we should be mangling the original form prior to any substitution
+  // instead. See https://lists.isocpp.org/core/2023/04/14118.php
+  auto HandleSubstitutionFailure =
+      [&](SourceLocation Loc) {
+        DiagnosticsEngine &Diags = Context.getDiags();
+        unsigned DiagID = Diags.getCustomDiagID(
+            DiagnosticsEngine::Error, "cannot mangle this requires-expression "
+                                      "containing a substitution failure");
+        Diags.Report(Loc, DiagID);
+        Out << 'F';
+      };
+
+  switch (Req->getKind()) {
+  case Requirement::RK_Type: {
+    const auto *TR = cast<concepts::TypeRequirement>(Req);
+    if (TR->isSubstitutionFailure())
+      return HandleSubstitutionFailure(
+          TR->getSubstitutionDiagnostic()->DiagLoc);
+
+    Out << 'T';
+    mangleType(TR->getType()->getType());
+    break;
+  }
+
+  case Requirement::RK_Simple:
+  case Requirement::RK_Compound: {
+    const auto *ER = cast<concepts::ExprRequirement>(Req);
+    if (ER->isExprSubstitutionFailure())
+      return HandleSubstitutionFailure(
+          ER->getExprSubstitutionDiagnostic()->DiagLoc);
+
+    Out << 'X';
+    mangleExpression(ER->getExpr());
+
+    if (ER->hasNoexceptRequirement())
+      Out << 'N';
+
+    if (!ER->getReturnTypeRequirement().isEmpty()) {
+      if (ER->getReturnTypeRequirement().isSubstitutionFailure())
+        return HandleSubstitutionFailure(ER->getReturnTypeRequirement()
+                                             .getSubstitutionDiagnostic()
+                                             ->DiagLoc);
+
+      Out << 'R';
+      mangleTypeConstraint(ER->getReturnTypeRequirement().getTypeConstraint());
+    }
+    break;
+  }
+
+  case Requirement::RK_Nested:
+    const auto *NR = cast<concepts::NestedRequirement>(Req);
+    if (NR->hasInvalidConstraint()) {
+      // FIXME: NestedRequirement should track the location of its requires
+      // keyword.
+      return HandleSubstitutionFailure(RequiresExprLoc);
+    }
+
+    Out << 'Q';
+    mangleExpression(NR->getConstraintExpr());
+    break;
+  }
+}
+
 void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
                                       bool AsTemplateArg) {
   // <expression> ::= <unary operator-name> <expression>
   //              ::= <binary operator-name> <expression> <expression>
   //              ::= <trinary operator-name> <expression> <expression> <expression>
   //              ::= cv <type> expression           # conversion with one argument
   //              ::= cv <type> _ <expression>* E # conversion with a different number of arguments
   //              ::= dc <type> <expression>         # dynamic_cast<type> (expression)
#include "clang/AST/StmtNodes.inc"
   case Expr::ObjCIndirectCopyRestoreExprClass:
   case Expr::ObjCAvailabilityCheckExprClass:
   case Expr::OffsetOfExprClass:
   case Expr::PredefinedExprClass:
   case Expr::ShuffleVectorExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::TypeTraitExprClass:
-  case Expr::RequiresExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::SourceLocExprClass:
case Expr::BuiltinBitCastExprClass:
     break;
   }
 
   case Expr::CXXUuidofExprClass: {
     NotPrimaryExpr();
     const CXXUuidofExpr *UE = cast<CXXUuidofExpr>(E);
     // As of clang 12, uuidof uses the vendor extended expression
     // mangling. Previously, it used a special-cased nonstandard extension.
-    if (Context.getASTContext().getLangOpts().getClangABICompat() >
-        LangOptions::ClangABI::Ver11) {
+    if (!isCompatibleWith(LangOptions::ClangABI::Ver11)) {
       Out << "u8__uuidof";
       if (UE->isTypeOperand())
         mangleType(UE->getTypeOperand(Context.getASTContext()));
       else
         mangleTemplateArgExpr(UE->getExprOperand());
       Out << 'E';
     } else {
       if (UE->isTypeOperand()) {
case Expr::UnaryExprOrTypeTraitExprClass: {
     case UETT_SizeOf:
       Out << 's';
       MangleAlignofSizeofArg();
       break;
     case UETT_PreferredAlignOf:
       // As of clang 12, we mangle __alignof__ differently than alignof. (They
       // have acted differently since Clang 8, but were previously mangled the
       // same.)
-      if (Context.getASTContext().getLangOpts().getClangABICompat() >
-          LangOptions::ClangABI::Ver11) {
+      if (!isCompatibleWith(LangOptions::ClangABI::Ver11)) {
         Out << "u11__alignof__";
         if (SAE->isArgumentType())
           mangleType(SAE->getArgumentType());
         else
           mangleTemplateArgExpr(SAE->getArgumentExpr());
         Out << 'E';
         break;
       }
case Expr::CXXOperatorCallExprClass: {
     break;
   }
 
   case Expr::ParenExprClass:
     E = cast<ParenExpr>(E)->getSubExpr();
     goto recurse;
 
   case Expr::ConceptSpecializationExprClass: {
-    //  <expr-primary> ::= L <mangled-name> E # external name
-    Out << "L_Z";
     auto *CSE = cast<ConceptSpecializationExpr>(E);
+    if (isCompatibleWith(LangOptions::ClangABI::Ver17)) {
+      // Clang 17 and before mangled concept-ids as if they resolved to an
+      // entity, meaning that references to enclosing template arguments don't
+      // work.
+      Out << "L_Z";
       mangleTemplateName(CSE->getNamedConcept(), CSE->getTemplateArguments());
       Out << 'E';
       break;
     }
+    // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+    NotPrimaryExpr();
+    mangleUnresolvedName(
+        CSE->getNestedNameSpecifierLoc().getNestedNameSpecifier(),
+        CSE->getConceptNameInfo().getName(),
+        CSE->getTemplateArgsAsWritten()->getTemplateArgs(),
+        CSE->getTemplateArgsAsWritten()->getNumTemplateArgs());
+    break;
+  }
+
+  case Expr::RequiresExprClass: {
+    // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+    auto *RE = cast<RequiresExpr>(E);
+    // This is a primary-expression in the C++ grammar, but does not have an
+    // <expr-primary> mangling (starting with 'L').
+    NotPrimaryExpr();
+    if (RE->getLParenLoc().isValid()) {
+      Out << "rQ";
+      FunctionTypeDepthState saved = FunctionTypeDepth.push();
+      if (RE->getLocalParameters().empty()) {
+        Out << 'v';
+      } else {
+        for (ParmVarDecl *Param : RE->getLocalParameters()) {
+          mangleType(Context.getASTContext().getSignatureParameterType(
+              Param->getType()));
+        }
+      }
+      Out << '_';
+
+      // The rest of the mangling is in the immediate scope of the parameters.
+      FunctionTypeDepth.enterResultType();
+      for (const concepts::Requirement *Req : RE->getRequirements())
+        mangleRequirement(RE->getExprLoc(), Req);
+      FunctionTypeDepth.pop(saved);
+      Out << 'E';
+    } else {
+      Out << "rq";
+      for (const concepts::Requirement *Req : RE->getRequirements())
+        mangleRequirement(RE->getExprLoc(), Req);
+      Out << 'E';
+    }
+    break;
+  }
 
   case Expr::DeclRefExprClass:
     // MangleDeclRefExpr helper handles primary-vs-nonprimary
     MangleDeclRefExpr(cast<DeclRefExpr>(E)->getDecl());
     break;
 
   case Expr::SubstNonTypeTemplateParmPackExprClass:
     NotPrimaryExpr();
case Dtor_Base:
     Out << "D2";
     break;
   case Dtor_Comdat:
     Out << "D5";
     break;
   }
 }
 
-namespace {
 // Helper to provide ancillary information on a template used to mangle its
 // arguments.
-struct TemplateArgManglingInfo {
+struct CXXNameMangler::TemplateArgManglingInfo {
+  const CXXNameMangler &Mangler;
   TemplateDecl *ResolvedTemplate = nullptr;
   bool SeenPackExpansionIntoNonPack = false;
   const NamedDecl *UnresolvedExpandedPack = nullptr;
 
-  TemplateArgManglingInfo(TemplateName TN) {
+  TemplateArgManglingInfo(const CXXNameMangler &Mangler, TemplateName TN)
+      : Mangler(Mangler) {
     if (TemplateDecl *TD = TN.getAsTemplateDecl())
       ResolvedTemplate = TD;
   }
 
-  /// Do we need to mangle template arguments with exactly correct types?
-  ///
+  /// Information about how to mangle a template argument.
+  struct Info {
+    /// Do we need to mangle the template argument with an exactly correct type?
+    bool NeedExactType;
+    /// If we need to prefix the mangling with a mangling of the template
+    /// parameter, the corresponding parameter.
+    const NamedDecl *TemplateParameterToMangle;
+  };
+
+  /// Determine whether the resolved template might be overloaded on its
+  /// template parameter list. If so, the mangling needs to include enough
+  /// information to reconstruct the template parameter list.
+  bool isOverloadable() {
+    // Function templates are generally overloadable. As a special case, a
+    // member function template of a generic lambda is not overloadable.
+    if (auto *FTD = dyn_cast_or_null<FunctionTemplateDecl>(ResolvedTemplate)) {
+      auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
+      if (!RD || !RD->isGenericLambda())
+        return true;
+    }
+
+    // All other templates are not overloadable. Partial specializations would
+    // be, but we never mangle them.
+    return false;
+  }
+
+  /// Determine whether we need to prefix this <template-arg> mangling with a
+  /// <template-param-decl>. This happens if the natural template parameter for
+  /// the argument mangling is not the same as the actual template parameter.
+  bool needToMangleTemplateParam(const NamedDecl *Param,
+                                 const TemplateArgument &Arg) {
+    // For a template type parameter, the natural parameter is 'typename T'.
+    // The actual parameter might be constrained.
+    if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
+      return TTP->hasTypeConstraint();
+
+    if (Arg.getKind() == TemplateArgument::Pack) {
+      // For an empty pack, the natural parameter is `typename...`.
+      if (Arg.pack_size() == 0)
+        return true;
+
+      // For any other pack, we use the first argument to determine the natural
+      // template parameter.
+      return needToMangleTemplateParam(Param, *Arg.pack_begin());
+    }
+
+    // For a non-type template parameter, the natural parameter is `T V` (for a
+    // prvalue argument) or `T &V` (for a glvalue argument), where `T` is the
+    // type of the argument, which we require to exactly match. If the actual
+    // parameter has a deduced or instantiation-dependent type, it is not
+    // equivalent to the natural parameter.
+    if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
+      return NTTP->getType()->isInstantiationDependentType() ||
+             NTTP->getType()->getContainedDeducedType();
+
+    // For a template template parameter, the template-head might differ from
+    // that of the template.
+    auto *TTP = cast<TemplateTemplateParmDecl>(Param);
+    TemplateName ArgTemplateName = Arg.getAsTemplateOrTemplatePattern();
+    const TemplateDecl *ArgTemplate = ArgTemplateName.getAsTemplateDecl();
+    if (!ArgTemplate)
+      return true;
+
+    // Mangle the template parameter list of the parameter and argument to see
+    // if they are the same. We can't use Profile for this, because it can't
+    // model the depth difference between parameter and argument and might not
+    // necessarily have the same definition of "identical" that we use here --
+    // that is, same mangling.
+    auto MangleTemplateParamListToString =
+        [&](SmallVectorImpl<char> &Buffer, const TemplateParameterList *Params,
+            unsigned DepthOffset) {
+          llvm::raw_svector_ostream Stream(Buffer);
+          CXXNameMangler(Mangler.Context, Stream,
+                         WithTemplateDepthOffset{DepthOffset})
+              .mangleTemplateParameterList(Params);
+        };
+    llvm::SmallString<128> ParamTemplateHead, ArgTemplateHead;
+    MangleTemplateParamListToString(ParamTemplateHead,
+                                    TTP->getTemplateParameters(), 0);
+    // Add the depth of the parameter's template parameter list to all
+    // parameters appearing in the argument to make the indexes line up
+    // properly.
+    MangleTemplateParamListToString(ArgTemplateHead,
+                                    ArgTemplate->getTemplateParameters(),
+                                    TTP->getTemplateParameters()->getDepth());
+    return ParamTemplateHead != ArgTemplateHead;
+  }
+
+  /// Determine information about how this template argument should be mangled.
   /// This should be called exactly once for each parameter / argument pair, in
   /// order.
-  bool needExactType(unsigned ParamIdx, const TemplateArgument &Arg) {
+  Info getArgInfo(unsigned ParamIdx, const TemplateArgument &Arg) {
     // We need correct types when the template-name is unresolved or when it
     // names a template that is able to be overloaded.
     if (!ResolvedTemplate || SeenPackExpansionIntoNonPack)
-      return true;
+      return {true, nullptr};
 
     // Move to the next parameter.
     const NamedDecl *Param = UnresolvedExpandedPack;
     if (!Param) {
       assert(ParamIdx < ResolvedTemplate->getTemplateParameters()->size() &&
              "no parameter for argument");
       Param = ResolvedTemplate->getTemplateParameters()->getParam(ParamIdx);
 
Info getArgInfo(unsigned ParamIdx, const TemplateArgument &Arg) {
     }
 
     // If we encounter a pack argument that is expanded into a non-pack
     // parameter, we can no longer track parameter / argument correspondence,
     // and need to use exact types from this point onwards.
     if (Arg.isPackExpansion() &&
         (!Param->isParameterPack() || UnresolvedExpandedPack)) {
       SeenPackExpansionIntoNonPack = true;
-      return true;
+      return {true, nullptr};
     }
 
-    // We need exact types for function template arguments because they might be
-    // overloaded on template parameter type. As a special case, a member
-    // function template of a generic lambda is not overloadable.
-    if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ResolvedTemplate)) {
-      auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
-      if (!RD || !RD->isGenericLambda())
-        return true;
-    }
+    // We need exact types for arguments of a template that might be overloaded
+    // on template parameter type.
+    if (isOverloadable())
+      return {true, needToMangleTemplateParam(Param, Arg) ? Param : nullptr};
 
     // Otherwise, we only need a correct type if the parameter has a deduced
     // type.
     //
     // Note: for an expanded parameter pack, getType() returns the type prior
     // to expansion. We could ask for the expanded type with getExpansionType(),
     // but it doesn't matter because substitution and expansion don't affect
     // whether a deduced type appears in the type.
     auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param);
-    return NTTP && NTTP->getType()->getContainedDeducedType();
+    bool NeedExactType = NTTP && NTTP->getType()->getContainedDeducedType();
+    return {NeedExactType, nullptr};
   }
-};
+
+  /// Determine if we should mangle a requires-clause after the template
+  /// argument list. If so, returns the expression to mangle.
+  const Expr *getTrailingRequiresClauseToMangle() {
+    if (!isOverloadable())
+      return nullptr;
+    return ResolvedTemplate->getTemplateParameters()->getRequiresClause();
   }
+};
 
 void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
                                         const TemplateArgumentLoc *TemplateArgs,
                                         unsigned NumTemplateArgs) {
-  // <template-args> ::= I <template-arg>+ E
+  // <template-args> ::= I <template-arg>+ [Q <requires-clause expr>] E
   Out << 'I';
-  TemplateArgManglingInfo Info(TN);
-  for (unsigned i = 0; i != NumTemplateArgs; ++i)
-    mangleTemplateArg(TemplateArgs[i].getArgument(),
-                      Info.needExactType(i, TemplateArgs[i].getArgument()));
+  TemplateArgManglingInfo Info(*this, TN);
+  for (unsigned i = 0; i != NumTemplateArgs; ++i) {
+    mangleTemplateArg(Info, i, TemplateArgs[i].getArgument());
+  }
+  mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());
   Out << 'E';
 }
 
 void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
                                         const TemplateArgumentList &AL) {
-  // <template-args> ::= I <template-arg>+ E
+  // <template-args> ::= I <template-arg>+ [Q <requires-clause expr>] E
   Out << 'I';
-  TemplateArgManglingInfo Info(TN);
-  for (unsigned i = 0, e = AL.size(); i != e; ++i)
-    mangleTemplateArg(AL[i], Info.needExactType(i, AL[i]));
+  TemplateArgManglingInfo Info(*this, TN);
+  for (unsigned i = 0, e = AL.size(); i != e; ++i) {
+    mangleTemplateArg(Info, i, AL[i]);
+  }
+  mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());
   Out << 'E';
 }
 
 void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
                                         ArrayRef<TemplateArgument> Args) {
-  // <template-args> ::= I <template-arg>+ E
+  // <template-args> ::= I <template-arg>+ [Q <requires-clause expr>] E
   Out << 'I';
-  TemplateArgManglingInfo Info(TN);
-  for (unsigned i = 0; i != Args.size(); ++i)
-    mangleTemplateArg(Args[i], Info.needExactType(i, Args[i]));
+  TemplateArgManglingInfo Info(*this, TN);
+  for (unsigned i = 0; i != Args.size(); ++i) {
+    mangleTemplateArg(Info, i, Args[i]);
+  }
+  mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());
   Out << 'E';
 }
 
+void CXXNameMangler::mangleTemplateArg(TemplateArgManglingInfo &Info,
+                                       unsigned Index, TemplateArgument A) {
+  TemplateArgManglingInfo::Info ArgInfo = Info.getArgInfo(Index, A);
+
+  // Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/47.
+  if (ArgInfo.TemplateParameterToMangle &&
+      !isCompatibleWith(LangOptions::ClangABI::Ver17)) {
+    // The template parameter is mangled if the mangling would otherwise be
+    // ambiguous.
+    //
+    // <template-arg> ::= <template-param-decl> <template-arg>
+    //
+    // Clang 17 and before did not do this.
+    mangleTemplateParamDecl(ArgInfo.TemplateParameterToMangle);
+  }
+
+  mangleTemplateArg(A, ArgInfo.NeedExactType);
+}
+
 void CXXNameMangler::mangleTemplateArg(TemplateArgument A, bool NeedExactType) {
   // <template-arg> ::= <type>              # type or template
   //                ::= X <expression> E    # expression
   //                ::= <expr-primary>      # simple expressions
   //                ::= J <template-arg>* E # argument pack
   if (!A.isInstantiationDependent() || A.isDependent())
     A = Context.getASTContext().getCanonicalTemplateArgument(A);
 
case TemplateArgument::Declaration: {
     ASTContext &Ctx = Context.getASTContext();
     APValue Value;
     if (D->isCXXInstanceMember())
       // Simple pointer-to-member with no conversion.
       Value = APValue(D, /*IsDerivedMember=*/false, /*Path=*/{});
     else if (D->getType()->isArrayType() &&
              Ctx.hasSimilarType(Ctx.getDecayedType(D->getType()),
                                 A.getParamTypeForDecl()) &&
-             Ctx.getLangOpts().getClangABICompat() >
-                 LangOptions::ClangABI::Ver11)
+             !isCompatibleWith(LangOptions::ClangABI::Ver11))
       // Build a value corresponding to this implicit array-to-pointer decay.
       Value = APValue(APValue::LValueBase(D), CharUnits::Zero(),
                       {APValue::LValuePathEntry::ArrayIndex(0)},
                       /*OnePastTheEnd=*/false);
     else
       // Regular pointer or reference to a declaration.
       Value = APValue(APValue::LValueBase(D), CharUnits::Zero(),
                       ArrayRef<APValue::LValuePathEntry>(),
case TemplateArgument::Pack: {
     for (const auto &P : A.pack_elements())
       mangleTemplateArg(P, NeedExactType);
     Out << 'E';
   }
   }
 }
 
 void CXXNameMangler::mangleTemplateArgExpr(const Expr *E) {
-  ASTContext &Ctx = Context.getASTContext();
-  if (Ctx.getLangOpts().getClangABICompat() > LangOptions::ClangABI::Ver11) {
+  if (!isCompatibleWith(LangOptions::ClangABI::Ver11)) {
     mangleExpression(E, UnknownArity, /*AsTemplateArg=*/true);
     return;
   }
 
   // Prior to Clang 12, we didn't omit the X .. E around <expr-primary>
   // correctly in cases where the template argument was
   // constructed from an expression rather than an already-evaluated
   // literal. In such a case, we would then e.g. emit 'XLi0EE' instead of
if (!V.hasLValuePath()) {
         Out << "so";
         mangleType(T->isVoidPointerType()
                        ? getLValueType(Ctx, V).getUnqualifiedType()
                        : T->getPointeeType());
         Kind = Path;
       } else {
         if (NeedExactType &&
             !Ctx.hasSameType(T->getPointeeType(), getLValueType(Ctx, V)) &&
-            Ctx.getLangOpts().getClangABICompat() >
-                LangOptions::ClangABI::Ver11) {
+            !isCompatibleWith(LangOptions::ClangABI::Ver11)) {
           NotPrimaryExpr();
           Out << "cv";
           mangleType(T);
         }
         if (T->isPointerType()) {
           NotPrimaryExpr();
           Out << "ad";
         }
case APValue::MemberPointer:
     NotPrimaryExpr();
     if (!V.getMemberPointerPath().empty()) {
       Out << "mc";
       mangleType(T);
     } else if (NeedExactType &&
                !Ctx.hasSameType(
                    T->castAs<MemberPointerType>()->getPointeeType(),
                    V.getMemberPointerDecl()->getType()) &&
-               Ctx.getLangOpts().getClangABICompat() >
-                   LangOptions::ClangABI::Ver11) {
+               !isCompatibleWith(LangOptions::ClangABI::Ver11)) {
       Out << "cv";
       mangleType(T);
     }
     Out << "adL";
     mangle(V.getMemberPointerDecl());
     Out << 'E';
     if (!V.getMemberPointerPath().empty()) {
       CharUnits Offset =
void CXXNameMangler::mangleTemplateParameter(unsigned Depth, unsigned Index) {
   //                  ::= T <parameter-2 non-negative number> _
   //                  ::= TL <L-1 non-negative number> __
   //                  ::= TL <L-1 non-negative number> _
   //                         <parameter-2 non-negative number> _
   //
   // The latter two manglings are from a proposal here:
   // https://github.com/itanium-cxx-abi/cxx-abi/issues/31#issuecomment-528122117
   Out << 'T';
+  Depth += TemplateDepthOffset;
   if (Depth != 0)
     Out << 'L' << (Depth - 1) << '_';
   if (Index != 0)
     Out << (Index - 1);
   Out << '_';
 }
 
 void CXXNameMangler::mangleSeqID(unsigned SeqID) {

clang/lib/Frontend/CompilerInvocation.cpp

#undef LANG_OPTION_WITH_MARSHALLING
 
   for (StringRef Sanitizer : serializeSanitizerKinds(Opts.Sanitize))
     GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
 
   // Conflating '-fsanitize-system-ignorelist' and '-fsanitize-ignorelist'.
   for (const std::string &F : Opts.NoSanitizeFiles)
     GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
 
-  if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver3_8)
+  switch (Opts.getClangABICompat()) {
+  case LangOptions::ClangABI::Ver3_8:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "3.8");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver4)
+    break;
+  case LangOptions::ClangABI::Ver4:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "4.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver6)
+    break;
+  case LangOptions::ClangABI::Ver6:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "6.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver7)
+    break;
+  case LangOptions::ClangABI::Ver7:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "7.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver9)
+    break;
+  case LangOptions::ClangABI::Ver9:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "9.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver11)
+    break;
+  case LangOptions::ClangABI::Ver11:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "11.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver12)
+    break;
+  case LangOptions::ClangABI::Ver12:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "12.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver14)
+    break;
+  case LangOptions::ClangABI::Ver14:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "14.0");
-  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver15)
+    break;
+  case LangOptions::ClangABI::Ver15:
     GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "15.0");
+    break;
+  case LangOptions::ClangABI::Ver17:
+    GenerateArg(Consumer, OPT_fclang_abi_compat_EQ, "17.0");
+    break;
+  case LangOptions::ClangABI::Latest:
+    break;
+  }
 
   if (Opts.getSignReturnAddressScope() ==
       LangOptions::SignReturnAddressScopeKind::All)
     GenerateArg(Consumer, OPT_msign_return_address_EQ, "all");
   else if (Opts.getSignReturnAddressScope() ==
            LangOptions::SignReturnAddressScopeKind::NonLeaf)
     GenerateArg(Consumer, OPT_msign_return_address_EQ, "non-leaf");
 
if (!VerParts.first.startswith("0") &&
       else if (Major <= 11)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver11);
       else if (Major <= 12)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver12);
       else if (Major <= 14)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver14);
       else if (Major <= 15)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver15);
+      else if (Major <= 17)
+        Opts.setClangABICompat(LangOptions::ClangABI::Ver17);
     } else if (Ver != "latest") {
       Diags.Report(diag::err_drv_invalid_value)
           << A->getAsString(Args) << A->getValue();
     }
   }
 
   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
     StringRef SignScope = A->getValue();

clang/lib/Parse/ParseExprCXX.cpp

 ///         type-requirement
 ///         compound-requirement
 ///         nested-requirement
 ExprResult Parser::ParseRequiresExpression() {
   assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword");
   SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires'
 
   llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
+  BalancedDelimiterTracker Parens(*this, tok::l_paren);
   if (Tok.is(tok::l_paren)) {
     // requirement parameter list is present.
     ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
                                     Scope::DeclScope);
-    BalancedDelimiterTracker Parens(*this, tok::l_paren);
     Parens.consumeOpen();
     if (!Tok.is(tok::r_paren)) {
       ParsedAttributes FirstArgAttrs(getAttrFactory());
       SourceLocation EllipsisLoc;
       llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters;
       ParseParameterDeclarationClause(DeclaratorContext::RequiresExpr,
                                       FirstArgAttrs, LocalParameters,
                                       EllipsisLoc);
if (Requirements.empty()) {
       Braces.consumeClose();
       Actions.ActOnFinishRequiresExpr();
       return ExprError();
     }
   }
   Braces.consumeClose();
   Actions.ActOnFinishRequiresExpr();
   ParsingBodyDecl.complete(Body);
-  return Actions.ActOnRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls,
-                                   Requirements, Braces.getCloseLocation());
+  return Actions.ActOnRequiresExpr(
+      RequiresKWLoc, Body, Parens.getOpenLocation(), LocalParameterDecls,
+      Parens.getCloseLocation(), Requirements, Braces.getCloseLocation());
 }
 
 static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
   switch (kind) {
   default: llvm_unreachable("Not a known type trait");
 #define TYPE_TRAIT_1(Spelling, Name, Key) \
 case tok::kw_ ## Spelling: return UTT_ ## Name;
 #define TYPE_TRAIT_2(Spelling, Name, Key) \

clang/lib/Sema/SemaExprCXX.cpp

 }
 
 void Sema::ActOnFinishRequiresExpr() {
   assert(CurContext && "DeclContext imbalance!");
   CurContext = CurContext->getLexicalParent();
   assert(CurContext && "Popped translation unit!");
 }
 
-ExprResult
-Sema::ActOnRequiresExpr(SourceLocation RequiresKWLoc,
-                        RequiresExprBodyDecl *Body,
-                        ArrayRef<ParmVarDecl *> LocalParameters,
-                        ArrayRef<concepts::Requirement *> Requirements,
-                        SourceLocation ClosingBraceLoc) {
-  auto *RE = RequiresExpr::Create(Context, RequiresKWLoc, Body, LocalParameters,
-                                  Requirements, ClosingBraceLoc);
+ExprResult Sema::ActOnRequiresExpr(
+    SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body,
+    SourceLocation LParenLoc, ArrayRef<ParmVarDecl *> LocalParameters,
+    SourceLocation RParenLoc, ArrayRef<concepts::Requirement *> Requirements,
+  auto *RE = RequiresExpr::Create(Context, RequiresKWLoc, Body, LParenLoc,
+                                  LocalParameters, RParenLoc, Requirements,
+                                  ClosingBraceLoc);
   if (DiagnoseUnexpandedParameterPackInRequiresExpr(RE))
     return ExprError();
   return RE;
 }

clang/lib/Sema/SemaTemplateInstantiate.cpp

if (getDerived().TransformFunctionTypeParams(
           &TransParams, PInfos, &ErrorIdx) ||
       Trap.hasErrorOccurred()) {
     SmallVector<concepts::Requirement *, 4> TransReqs;
     ParmVarDecl *FailedDecl = Params[ErrorIdx];
     // Add a 'failed' Requirement to contain the error that caused the failure
     // here.
     TransReqs.push_back(RebuildTypeRequirement(createSubstDiag(
         SemaRef, Info, [&](llvm::raw_ostream &OS) { OS << *FailedDecl; })));
-    return getDerived().RebuildRequiresExpr(KWLoc, Body, TransParams, TransReqs,
-                                            RBraceLoc);
+    return getDerived().RebuildRequiresExpr(KWLoc, Body, RE->getLParenLoc(),
+                                            TransParams, RE->getRParenLoc(),
+                                            TransReqs, RBraceLoc);
   }
 
   return ExprResult{};
 }
 
 concepts::TypeRequirement *
 TemplateInstantiator::TransformTypeRequirement(concepts::TypeRequirement *Req) {
   if (!Req->isDependent() && !AlwaysRebuild())

clang/lib/Sema/TreeTransform.h

#include "clang/Basic/AttrList.inc"
   ///
   /// By default, transforms the types of conversion function, constructor,
   /// and destructor names and then (if needed) rebuilds the declaration name.
   /// Identifiers and selectors are returned unmodified. Subclasses may
   /// override this function to provide alternate behavior.
   DeclarationNameInfo
   TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
 
-  bool TransformRequiresExprRequirements(ArrayRef<concepts::Requirement *> Reqs,
+  bool TransformRequiresExprRequirements(
+      ArrayRef<concepts::Requirement *> Reqs,
       llvm::SmallVectorImpl<concepts::Requirement *> &Transformed);
   concepts::TypeRequirement *
   TransformTypeRequirement(concepts::TypeRequirement *Req);
   concepts::ExprRequirement *
   TransformExprRequirement(concepts::ExprRequirement *Req);
   concepts::NestedRequirement *
   TransformNestedRequirement(concepts::NestedRequirement *Req);
 

   }
 
   /// \brief Build a new requires expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
                                  RequiresExprBodyDecl *Body,
+                                 SourceLocation LParenLoc,
                                  ArrayRef<ParmVarDecl *> LocalParameters,
+                                 SourceLocation RParenLoc,
                                  ArrayRef<concepts::Requirement *> Requirements,
                                  SourceLocation ClosingBraceLoc) {
-    return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body,
-                                LocalParameters, Requirements, ClosingBraceLoc);
+    return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body, LParenLoc,
+                                LocalParameters, RParenLoc, Requirements,
+                                ClosingBraceLoc);
   }
 
   concepts::TypeRequirement *
   RebuildTypeRequirement(
       concepts::Requirement::SubstitutionDiagnostic *SubstDiag) {
     return SemaRef.BuildTypeRequirement(SubstDiag);
   }
 
if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
       if (ER->getReturnTypeRequirement().isTypeConstraint()) {
         ER->getReturnTypeRequirement()
                 .getTypeConstraintTemplateParameterList()->getParam(0)
                 ->setDeclContext(Body);
       }
     }
   }
 
-  return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
-                                          TransParams, TransReqs,
-                                          E->getRBraceLoc());
+  return getDerived().RebuildRequiresExpr(
+      E->getRequiresKWLoc(), Body, E->getLParenLoc(), TransParams,
+      E->getRParenLoc(), TransReqs, E->getRBraceLoc());
 }
 
 template<typename Derived>
 bool TreeTransform<Derived>::TransformRequiresExprRequirements(
     ArrayRef<concepts::Requirement *> Reqs,
     SmallVectorImpl<concepts::Requirement *> &Transformed) {
   for (concepts::Requirement *Req : Reqs) {
     concepts::Requirement *TransReq = nullptr;

clang/lib/Serialization/ASTReaderStmt.cpp

switch (RK) {
       } break;
     }
     if (!R)
       continue;
     Requirements.push_back(R);
   }
   std::copy(Requirements.begin(), Requirements.end(),
             E->getTrailingObjects<concepts::Requirement *>());
+  E->LParenLoc = Record.readSourceLocation();
+  E->RParenLoc = Record.readSourceLocation();
   E->RBraceLoc = Record.readSourceLocation();
 }
 
 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
   E->setLHS(Record.readSubExpr());
   E->setRHS(Record.readSubExpr());
   E->setRBracketLoc(readSourceLocation());

clang/lib/Serialization/ASTWriterStmt.cpp

if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(R)) {
         addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
       } else {
         Record.AddStmt(NestedReq->getConstraintExpr());
         if (!NestedReq->isDependent())
           addConstraintSatisfaction(Record, *NestedReq->Satisfaction);
       }
     }
   }
+  Record.AddSourceLocation(E->getLParenLoc());
+  Record.AddSourceLocation(E->getRParenLoc());
   Record.AddSourceLocation(E->getEndLoc());
 
   Code = serialization::EXPR_REQUIRES;
 }
 
 
 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);

clang/test/CodeGenCXX/mangle-concept.cpp

-// RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++2a -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
+// RUN: %clang_cc1 -verify -frelaxed-template-template-args -std=c++20 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
+// RUN: %clang_cc1 -verify -frelaxed-template-template-args -std=c++20 -emit-llvm -triple %itanium_abi_triple -o - %s -fclang-abi-compat=16 | FileCheck %s --check-prefix=CLANG16
 // expected-no-diagnostics
 
 namespace test1 {
 template <bool> struct S {};
 template <typename> concept C = true;
 template <typename T = int> S<C<T>> f0() { return S<C<T>>{}; }
 template S<C<int>> f0<>();
-// CHECK: @_ZN5test12f0IiEENS_1SIL_ZNS_1CIT_EEEEEv(
+// CHECK: @_ZN5test12f0IiEENS_1SIX1CIT_EEEEv(
+// CLANG16: @_ZN5test12f0IiEENS_1SIL_ZNS_1CIT_EEEEEv(
 }
 
 template <bool> struct S {};
 template <typename> concept C = true;
+template <typename, typename> concept D = true;
+
+template <typename T = int> S<test1::C<T>> f0a() { return S<C<T>>{}; }
+template S<test1::C<int>> f0a<>();
+// CHECK: @_Z3f0aIiE1SIXsr5test1E1CIT_EEEv(
+// CLANG16: @_Z3f0aIiE1SIL_ZN5test11CIT_EEEEv(
+
 template <typename T = int> S<C<T>> f0() { return S<C<T>>{}; }
 template S<C<int>> f0<>();
-// CHECK: @_Z2f0IiE1SIL_Z1CIT_EEEv(
+// CHECK: @_Z2f0IiE1SIX1CIT_EEEv(
+// CLANG16: @_Z2f0IiE1SIL_Z1CIT_EEEv(
+
+template<typename T> concept True = true;
+
+namespace test2 {
+  // Member-like friends.
+  template<typename T> struct A {
+    friend void f(...) requires True<T> {}
+
+    template<typename U = void>
+    friend void g(...) requires True<T> && True<U> {}
+
+    template<typename U = void>
+    friend void h(...) requires True<U> {}
+
+    template<typename U = void> requires True<T> && True<U>
+    friend void i(...) {}
+
+    template<typename U = void> requires True<U>
+    friend void j(...) {}
+
+    template<True U = void> requires True<T>
+    friend void k(...) {}
+
+    template<True U = void>
+    friend void l(...) {}
+  };
+
+  A<int> ai;
+
+  // CHECK-LABEL: define {{.*}}@{{.*}}test2{{.*}}use
+  void use() {
+    // CHECK: call {{.*}}@_ZN5test21AIiEF1fEzQ4TrueIT_E(
+    // CLANG16: call {{.*}}@_ZN5test21fEz(
+    f(ai);
+    // CHECK: call {{.*}}@_ZN5test2F1gIvEEvzQaa4TrueIT_E4TrueITL0__E(
+    // CLANG16: call {{.*}}@_ZN5test21gIvEEvz(
+    g(ai);
+    // CHECK: call {{.*}}@_ZN5test21hIvEEvzQ4TrueITL0__E(
+    // CLANG16: call {{.*}}@_ZN5test21hIvEEvz(
+    h(ai);
+    // CHECK: call {{.*}}@_ZN5test2F1iIvQaa4TrueIT_E4TrueITL0__EEEvz(
+    // CLANG16: call {{.*}}@_ZN5test21iIvEEvz(
+    i(ai);
+    // CHECK: call {{.*}}@_ZN5test21jIvQ4TrueITL0__EEEvz(
+    // CLANG16: call {{.*}}@_ZN5test21jIvEEvz(
+    j(ai);
+    // CHECK: call {{.*}}@_ZN5test2F1kITk4TruevQ4TrueIT_EEEvz(
+    // CLANG16: call {{.*}}@_ZN5test21kIvEEvz(
+    k(ai);
+    // CHECK: call {{.*}}@_ZN5test21lITk4TruevEEvz(
+    // CLANG16: call {{.*}}@_ZN5test21lIvEEvz(
+    l(ai);
+  }
+}
+
+namespace test3 {
+  // Unconstrained auto.
+  template<auto> void d() {}
+  template void d<0>();
+  // CHECK: define {{.*}}@_ZN5test31dITnDaLi0EEEvv(
+  // CLANG16: define {{.*}}@_ZN5test31dILi0EEEvv(
+
+  template<decltype(auto)> void e() {}
+  template void e<0>();
+  // CHECK: define {{.*}}@_ZN5test31eITnDcLi0EEEvv(
+  // CLANG16: define {{.*}}@_ZN5test31eILi0EEEvv(
+
+  // Constrained auto.
+  template<C auto> void f() {}
+  template void f<0>();
+  // CHECK: define {{.*}}@_ZN5test31fITnDk1CLi0EEEvv(
+  // CLANG16: define {{.*}}@_ZN5test31fILi0EEEvv(
+
+  template<D<int> auto> void g() {}
+  template void g<0>();
+  // CHECK: define {{.*}}@_ZN5test31gITnDk1DIiELi0EEEvv(
+  // CLANG16: define {{.*}}@_ZN5test31gILi0EEEvv(
+
+  template<typename T, D<T> auto> void h() {}
+  template void h<int, 0>();
+  // CHECK: define {{.*}}@_ZN5test31hIiTnDk1DIT_ELi0EEEvv(
+  // CLANG16: define {{.*}}@_ZN5test31hIiLi0EEEvv(
+
+  template<typename T> void i(decltype(new C auto(T()))) {}
+  template void i<int>(int*);
+  // CHECK: define {{.*}}@_ZN5test31iIiEEvDTnw_Dk1CpicvT__EEE(
+  // CLANG16: define {{.*}}@_ZN5test31iIiEEvDTnw_DapicvT__EEE(
+
+  template<typename T> void j(decltype(new C decltype(auto)(T()))) {}
+  template void j<int>(int*);
+  // CHECK: define {{.*}}@_ZN5test31jIiEEvDTnw_DK1CpicvT__EEE(
+  // CLANG16: define {{.*}}@_ZN5test31jIiEEvDTnw_DcpicvT__EEE(
+}
+
+namespace test4 {
+  // Constrained type parameters.
+  template<C> void f() {}
+  template void f<int>();
+  // CHECK: define {{.*}}@_ZN5test41fITk1CiEEvv(
+  // CLANG16: define {{.*}}@_ZN5test41fIiEEvv(
+
+  template<D<int>> void g() {}
+  template void g<int>();
+  // CHECK: define {{.*}}@_ZN5test41gITk1DIiEiEEvv(
+  // CLANG16: define {{.*}}@_ZN5test41gIiEEvv(
+}
+
+namespace test5 {
+  // Exact-match vs non-exact-match template template parameters.
+  template<typename T, T V> struct X {};
+  template<typename T, T V> requires C<T> struct Y {};
+  template<C T, T V> struct Z {};
+
+  template<template<typename T, T> typename> void f() {}
+  // CHECK: define {{.*}}@_ZN5test51fINS_1XEEEvv(
+  template void f<X>();
+  // CHECK: define {{.*}}@_ZN5test51fITtTyTnTL0__ENS_1YEEEvv(
+  template void f<Y>();
+  // CHECK: define {{.*}}@_ZN5test51fITtTyTnTL0__ENS_1ZEEEvv(
+  template void f<Z>();
+
+  template<template<typename T, T> requires C<T> typename> void g() {}
+  // CHECK: define {{.*}}@_ZN5test51gITtTyTnTL0__Q1CIS1_EENS_1XEEEvv(
+  template void g<X>();
+  // CHECK: define {{.*}}@_ZN5test51gINS_1YEEEvv(
+  template void g<Y>();
+  // CHECK: define {{.*}}@_ZN5test51gITtTyTnTL0__Q1CIS1_EENS_1ZEEEvv(
+  template void g<Z>();
+
+  template<template<C T, T> typename> void h() {}
+  // CHECK: define {{.*}}@_ZN5test51hITtTk1CTnTL0__ENS_1XEEEvv(
+  template void h<X>();
+  // CHECK: define {{.*}}@_ZN5test51hITtTk1CTnTL0__ENS_1YEEEvv(
+  template void h<Y>();
+  // CHECK: define {{.*}}@_ZN5test51hINS_1ZEEEvv(
+  template void h<Z>();
+
+  // Packs must match the first argument.
+  template<template<C T, T> typename...> void i() {}
+  // CHECK: define {{.*}}@_ZN5test51iITpTtTk1CTnTL0__EJNS_1XENS_1YENS_1ZEEEEvv(
+  template void i<X, Y, Z>();
+  // CHECK: define {{.*}}@_ZN5test51iITpTtTk1CTnTL0__EJNS_1YENS_1ZENS_1XEEEEvv(
+  template void i<Y, Z, X>();
+  // CHECK: define {{.*}}@_ZN5test51iIJNS_1ZENS_1XENS_1YEEEEvv(
+  template void i<Z, X, Y>();
+
+  template<typename ...T> struct A {};
+  template<typename, typename> struct B {};
+
+  template<template<typename ...> typename> void p() {}
+  // CHECK: define {{.*}}@_ZN5test51pINS_1AEEEvv(
+  // CLANG16: define {{.*}}@_ZN5test51pINS_1AEEEvv(
+  template void p<A>();
+  // CHECK: define {{.*}}@_ZN5test51pITtTpTyENS_1BEEEvv(
+  // CLANG16: define {{.*}}@_ZN5test51pINS_1BEEEvv(
+  template void p<B>();
+
+  template<template<typename, typename> typename> void q() {}
+  // CHECK: define {{.*}}@_ZN5test51qITtTyTyENS_1AEEEvv(
+  // CLANG16: define {{.*}}@_ZN5test51qINS_1AEEEvv(
+  template void q<A>();
+  // CHECK: define {{.*}}@_ZN5test51qINS_1BEEEvv(
+  // CLANG16: define {{.*}}@_ZN5test51qINS_1BEEEvv(
+  template void q<B>();
+}
+
+namespace test6 {
+  // Abbreviated function templates.
+  void f(C auto) {}
+  // CHECK: define {{.*}}@_ZN5test61fITk1CiEEvT_(
+  // CLANG16: define {{.*}}@_ZN5test61fIiEEvT_(
+  template void f(int);
+
+  template<typename T>
+  void g(D<T> auto) {}
+  // CHECK: define {{.*}}@_ZN5test61gIiTk1DIT_EiEEvT0_(
+  // CLANG16: define {{.*}}@_ZN5test61gIiiEEvT0_(
+  template void g<int>(int);
+}
+
+namespace test7 {
+  // Constrained lambdas.
+  template<typename T> void f() {
+    // Ensure that requires-clauses affect lambda numbering.
+    // CHECK-LABEL: define {{.*}}@_ZN5test71fIiEEvv(
+    // CHECK: call {{.*}}@_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E_clIiiEEDaS3_Q1CIDtfp_EE(
+    ([]<typename U> requires C<T> && C<U> (auto x) requires C<decltype(x)> {}).template operator()<int>(0);
+    // CHECK: call {{.*}}@_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E0_clIiiEEDaS3_Qaa1CIDtfp_EELb1E(
+    ([]<typename U> requires C<T> && C<U> (auto x) requires C<decltype(x)> && true {}).template operator()<int>(0);
+    // CHECK: call {{.*}}@_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E1_clIiiEEDaS3_Q1CIDtfp_EE(
+    ([]<typename U> requires C<T> && C<U> (auto x) requires C<decltype(x)> {}).template operator()<int>(0);
+    // CHECK: call {{.*}}@_ZZN5test71fIiEEvvENKUlTyT0_E_clIiiEEDaS1_(
+    ([]<typename U> (auto x){}).template operator()<int>(0);
+  }
+  template void f<int>();
+}

clang/test/CodeGenCXX/mangle-exprs.cpp

namespace Casts {
   // CHECK-LABEL: define weak_odr void @_ZN5Casts6cstyleILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE
   template void cstyle<4>(void*);
   // CHECK-LABEL: define weak_odr void @_ZN5Casts10functionalILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE
   template void functional<4>(void*);
   // CHECK-LABEL: define weak_odr void @_ZN5Casts7static_ILj4EEEvPN9enable_ifIXleT_scjLi4EEvE4typeE
   template void static_<4>(void*);
   // CHECK-LABEL: define weak_odr void @_ZN5Casts12reinterpret_ILj4EiEEvPN9enable_ifIXleT_szrcPT0_Li0EEvE4typeE
   template void reinterpret_<4, int>(void*);
-  // CHECK-LABEL: define weak_odr void @_ZN5Casts6const_IiXadL_ZNS_1iEEEEEvPN9enable_ifIXleLi0EszccPT_T0_EvE4typeE
+  // CHECK-LABEL: define weak_odr void @_ZN5Casts6const_IiTnPT_XadL_ZNS_1iEEEEEvPN9enable_ifIXleLi0EszccS2_T0_EvE4typeE
   template void const_<int, &i>(void*);
-  // CHECK-LABEL: define weak_odr void @_ZN5Casts8dynamic_INS_1SEXadL_ZNS_1sEEEEEvPN9enable_ifIXleLi0EszdcPT_T0_EvE4typeE
+  // CHECK-LABEL: define weak_odr void @_ZN5Casts8dynamic_INS_1SETnPT_XadL_ZNS_1sEEEEEvPN9enable_ifIXleLi0EszdcS3_T0_EvE4typeE
   template void dynamic_<struct S, &s>(void*);
 
   // CHECK-LABEL: define weak_odr void @_ZN5Casts1fILi6EEENS_1TIXT_EEEv
   template T<6> f<6>();
 
   // CHECK-LABEL: define weak_odr void @_ZN5Casts5auto_IiEEvDTnw_DapicvT__EEE(
   template void auto_<int>(int*);
 

clang/test/CodeGenCXX/mangle-nttp-anon-union.cpp

 
 
 template<auto tparam> void dummy(){}
 
 
 void uses() {
   // Zero init'ed cases.
   dummy<wrapper1<int>{}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper1IiEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper1IiEEEEvv
   // DEMANGLED: call void @void dummy<wrapper1<int>{}>()()
   dummy<wrapper2<float>{}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper2IfEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper2IfEEEEvv
   // DEMANGLED: call void @void dummy<wrapper2<float>{}>()()
   dummy<wrapper3<short>{}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper3IsEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper3IsEEEEvv
   // DEMANGLED: call void @void dummy<wrapper3<short>{}>()()
   dummy<wrapper4<double>{}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper4IdEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper4IdEEEEvv
   // DEMANGLED: call void @void dummy<wrapper4<double>{}>()()
   dummy<wrapper5<long long>{}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper5IxEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper5IxEEEEvv
   // DEMANGLED: call void @void dummy<wrapper5<long long>{}>()()
   dummy<wrapper6<int>{}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper6IiEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper6IiEEEEvv
   // DEMANGLED: call void @void dummy<wrapper6<int>{}>()()
 
   dummy<wrapper1<double>{123.0}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper1IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_ELd405ec00000000000EEEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper1IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_ELd405ec00000000000EEEEEEvv
   // DEMANGLED: call void @void dummy<wrapper1<double>{wrapper1<double>::'unnamed'{.RightName = wrapper1<double>::'unnamed'::'unnamed'{0x1.ec{{.*}}p+6}}}>()()
   dummy<wrapper2<double>{123.0}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper2IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_ELd405ec00000000000EEEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper2IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_ELd405ec00000000000EEEEEEvv
   // DEMANGLED: call void @void dummy<wrapper2<double>{wrapper2<double>::'unnamed'{.RightName = wrapper2<double>::'unnamed'::'unnamed'{0x1.ec{{.*}}p+6}}}>()()
   dummy<wrapper3<double>{123, 456}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper3IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_Etl4BaseLi123EELd407c800000000000EEEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper3IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_Etl4BaseLi123EELd407c800000000000EEEEEEvv
   // DEMANGLED: call void @void dummy<wrapper3<double>{wrapper3<double>::'unnamed'{.RightName = wrapper3<double>::'unnamed'::'unnamed'{Base{123}, 0x1.c8{{.*}}p+8}}}>()()
   dummy<wrapper4<double>{123}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper4IdEtlNS1_Ut_Edi9RightNameLi123EEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper4IdEtlNS1_Ut_Edi9RightNameLi123EEEEEvv
   // DEMANGLED: call void @void dummy<wrapper4<double>{wrapper4<double>::'unnamed'{.RightName = 123}}>()()
   dummy<wrapper5<double>{123.0, 456.0}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper5IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_EtlNS3_Ut_ELd405ec00000000000EELd407c800000000000EEEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper5IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_EtlNS3_Ut_ELd405ec00000000000EELd407c800000000000EEEEEEvv
   // DEMANGLED: call void @void dummy<wrapper5<double>{wrapper5<double>::'unnamed'{.RightName = wrapper5<double>::'unnamed'::'unnamed'{wrapper5<double>::'unnamed'::'unnamed'::'unnamed'{0x1.ec{{.*}}p+6}, 0x1.c8{{.*}}p+8}}}>()()
   dummy<wrapper6<double>{1}>();
-  // CHECK: call void @_Z5dummyIXtl8wrapper6IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_Edi9RightNameLd3ff0000000000000EEEEEEvv
+  // CHECK: call void @_Z5dummyITnDaXtl8wrapper6IdEtlNS1_Ut_Edi9RightNametlNS2_Ut_Edi9RightNameLd3ff0000000000000EEEEEEvv
   // DEMANGELD: call void @void dummy<wrapper6<double>{wrapper6<double>::'unnamed'{.RightName = wrapper6<double>::'unnamed'::'unnamed'{.RightName = 0x1{{.*}}p+0}}}>()()   
 }

clang/test/CodeGenCXX/mangle-requires.cpp

+// RUN: %clang_cc1 -verify -std=c++2a -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
+// expected-no-diagnostics
+
+template <typename T, int N> concept SmallerThan = sizeof(T) < N;
+template <typename T> concept Small = SmallerThan<T, 1000>;
+
+template <typename T> struct X { using type = T; };
+
+template <typename T> void f(int n) requires requires {
+  // simple-requirement
+  T();
+  n;
+  n == T();
+  // compound-requirement
+  {T() + 1} -> Small;
+  {T() - 1} noexcept;
+  {T() * 2} noexcept -> SmallerThan<1234>;
+  // type-requirement
+  typename T;
+  typename X<T>;
+  typename X<T>::type;
+  typename X<decltype(n)>;
+  // nested-requirement
+  requires SmallerThan<T, 256>;
+} {}
+// CHECK: define {{.*}}@_Z1fIiEviQrqXcvT__EXfp_Xeqfp_cvS0__EXplcvS0__ELi1ER5SmallXmicvS0__ELi1ENXmlcvS0__ELi2ENR11SmallerThanILi1234EETS0_T1XIS0_ETNS3_4typeETS2_IiEQ11SmallerThanIS0_Li256EEE(
+template void f<int>(int);
+
+template <typename T> void g(int n) requires requires (T m) {
+  // reference to our parameter vs an enclosing parameter
+  n + m;
+} {}
+// CHECK: define {{.*}}@_Z1gIiEviQrQT__XplfL0p_fp_E(
+template void g<int>(int);

clang/test/CodeGenCXX/mangle-template.cpp

 }
 
 namespace test12 {
   // Make sure we can mangle non-type template args with internal linkage.
   static int f() {}
   const int n = 10;
   template<typename T, T v> void test() {}
   void use() {
-    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIFivEXadL_ZNS_L1fEvEEEEvv(
+    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIFivETnT_XadL_ZNS_L1fEvEEEEvv(
     test<int(), &f>();
-    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIRFivEL_ZNS_L1fEvEEEvv(
+    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIRFivETnT_L_ZNS_L1fEvEEEvv(
     test<int(&)(), f>();
-    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIPKiXadL_ZNS_L1nEEEEEvv(
+    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIPKiTnT_XadL_ZNS_L1nEEEEEvv(
     test<const int*, &n>();
-    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIRKiL_ZNS_L1nEEEEvv(
+    // CHECK-LABEL: define internal {{.*}}void @_ZN6test124testIRKiTnT_L_ZNS_L1nEEEEvv(
     test<const int&, n>();
   }
 }
 
 // Test the boundary condition of minimal signed integers.
 namespace test13 {
   template <char c> char returnChar() { return c; }
   template char returnChar<-128>();

clang/test/CodeGenCXX/matrix-type.cpp

 template <auto R>
 void foo(matrix<int, R, 10> &m) {
 }
 
 void test_auto_t() {
   // CHECK-LABEL: define{{.*}} void @_Z11test_auto_tv()
   // CHECK-NEXT:  entry:
   // CHECK-NEXT:    %m = alloca [130 x i32], align 4
-  // CHECK-NEXT:    call void @_Z3fooILm13EEvRu11matrix_typeIXT_ELm10EiE(ptr nonnull align 4 dereferenceable(520) %m)
+  // CHECK-NEXT:    call void @_Z3fooITnDaLm13EEvRu11matrix_typeIXT_ELm10EiE(ptr nonnull align 4 dereferenceable(520) %m)
   // CHECK-NEXT:    ret void
 
-  // CHECK-LABEL: define linkonce_odr void @_Z3fooILm13EEvRu11matrix_typeIXT_ELm10EiE(ptr nonnull align 4 dereferenceable(520) %m)
+  // CHECK-LABEL: define linkonce_odr void @_Z3fooITnDaLm13EEvRu11matrix_typeIXT_ELm10EiE(ptr nonnull align 4 dereferenceable(520) %m)
   // CHECK-NEXT:  entry:
   // CHECK-NEXT:    %m.addr = alloca ptr, align 8
   // CHECK-NEXT:    store ptr %m, ptr %m.addr, align 8
   // CHECK-NEXT:    ret void
 
   matrix<int, 13, 10> m;
   foo(m);
 }

clang/test/OpenMP/tile_codegen.cpp

 // CHECK1:       omp.loop.exit:
 // CHECK1-NEXT:    call void @__kmpc_for_static_fini(ptr @[[GLOB1]], i32 [[TMP1]])
 // CHECK1-NEXT:    ret void
 //
 //
 // CHECK1-LABEL: define {{[^@]+}}@tfoo7
 // CHECK1-SAME: () #[[ATTR0]] {
 // CHECK1-NEXT:  entry:
-// CHECK1-NEXT:    call void @_Z4foo7IiLi3ELi5EEvT_S0_(i32 noundef 0, i32 noundef 42)
+// CHECK1-NEXT:    call void @_Z4foo7IiTnT_Li3ETnS0_Li5EEvS0_S0_(i32 noundef 0, i32 noundef 42)
 // CHECK1-NEXT:    ret void
 //
 //
-// CHECK1-LABEL: define {{[^@]+}}@_Z4foo7IiLi3ELi5EEvT_S0_
+// CHECK1-LABEL: define {{[^@]+}}@_Z4foo7IiTnT_Li3ETnS0_Li5EEvS0_S0_
 // CHECK1-SAME: (i32 noundef [[START:%.*]], i32 noundef [[END:%.*]]) #[[ATTR0]] comdat {
 // CHECK1-NEXT:  entry:
 // CHECK1-NEXT:    [[START_ADDR:%.*]] = alloca i32, align 4
 // CHECK1-NEXT:    [[END_ADDR:%.*]] = alloca i32, align 4
 // CHECK1-NEXT:    [[I:%.*]] = alloca i32, align 4
 // CHECK1-NEXT:    [[DOTCAPTURE_EXPR_:%.*]] = alloca i32, align 4
 // CHECK1-NEXT:    [[DOTCAPTURE_EXPR_1:%.*]] = alloca i32, align 4
 // CHECK1-NEXT:    [[DOTCAPTURE_EXPR_2:%.*]] = alloca i32, align 4

 // CHECK2:       omp.loop.exit:
 // CHECK2-NEXT:    call void @__kmpc_for_static_fini(ptr @[[GLOB1]], i32 [[TMP1]])
 // CHECK2-NEXT:    ret void
 //
 //
 // CHECK2-LABEL: define {{[^@]+}}@tfoo7
 // CHECK2-SAME: () #[[ATTR2]] {
 // CHECK2-NEXT:  entry:
-// CHECK2-NEXT:    call void @_Z4foo7IiLi3ELi5EEvT_S0_(i32 noundef 0, i32 noundef 42)
+// CHECK2-NEXT:    call void @_Z4foo7IiTnT_Li3ETnS0_Li5EEvS0_S0_(i32 noundef 0, i32 noundef 42)
 // CHECK2-NEXT:    ret void
 //
 //
-// CHECK2-LABEL: define {{[^@]+}}@_Z4foo7IiLi3ELi5EEvT_S0_
+// CHECK2-LABEL: define {{[^@]+}}@_Z4foo7IiTnT_Li3ETnS0_Li5EEvS0_S0_
 // CHECK2-SAME: (i32 noundef [[START:%.*]], i32 noundef [[END:%.*]]) #[[ATTR2]] comdat {
 // CHECK2-NEXT:  entry:
 // CHECK2-NEXT:    [[START_ADDR:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[END_ADDR:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[I:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[DOTCAPTURE_EXPR_:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[DOTCAPTURE_EXPR_1:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[DOTCAPTURE_EXPR_2:%.*]] = alloca i32, align 4

libcxxabi/src/demangle/ItaniumDemangle.h

public:
   }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
   void pop_back() {
     assert(Last != First && "Popping empty vector!");
     --Last;
   }
 
-  void dropBack(size_t Index) {
-    assert(Index <= size() && "dropBack() can't expand!");
+  void shrinkToSize(size_t Index) {
+    assert(Index <= size() && "shrinkToSize() can't expand!");
     Last = First + Index;
   }
 
   T *begin() { return First; }
   T *end() { return Last; }
 
   bool empty() const { return First == Last; }
   size_t size() const { return static_cast<size_t>(Last - First); }
public:
   }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
   const Node *Name;
   NodeArray Params;
   const Node *Attrs;
+  const Node *Requires;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
 
 public:
   FunctionEncoding(const Node *Ret_, const Node *Name_, NodeArray Params_,
-                   const Node *Attrs_, Qualifiers CVQuals_,
-                   FunctionRefQual RefQual_)
+                   const Node *Attrs_, const Node *Requires_,
+                   Qualifiers CVQuals_, FunctionRefQual RefQual_)
       : Node(KFunctionEncoding,
              /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
-        CVQuals(CVQuals_), RefQual(RefQual_) {}
+        Requires(Requires_), CVQuals(CVQuals_), RefQual(RefQual_) {}
 
   template<typename Fn> void match(Fn F) const {
-    F(Ret, Name, Params, Attrs, CVQuals, RefQual);
+    F(Ret, Name, Params, Attrs, Requires, CVQuals, RefQual);
   }
 
   Qualifiers getCVQuals() const { return CVQuals; }
   FunctionRefQual getRefQual() const { return RefQual; }
   NodeArray getParams() const { return Params; }
   const Node *getReturnType() const { return Ret; }
 
   bool hasRHSComponentSlow(OutputBuffer &) const override { return true; }
void printRight(OutputBuffer &OB) const override {
 
     if (RefQual == FrefQualLValue)
       OB += " &";
     else if (RefQual == FrefQualRValue)
       OB += " &&";
 
     if (Attrs != nullptr)
       Attrs->print(OB);
+
+    if (Requires != nullptr) {
+      OB += " requires ";
+      Requires->print(OB);
+    }
   }
 };
 
 class LiteralOperator : public Node {
   const Node *OpName;
 
 public:
   LiteralOperator(const Node *OpName_)
struct NestedName : Node {
 
   void printLeft(OutputBuffer &OB) const override {
     Qual->print(OB);
     OB += "::";
     Name->print(OB);
   }
 };
 
+struct MemberLikeFriendName : Node {
+  Node *Qual;
+  Node *Name;
+
+  MemberLikeFriendName(Node *Qual_, Node *Name_)
+      : Node(KMemberLikeFriendName), Qual(Qual_), Name(Name_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Qual, Name); }
+
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    Qual->print(OB);
+    OB += "::friend ";
+    Name->print(OB);
+  }
+};
+
 struct ModuleName : Node {
   ModuleName *Parent;
   Node *Name;
   bool IsPartition;
 
   ModuleName(ModuleName *Parent_, Node *Name_, bool IsPartition_ = false)
       : Node(KModuleName), Parent(Parent_), Name(Name_),
         IsPartition(IsPartition_) {}
case TemplateParamKind::Template:
       OB += "$TT";
       break;
     }
     if (Index > 0)
       OB << Index - 1;
   }
 };
 
+class TemplateParamQualifiedArg final : public Node {
+  Node *Param;
+  Node *Arg;
+
+public:
+  TemplateParamQualifiedArg(Node *Param_, Node *Arg_)
+      : Node(KTemplateParamQualifiedArg), Param(Param_), Arg(Arg_) {}
+
+  template <typename Fn> void match(Fn F) const { F(Param, Arg); }
+
+  Node *getArg() { return Arg; }
+
+  void printLeft(OutputBuffer &OB) const override {
+    // Don't print Param to keep the output consistent.
+    Arg->print(OB);
+  }
+};
+
 /// A template type parameter declaration, 'typename T'.
 class TypeTemplateParamDecl final : public Node {
   Node *Name;
 
 public:
   TypeTemplateParamDecl(Node *Name_)
       : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
   void printLeft(OutputBuffer &OB) const override { OB += "typename "; }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
 };
 
+/// A constrained template type parameter declaration, 'C<U> T'.
+class ConstrainedTypeTemplateParamDecl final : public Node {
+  Node *Constraint;
+  Node *Name;
+
+public:
+  ConstrainedTypeTemplateParamDecl(Node *Constraint_, Node *Name_)
+      : Node(KConstrainedTypeTemplateParamDecl, Cache::Yes),
+        Constraint(Constraint_), Name(Name_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Constraint, Name); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    Constraint->print(OB);
+    OB += " ";
+  }
+
+  void printRight(OutputBuffer &OB) const override { Name->print(OB); }
+};
+
 /// A non-type template parameter declaration, 'int N'.
 class NonTypeTemplateParamDecl final : public Node {
   Node *Name;
   Node *Type;
 
 public:
   NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
       : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
public:
   }
 };
 
 /// A template template parameter declaration,
 /// 'template<typename T> typename N'.
 class TemplateTemplateParamDecl final : public Node {
   Node *Name;
   NodeArray Params;
+  Node *Requires;
 
 public:
-  TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
+  TemplateTemplateParamDecl(Node *Name_, NodeArray Params_, Node *Requires_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
-        Params(Params_) {}
+        Params(Params_), Requires(Requires_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Name, Params); }
+  template <typename Fn> void match(Fn F) const { F(Name, Params, Requires); }
 
   void printLeft(OutputBuffer &OB) const override {
     ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
-  void printRight(OutputBuffer &OB) const override { Name->print(OB); }
+  void printRight(OutputBuffer &OB) const override {
+    Name->print(OB);
+    if (Requires != nullptr) {
+      OB += " requires ";
+      Requires->print(OB);
+    }
+  }
 };
 
 /// A template parameter pack declaration, 'typename ...T'.
 class TemplateParamPackDecl final : public Node {
   Node *Param;
 
 public:
   TemplateParamPackDecl(Node *Param_)
void printRight(OutputBuffer &OB) const override {
     size_t Idx = OB.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printRight(OB);
   }
 };
 
 /// A variadic template argument. This node represents an occurrence of
 /// J<something>E in some <template-args>. It isn't itself unexpanded, unless
-/// one of it's Elements is. The parser inserts a ParameterPack into the
+/// one of its Elements is. The parser inserts a ParameterPack into the
 /// TemplateParams table if the <template-args> this pack belongs to apply to an
 /// <encoding>.
 class TemplateArgumentPack final : public Node {
   NodeArray Elements;
 public:
   TemplateArgumentPack(NodeArray Elements_)
       : Node(KTemplateArgumentPack), Elements(Elements_) {}
 
for (unsigned I = 1, E = OB.CurrentPackMax; I < E; ++I) {
       OB.CurrentPackIndex = I;
       Child->print(OB);
     }
   }
 };
 
 class TemplateArgs final : public Node {
   NodeArray Params;
+  Node *Requires;
 
 public:
-  TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
+  TemplateArgs(NodeArray Params_, Node *Requires_)
+      : Node(KTemplateArgs), Params(Params_), Requires(Requires_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Params); }
+  template<typename Fn> void match(Fn F) const { F(Params, Requires); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
     ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     OB += ">";
+    // Don't print the requires clause to keep the output simple.
   }
 };
 
 /// A forward-reference to a template argument that was not known at the point
 /// where the template parameter name was parsed in a mangling.
 ///
 /// This is created when demangling the name of a specialization of a
 /// conversion function template:
void printLeft(OutputBuffer &OB) const override {
     OB += "'unnamed";
     OB += Count;
     OB += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
+  const Node *Requires1;
   NodeArray Params;
+  const Node *Requires2;
   std::string_view Count;
 
 public:
-  ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
+  ClosureTypeName(NodeArray TemplateParams_, const Node *Requires1_,
+                  NodeArray Params_, const Node *Requires2_,
                   std::string_view Count_)
       : Node(KClosureTypeName), TemplateParams(TemplateParams_),
-        Params(Params_), Count(Count_) {}
+        Requires1(Requires1_), Params(Params_), Requires2(Requires2_),
+        Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
-    F(TemplateParams, Params, Count);
+    F(TemplateParams, Requires1, Params, Requires2, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
     if (!TemplateParams.empty()) {
       ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       TemplateParams.printWithComma(OB);
       OB += ">";
     }
+    if (Requires1 != nullptr) {
+      OB += " requires ";
+      Requires1->print(OB);
+      OB += " ";
+    }
     OB.printOpen();
     Params.printWithComma(OB);
     OB.printClose();
+    if (Requires2 != nullptr) {
+      OB += " requires ";
+      Requires2->print(OB);
+    }
   }
 
   void printLeft(OutputBuffer &OB) const override {
+    // FIXME: This demangling is not particularly readable.
     OB += "\'lambda";
     OB += Count;
     OB += "\'";
     printDeclarator(OB);
   }
 };
 
 class StructuredBindingName : public Node {
void printLeft(OutputBuffer &OB) const override {
     else
       OB += Value;
 
     if (Type.size() <= 3)
       OB += Type;
   }
 };
 
+class RequiresExpr : public Node {
+  NodeArray Parameters;
+  NodeArray Requirements;
+public:
+  RequiresExpr(NodeArray Parameters_, NodeArray Requirements_)
+      : Node(KRequiresExpr), Parameters(Parameters_),
+        Requirements(Requirements_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Parameters, Requirements); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += "requires";
+    if (!Parameters.empty()) {
+      OB += ' ';
+      OB.printOpen();
+      Parameters.printWithComma(OB);
+      OB.printClose();
+    }
+    OB += ' ';
+    OB.printOpen('{');
+    for (const Node *Req : Requirements) {
+      Req->print(OB);
+    }
+    OB += ' ';
+    OB.printClose('}');
+  }
+};
+
+class ExprRequirement : public Node {
+  const Node *Expr;
+  bool IsNoexcept;
+  const Node *TypeConstraint;
+public:
+  ExprRequirement(const Node *Expr_, bool IsNoexcept_,
+                  const Node *TypeConstraint_)
+      : Node(KExprRequirement), Expr(Expr_), IsNoexcept(IsNoexcept_),
+        TypeConstraint(TypeConstraint_) {}
+
+  template <typename Fn> void match(Fn F) const {
+    F(Expr, IsNoexcept, TypeConstraint);
+  }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += " ";
+    if (IsNoexcept || TypeConstraint)
+      OB.printOpen('{');
+    Expr->print(OB);
+    if (IsNoexcept || TypeConstraint)
+      OB.printClose('}');
+    if (IsNoexcept)
+      OB += " noexcept";
+    if (TypeConstraint) {
+      OB += " -> ";
+      TypeConstraint->print(OB);
+    }
+    OB += ';';
+  }
+};
+
+class TypeRequirement : public Node {
+  const Node *Type;
+public:
+  TypeRequirement(const Node *Type_)
+      : Node(KTypeRequirement), Type(Type_) {}
+
+  template <typename Fn> void match(Fn F) const { F(Type); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += " typename ";
+    Type->print(OB);
+    OB += ';';
+  }
+};
+
+class NestedRequirement : public Node {
+  const Node *Constraint;
+public:
+  NestedRequirement(const Node *Constraint_)
+      : Node(KNestedRequirement), Constraint(Constraint_) {}
+
+  template <typename Fn> void match(Fn F) const { F(Constraint); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += " requires ";
+    Constraint->print(OB);
+    OB += ';';
+  }
+};
+
 template <class Float> struct FloatData;
 
 namespace float_literal_impl {
 constexpr Node::Kind getFloatLiteralKind(float *) {
   return Node::KFloatLiteral;
 }
 constexpr Node::Kind getFloatLiteralKind(double *) {
   return Node::KDoubleLiteral;
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   // the AST. Once the parser is finished, names.size() == 1.
   PODSmallVector<Node *, 32> Names;
 
   // Substitution table. Itanium supports name substitutions as a means of
   // compression. The string "S42_" refers to the 44nd entry (base-36) in this
   // table.
   PODSmallVector<Node *, 32> Subs;
 
+  // A list of template argument values corresponding to a template parameter
+  // list.
   using TemplateParamList = PODSmallVector<Node *, 8>;
 
   class ScopedTemplateParamList {
     AbstractManglingParser *Parser;
     size_t OldNumTemplateParamLists;
     TemplateParamList Params;
 
   public:
     ScopedTemplateParamList(AbstractManglingParser *TheParser)
         : Parser(TheParser),
           OldNumTemplateParamLists(TheParser->TemplateParams.size()) {
       Parser->TemplateParams.push_back(&Params);
     }
     ~ScopedTemplateParamList() {
       assert(Parser->TemplateParams.size() >= OldNumTemplateParamLists);
-      Parser->TemplateParams.dropBack(OldNumTemplateParamLists);
+      Parser->TemplateParams.shrinkToSize(OldNumTemplateParamLists);
     }
+    TemplateParamList *params() { return &Params; }
   };
 
   // Template parameter table. Like the above, but referenced like "T42_".
   // This has a smaller size compared to Subs and Names because it can be
   // stored on the stack.
   TemplateParamList OuterTemplateParams;
 
   // Lists of template parameters indexed by template parameter depth,
   // referenced like "TL2_4_". If nonempty, element 0 is always
   // OuterTemplateParams; inner elements are always template parameter lists of
   // lambda expressions. For a generic lambda with no explicit template
   // parameter list, the corresponding parameter list pointer will be null.
   PODSmallVector<TemplateParamList *, 4> TemplateParams;
 
+  class SaveTemplateParams {
+    AbstractManglingParser *Parser;
+    decltype(TemplateParams) OldParams;
+    decltype(OuterTemplateParams) OldOuterParams;
+
+  public:
+    SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
+      OldParams = std::move(Parser->TemplateParams);
+      OldOuterParams = std::move(Parser->OuterTemplateParams);
+      Parser->TemplateParams.clear();
+      Parser->OuterTemplateParams.clear();
+    }
+    ~SaveTemplateParams() {
+      Parser->TemplateParams = std::move(OldParams);
+      Parser->OuterTemplateParams = std::move(OldOuterParams);
+    }
+  };
+
   // Set of unresolved forward <template-param> references. These can occur in a
   // conversion operator's type, and are resolved in the enclosing <encoding>.
   PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
 
   bool TryToParseTemplateArgs = true;
   bool PermitForwardTemplateReferences = false;
+  bool InConstraintExpr = false;
   size_t ParsingLambdaParamsAtLevel = (size_t)-1;
 
   unsigned NumSyntheticTemplateParameters[3] = {};
 
   Alloc ASTAllocator;
 
   AbstractManglingParser(const char *First_, const char *Last_)
       : First(First_), Last(Last_) {}
template <class It> NodeArray makeNodeArray(It begin, It end) {
     std::copy(begin, end, data);
     return NodeArray(data, sz);
   }
 
   NodeArray popTrailingNodeArray(size_t FromPosition) {
     assert(FromPosition <= Names.size());
     NodeArray res =
         makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
-    Names.dropBack(FromPosition);
+    Names.shrinkToSize(FromPosition);
     return res;
   }
 
   bool consumeIf(std::string_view S) {
     if (starts_with(std::string_view(First, Last - First), S)) {
       First += S.size();
       return true;
     }
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   std::string_view parseNumber(bool AllowNegative = false);
   Qualifiers parseCVQualifiers();
   bool parsePositiveInteger(size_t *Out);
   std::string_view parseBareSourceName();
 
   bool parseSeqId(size_t *Out);
   Node *parseSubstitution();
   Node *parseTemplateParam();
-  Node *parseTemplateParamDecl();
+  Node *parseTemplateParamDecl(TemplateParamList *Params);
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
-  /// Parse the <expr> production.
+  bool isTemplateParamDecl() {
+    return look() == 'T' &&
+           std::string_view("yptnk").find(look(1)) != std::string_view::npos;
+  }
+
+  /// Parse the <expression> production.
   Node *parseExpr();
   Node *parsePrefixExpr(std::string_view Kind, Node::Prec Prec);
   Node *parseBinaryExpr(std::string_view Kind, Node::Prec Prec);
   Node *parseIntegerLiteral(std::string_view Lit);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
   Node *parsePointerToMemberConversionExpr(Node::Prec Prec);
   Node *parseSubobjectExpr();
+  Node *parseConstraintExpr();
+  Node *parseRequiresExpr();
 
   /// Parse the <type> production.
   Node *parseType();
   Node *parseFunctionType();
   Node *parseVectorType();
   Node *parseDecltype();
   Node *parseArrayType();
   Node *parsePointerToMemberType();
bool resolveForwardTemplateRefs(NameState &State) {
     size_t E = ForwardTemplateRefs.size();
     for (; I < E; ++I) {
       size_t Idx = ForwardTemplateRefs[I]->Index;
       if (TemplateParams.empty() || !TemplateParams[0] ||
           Idx >= TemplateParams[0]->size())
         return true;
       ForwardTemplateRefs[I]->Ref = (*TemplateParams[0])[Idx];
     }
-    ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
+    ForwardTemplateRefs.shrinkToSize(State.ForwardTemplateRefsBegin);
     return false;
   }
 
   /// Parse the <name> production>
   Node *parseName(NameState *State = nullptr);
   Node *parseLocalName(NameState *State);
   Node *parseOperatorName(NameState *State);
   bool parseModuleNameOpt(ModuleName *&Module);
Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
   if (consumeIf('s')) {
     First = parse_discriminator(First, Last);
     auto *StringLitName = make<NameType>("string literal");
     if (!StringLitName)
       return nullptr;
     return make<LocalName>(Encoding, StringLitName);
   }
 
+  // The template parameters of the inner name are unrelated to those of the
+  // enclosing context.
+  SaveTemplateParams SaveTemplateParamsScope(this);
+
   if (consumeIf('d')) {
     parseNumber(true);
     if (!consumeIf('_'))
       return nullptr;
     Node *N = getDerived().parseName(State);
     if (N == nullptr)
       return nullptr;
     return make<LocalName>(Encoding, N);
AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State,
 
   if (Res == nullptr || Std != nullptr) {
     Res = getDerived().parseUnqualifiedName(State, Std, Module);
   }
 
   return Res;
 }
 
-// <unqualified-name> ::= [<module-name>] L? <operator-name> [<abi-tags>]
+// <unqualified-name> ::= [<module-name>] F? L? <operator-name> [<abi-tags>]
 //                    ::= [<module-name>] <ctor-dtor-name> [<abi-tags>]
-//                    ::= [<module-name>] L? <source-name> [<abi-tags>]
+//                    ::= [<module-name>] F? L? <source-name> [<abi-tags>]
 //                    ::= [<module-name>] L? <unnamed-type-name> [<abi-tags>]
 //      # structured binding declaration
 //                    ::= [<module-name>] L? DC <source-name>+ E
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(
     NameState *State, Node *Scope, ModuleName *Module) {
   if (getDerived().parseModuleNameOpt(Module))
     return nullptr;
 
+  bool IsMemberLikeFriend = Scope && consumeIf('F');
+
   consumeIf('L');
 
   Node *Result;
   if (look() >= '1' && look() <= '9') {
     Result = getDerived().parseSourceName(State);
   } else if (look() == 'U') {
     Result = getDerived().parseUnnamedTypeName(State);
   } else if (consumeIf("DC")) {
Node *AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(
   } else {
     Result = getDerived().parseOperatorName(State);
   }
 
   if (Result != nullptr && Module != nullptr)
     Result = make<ModuleEntity>(Module, Result);
   if (Result != nullptr)
     Result = getDerived().parseAbiTags(Result);
-  if (Result != nullptr && Scope != nullptr)
+  if (Result != nullptr && IsMemberLikeFriend)
+    Result = make<MemberLikeFriendName>(Scope, Result);
+  else if (Result != nullptr && Scope != nullptr)
     Result = make<NestedName>(Scope, Result);
 
   return Result;
 }
 
 // <module-name> ::= <module-subname>
 //     ::= <module-name> <module-subname>
 //     ::= <substitution>  # passed in by caller
bool AbstractManglingParser<Derived, Alloc>::parseModuleNameOpt(
   return false;
 }
 
 // <unnamed-type-name> ::= Ut [<nonnegative number>] _
 //                     ::= <closure-type-name>
 //
 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
 //
-// <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
+// <lambda-sig> ::= <template-param-decl>* [Q <requires-clause expression>]
+//                  <parameter type>+  # or "v" if the lambda has no parameters
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
   // <template-params> refer to the innermost <template-args>. Clear out any
   // outer args that we may have inserted into TemplateParams.
   if (State != nullptr)
     TemplateParams.clear();
 
   if (consumeIf("Ut")) {
     std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<UnnamedTypeName>(Count);
   }
   if (consumeIf("Ul")) {
     ScopedOverride<size_t> SwapParams(ParsingLambdaParamsAtLevel,
                                       TemplateParams.size());
     ScopedTemplateParamList LambdaTemplateParams(this);
 
     size_t ParamsBegin = Names.size();
-    while (look() == 'T' &&
-           std::string_view("yptn").find(look(1)) != std::string_view::npos) {
-      Node *T = parseTemplateParamDecl();
-      if (!T)
+    while (getDerived().isTemplateParamDecl()) {
+      Node *T =
+          getDerived().parseTemplateParamDecl(LambdaTemplateParams.params());
+      if (T == nullptr)
         return nullptr;
       Names.push_back(T);
     }
     NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
 
     // FIXME: If TempParams is empty and none of the function parameters
     // includes 'auto', we should remove LambdaTemplateParams from the
     // TemplateParams list. Unfortunately, we don't find out whether there are
if (consumeIf("Ul")) {
     // need to support it here.
     //
     // If we encounter an 'auto' in the function parameter types, we will
     // recreate a template parameter scope for it, but any intervening lambdas
     // will be parsed in the 'wrong' template parameter depth.
     if (TempParams.empty())
       TemplateParams.pop_back();
 
-    if (!consumeIf("vE")) {
+    Node *Requires1 = nullptr;
+    if (consumeIf('Q')) {
+      Requires1 = getDerived().parseConstraintExpr();
+      if (Requires1 == nullptr)
+        return nullptr;
+    }
+
+    if (!consumeIf("v")) {
       do {
         Node *P = getDerived().parseType();
         if (P == nullptr)
           return nullptr;
         Names.push_back(P);
-      } while (!consumeIf('E'));
+      } while (look() != 'E' && look() != 'Q');
     }
     NodeArray Params = popTrailingNodeArray(ParamsBegin);
 
+    Node *Requires2 = nullptr;
+    if (consumeIf('Q')) {
+      Requires2 = getDerived().parseConstraintExpr();
+      if (Requires2 == nullptr)
+        return nullptr;
+    }
+
+    if (!consumeIf('E'))
+      return nullptr;
+
     std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
-    return make<ClosureTypeName>(TempParams, Params, Count);
+    return make<ClosureTypeName>(TempParams, Requires1, Params, Requires2,
+                                 Count);
   }
   if (consumeIf("Ub")) {
     (void)parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<NameType>("'block-literal'");
   }
   return nullptr;
case 'D':
     //                ::= Da   # auto (in dependent new-expressions)
     case 'a':
       First += 2;
       return make<NameType>("auto");
     //                ::= Dc   # decltype(auto)
     case 'c':
       First += 2;
       return make<NameType>("decltype(auto)");
+    //                ::= Dk <type-constraint> # constrained auto
+    //                ::= DK <type-constraint> # constrained decltype(auto)
+    case 'k':
+    case 'K': {
+      std::string_view Kind = look(1) == 'k' ? " auto" : " decltype(auto)";
+      First += 2;
+      Node *Constraint = getDerived().parseName();
+      if (!Constraint)
+        return nullptr;
+      return make<PostfixQualifiedType>(Constraint, Kind);
+    }
     //                ::= Dn   # std::nullptr_t (i.e., decltype(nullptr))
     case 'n':
       First += 2;
       return make<NameType>("std::nullptr_t");
 
     //             ::= <decltype>
     case 't':
     case 'T': {
Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
   }
   bool OnePastTheEnd = consumeIf('p');
   if (!consumeIf('E'))
     return nullptr;
   return make<SubobjectExpr>(
       Ty, Expr, Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
 }
 
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseConstraintExpr() {
+  // Within this expression, all enclosing template parameter lists are in
+  // scope.
+  ScopedOverride<bool> SaveInConstraintExpr(InConstraintExpr, true);
+  return getDerived().parseExpr();
+}
+
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseRequiresExpr() {
+  NodeArray Params;
+  if (consumeIf("rQ")) {
+    // <expression> ::= rQ <bare-function-type> _ <requirement>+ E
+    size_t ParamsBegin = Names.size();
+    while (!consumeIf('_')) {
+      Node *Type = getDerived().parseType();
+      if (Type == nullptr)
+        return nullptr;
+      Names.push_back(Type);
+    }
+    Params = popTrailingNodeArray(ParamsBegin);
+  } else if (!consumeIf("rq")) {
+    // <expression> ::= rq <requirement>+ E
+    return nullptr;
+  }
+
+  size_t ReqsBegin = Names.size();
+  do {
+    Node *Constraint = nullptr;
+    if (consumeIf('X')) {
+      // <requirement> ::= X <expression> [N] [R <type-constraint>]
+      Node *Expr = getDerived().parseExpr();
+      if (Expr == nullptr)
+        return nullptr;
+      bool Noexcept = consumeIf('N');
+      Node *TypeReq = nullptr;
+      if (consumeIf('R')) {
+        TypeReq = getDerived().parseName();
+        if (TypeReq == nullptr)
+          return nullptr;
+      }
+      Constraint = make<ExprRequirement>(Expr, Noexcept, TypeReq);
+    } else if (consumeIf('T')) {
+      // <requirement> ::= T <type>
+      Node *Type = getDerived().parseType();
+      if (Type == nullptr)
+        return nullptr;
+      Constraint = make<TypeRequirement>(Type);
+    } else if (consumeIf('Q')) {
+      // <requirement> ::= Q <constraint-expression>
+      //
+      // FIXME: We use <expression> instead of <constraint-expression>. Either
+      // the requires expression is already inside a constraint expression, in
+      // which case it makes no difference, or we're in a requires-expression
+      // that might be partially-substituted, where the language behavior is
+      // not yet settled and clang mangles after substitution.
+      Node *NestedReq = getDerived().parseExpr();
+      if (NestedReq == nullptr)
+        return nullptr;
+      Constraint = make<NestedRequirement>(NestedReq);
+    }
+    if (Constraint == nullptr)
+      return nullptr;
+    Names.push_back(Constraint);
+  } while (!consumeIf('E'));
+
+  return make<RequiresExpr>(Params, popTrailingNodeArray(ReqsBegin));
+}
+
 // <expression> ::= <unary operator-name> <expression>
 //              ::= <binary operator-name> <expression> <expression>
 //              ::= <ternary operator-name> <expression> <expression> <expression>
 //              ::= cl <expression>+ E                                   # call
 //              ::= cv <type> <expression>                               # conversion with one argument
 //              ::= cv <type> _ <expression>* E                          # conversion with a different number of arguments
 //              ::= [gs] nw <expression>* _ <type> E                     # new (expr-list) type
 //              ::= [gs] nw <expression>* _ <type> <initializer>         # new (expr-list) type (init)
Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
   if (consumeIf("mc"))
     return parsePointerToMemberConversionExpr(Node::Prec::Unary);
   if (consumeIf("nx")) {
     Node *Ex = getDerived().parseExpr();
     if (Ex == nullptr)
       return Ex;
     return make<EnclosingExpr>("noexcept ", Ex, Node::Prec::Unary);
   }
+  if (look() == 'r' && (look(1) == 'q' || look(1) == 'Q'))
+    return parseRequiresExpr();
   if (consumeIf("so"))
     return parseSubobjectExpr();
   if (consumeIf("sp")) {
     Node *Child = getDerived().parseExpr();
     if (Child == nullptr)
       return nullptr;
     return make<ParameterPackExpansion>(Child);
   }
case 'I': {
       return make<SpecialName>("initializer for module ", Module);
     }
     }
   }
   return nullptr;
 }
 
 // <encoding> ::= <function name> <bare-function-type>
+//                    [`Q` <requires-clause expr>]
 //            ::= <data name>
 //            ::= <special-name>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
   // The template parameters of an encoding are unrelated to those of the
   // enclosing context.
-  class SaveTemplateParams {
-    AbstractManglingParser *Parser;
-    decltype(TemplateParams) OldParams;
-    decltype(OuterTemplateParams) OldOuterParams;
-
-  public:
-    SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
-      OldParams = std::move(Parser->TemplateParams);
-      OldOuterParams = std::move(Parser->OuterTemplateParams);
-      Parser->TemplateParams.clear();
-      Parser->OuterTemplateParams.clear();
-    }
-    ~SaveTemplateParams() {
-      Parser->TemplateParams = std::move(OldParams);
-      Parser->OuterTemplateParams = std::move(OldOuterParams);
-    }
-  } SaveTemplateParams(this);
+  SaveTemplateParams SaveTemplateParamsScope(this);
 
   if (look() == 'G' || look() == 'T')
     return getDerived().parseSpecialName();
 
   auto IsEndOfEncoding = [&] {
     // The set of chars that can potentially follow an <encoding> (none of which
     // can start a <type>). Enumerating these allows us to avoid speculative
     // parsing.
Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
 
   Node *ReturnType = nullptr;
   if (!NameInfo.CtorDtorConversion && NameInfo.EndsWithTemplateArgs) {
     ReturnType = getDerived().parseType();
     if (ReturnType == nullptr)
       return nullptr;
   }
 
-  if (consumeIf('v'))
-    return make<FunctionEncoding>(ReturnType, Name, NodeArray(),
-                                  Attrs, NameInfo.CVQualifiers,
-                                  NameInfo.ReferenceQualifier);
-
+  NodeArray Params;
+  if (!consumeIf('v')) {
     size_t ParamsBegin = Names.size();
     do {
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return nullptr;
       Names.push_back(Ty);
-  } while (!IsEndOfEncoding());
+    } while (!IsEndOfEncoding() && look() != 'Q');
+    Params = popTrailingNodeArray(ParamsBegin);
+  }
+
+  Node *Requires = nullptr;
+  if (consumeIf('Q')) {
+    Requires = getDerived().parseConstraintExpr();
+    if (!Requires)
+      return nullptr;
+  }
 
-  return make<FunctionEncoding>(ReturnType, Name,
-                                popTrailingNodeArray(ParamsBegin),
-                                Attrs, NameInfo.CVQualifiers,
+  return make<FunctionEncoding>(ReturnType, Name, Params, Attrs, Requires,
+                                NameInfo.CVQualifiers,
                                 NameInfo.ReferenceQualifier);
 }
 
 template <class Float>
 struct FloatData;
 
 template <>
 struct FloatData<float>

 }
 
 // <template-param> ::= T_    # first template parameter
 //                  ::= T <parameter-2 non-negative number> _
 //                  ::= TL <level-1> __
 //                  ::= TL <level-1> _ <parameter-2 non-negative number> _
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
+  const char *Begin = First;
   if (!consumeIf('T'))
     return nullptr;
 
   size_t Level = 0;
   if (consumeIf('L')) {
     if (parsePositiveInteger(&Level))
       return nullptr;
     ++Level;
     if (!consumeIf('_'))
       return nullptr;
   }
 
   size_t Index = 0;
   if (!consumeIf('_')) {
     if (parsePositiveInteger(&Index))
       return nullptr;
     ++Index;
     if (!consumeIf('_'))
       return nullptr;
   }
 
+  // We don't track enclosing template parameter levels well enough to reliably
+  // substitute them all within a <constraint-expression>, so print the
+  // parameter numbering instead for now.
+  // TODO: Track all enclosing template parameters and substitute them here.
+  if (InConstraintExpr) {
+    return make<NameType>(std::string_view(Begin, First - 1 - Begin));
+  }
+
   // If we're in a context where this <template-param> refers to a
   // <template-arg> further ahead in the mangled name (currently just conversion
   // operator types), then we should only look it up in the right context.
   // This can only happen at the outermost level.
   if (PermitForwardTemplateReferences && Level == 0) {
     Node *ForwardRef = make<ForwardTemplateReference>(Index);
     if (!ForwardRef)
       return nullptr;
Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
   return (*TemplateParams[Level])[Index];
 }
 
 // <template-param-decl> ::= Ty                          # type parameter
 //                       ::= Tn <type>                   # non-type parameter
 //                       ::= Tt <template-param-decl>* E # template parameter
 //                       ::= Tp <template-param-decl>    # parameter pack
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl() {
+Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl(
+    TemplateParamList *Params) {
   auto InventTemplateParamName = [&](TemplateParamKind Kind) {
     unsigned Index = NumSyntheticTemplateParameters[(int)Kind]++;
     Node *N = make<SyntheticTemplateParamName>(Kind, Index);
-    if (N) TemplateParams.back()->push_back(N);
+    if (N && Params)
+      Params->push_back(N);
     return N;
   };
 
   if (consumeIf("Ty")) {
     Node *Name = InventTemplateParamName(TemplateParamKind::Type);
     if (!Name)
       return nullptr;
     return make<TypeTemplateParamDecl>(Name);
   }
 
+  if (consumeIf("Tk")) {
+    Node *Constraint = getDerived().parseName();
+    if (!Constraint)
+      return nullptr;
+    Node *Name = InventTemplateParamName(TemplateParamKind::Type);
+    if (!Name)
+      return nullptr;
+    return make<ConstrainedTypeTemplateParamDecl>(Constraint, Name);
+  }
+
   if (consumeIf("Tn")) {
     Node *Name = InventTemplateParamName(TemplateParamKind::NonType);
     if (!Name)
       return nullptr;
     Node *Type = parseType();
     if (!Type)
       return nullptr;
     return make<NonTypeTemplateParamDecl>(Name, Type);
   }
 
   if (consumeIf("Tt")) {
     Node *Name = InventTemplateParamName(TemplateParamKind::Template);
     if (!Name)
       return nullptr;
     size_t ParamsBegin = Names.size();
     ScopedTemplateParamList TemplateTemplateParamParams(this);
-    while (!consumeIf("E")) {
-      Node *P = parseTemplateParamDecl();
+    Node *Requires = nullptr;
+    while (!consumeIf('E')) {
+      Node *P = parseTemplateParamDecl(TemplateTemplateParamParams.params());
       if (!P)
         return nullptr;
       Names.push_back(P);
+      if (consumeIf('Q')) {
+        Requires = getDerived().parseConstraintExpr();
+        if (Requires == nullptr || !consumeIf('E'))
+          return nullptr;
+        break;
       }
-    NodeArray Params = popTrailingNodeArray(ParamsBegin);
-    return make<TemplateTemplateParamDecl>(Name, Params);
+    }
+    NodeArray InnerParams = popTrailingNodeArray(ParamsBegin);
+    return make<TemplateTemplateParamDecl>(Name, InnerParams, Requires);
   }
 
   if (consumeIf("Tp")) {
-    Node *P = parseTemplateParamDecl();
+    Node *P = parseTemplateParamDecl(Params);
     if (!P)
       return nullptr;
     return make<TemplateParamPackDecl>(P);
   }
 
   return nullptr;
 }
 
 // <template-arg> ::= <type>                    # type or template
 //                ::= X <expression> E          # expression
 //                ::= <expr-primary>            # simple expressions
 //                ::= J <template-arg>* E       # argument pack
 //                ::= LZ <encoding> E           # extension
+//                ::= <template-param-decl> <template-arg>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseTemplateArg() {
   switch (look()) {
   case 'X': {
     ++First;
     Node *Arg = getDerived().parseExpr();
     if (Arg == nullptr || !consumeIf('E'))
       return nullptr;
if (look(1) == 'Z') {
       Node *Arg = getDerived().parseEncoding();
       if (Arg == nullptr || !consumeIf('E'))
         return nullptr;
       return Arg;
     }
     //                ::= <expr-primary>            # simple expressions
     return getDerived().parseExprPrimary();
   }
+  case 'T': {
+    // Either <template-param> or a <template-param-decl> <template-arg>.
+    if (!getDerived().isTemplateParamDecl())
+      return getDerived().parseType();
+    Node *Param = getDerived().parseTemplateParamDecl(nullptr);
+    if (!Param)
+      return nullptr;
+    Node *Arg = getDerived().parseTemplateArg();
+    if (!Arg)
+      return nullptr;
+    return make<TemplateParamQualifiedArg>(Param, Arg);
+  }
   default:
     return getDerived().parseType();
   }
 }
 
 // <template-args> ::= I <template-arg>* E
 //     extension, the abi says <template-arg>+
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseTemplateArgs(bool TagTemplates) {
   if (!consumeIf('I'))
     return nullptr;
 
   // <template-params> refer to the innermost <template-args>. Clear out any
   // outer args that we may have inserted into TemplateParams.
   if (TagTemplates) {
     TemplateParams.clear();
     TemplateParams.push_back(&OuterTemplateParams);
     OuterTemplateParams.clear();
   }
 
   size_t ArgsBegin = Names.size();
+  Node *Requires = nullptr;
   while (!consumeIf('E')) {
     if (TagTemplates) {
-      auto OldParams = std::move(TemplateParams);
       Node *Arg = getDerived().parseTemplateArg();
-      TemplateParams = std::move(OldParams);
       if (Arg == nullptr)
         return nullptr;
       Names.push_back(Arg);
       Node *TableEntry = Arg;
+      if (Arg->getKind() == Node::KTemplateParamQualifiedArg) {
+        TableEntry =
+            static_cast<TemplateParamQualifiedArg *>(TableEntry)->getArg();
+      }
       if (Arg->getKind() == Node::KTemplateArgumentPack) {
         TableEntry = make<ParameterPack>(
             static_cast<TemplateArgumentPack*>(TableEntry)->getElements());
         if (!TableEntry)
           return nullptr;
       }
-      TemplateParams.back()->push_back(TableEntry);
+      OuterTemplateParams.push_back(TableEntry);
     } else {
       Node *Arg = getDerived().parseTemplateArg();
       if (Arg == nullptr)
         return nullptr;
       Names.push_back(Arg);
     }
+    if (consumeIf('Q')) {
+      Requires = getDerived().parseConstraintExpr();
+      if (!Requires || !consumeIf('E'))
+        return nullptr;
+      break;
+    }
   }
-  return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin));
+  return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin), Requires);
 }
 
 // <mangled-name> ::= _Z <encoding>
 //                ::= <type>
 // extension      ::= ___Z <encoding> _block_invoke
 // extension      ::= ___Z <encoding> _block_invoke<decimal-digit>+
 // extension      ::= ___Z <encoding> _block_invoke_<decimal-digit>+
 template <typename Derived, typename Alloc>

libcxxabi/src/demangle/ItaniumNodes.def

 NODE(NoexceptSpec)
 NODE(DynamicExceptionSpec)
 NODE(FunctionEncoding)
 NODE(LiteralOperator)
 NODE(SpecialName)
 NODE(CtorVtableSpecialName)
 NODE(QualifiedName)
 NODE(NestedName)
+NODE(MemberLikeFriendName)
 NODE(LocalName)
 NODE(ModuleName)
 NODE(ModuleEntity)
 NODE(VectorType)
 NODE(PixelVectorType)
 NODE(BinaryFPType)
 NODE(BitIntType)
 NODE(SyntheticTemplateParamName)
+NODE(TemplateParamQualifiedArg)
 NODE(TypeTemplateParamDecl)
+NODE(ConstrainedTypeTemplateParamDecl)
 NODE(NonTypeTemplateParamDecl)
 NODE(TemplateTemplateParamDecl)
 NODE(TemplateParamPackDecl)
 NODE(ParameterPack)
 NODE(TemplateArgumentPack)
 NODE(ParameterPackExpansion)
 NODE(TemplateArgs)
 NODE(ForwardTemplateReference)

 NODE(LambdaExpr)
 NODE(EnumLiteral)
 NODE(IntegerLiteral)
 NODE(FloatLiteral)
 NODE(DoubleLiteral)
 NODE(LongDoubleLiteral)
 NODE(BracedExpr)
 NODE(BracedRangeExpr)
+NODE(RequiresExpr)
+NODE(ExprRequirement)
+NODE(TypeRequirement)
+NODE(NestedRequirement)
 
 #undef NODE

libcxxabi/test/test_demangle.pass.cpp

//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
 
     // Legacy nonstandard mangling for __uuidof.
     {"_Z15test_uuidofTypeI10TestStructEvDTu8__uuidoftT_E", "void test_uuidofType<TestStruct>(decltype(__uuidof(TestStruct)))"},
     {"_Z15test_uuidofExprI9HasMemberEvDTu8__uuidofXsrT_6memberEEE", "void test_uuidofExpr<HasMember>(decltype(__uuidof(HasMember::member)))"},
     // Current __uuidof mangling using vendor extended expression.
     {"_Z15test_uuidofTypeI10TestStructEvDTu8__uuidofT_EE", "void test_uuidofType<TestStruct>(decltype(__uuidof(TestStruct)))"},
     {"_Z15test_uuidofExprI9HasMemberEvDTu8__uuidofXsrT_6memberEEE", "void test_uuidofExpr<HasMember>(decltype(__uuidof(HasMember::member)))"},
 
-    // C++2a char8_t:
+    // C++20 char8_t:
     {"_ZTSPDu", "typeinfo name for char8_t*"},
 
-    // C++2a lambda-expressions:
+    // C++20 lambda-expressions:
     {"_ZNK1xMUlTyT_E_clIiEEDaS_", "auto x::'lambda'<typename $T>($T)::operator()<int>(x) const"},
     {"_ZNK1xMUlTnPA3_ivE_clILS0_0EEEDav", "auto x::'lambda'<int (*$N) [3]>()::operator()<(int [3])0>() const"},
     {"_ZNK1xMUlTyTtTyTnT_TpTnPA3_TL0__ETpTyvE_clIi1XJfEEEDav", "auto x::'lambda'<typename $T, template<typename $T0, $T $N, $T0 (*...$N0) [3]> typename $TT, typename ...$T1>()::operator()<int, X, float>() const"},
     {"_ZN1AIiE1fIfEEvDTLUlTyTtTyTnTL1__ETL0_1_T_TL0__E_EE", "void A<int>::f<float>(decltype([]<typename $T, template<typename $T0, $T0 $N> typename $TT>(auto, float, $T){...}))"},
     {"_ZN1S1fILb1EEEv1XILUlvE_EE", "void S::f<true>(X<[](){...}>)"},
     {"_ZN1S1fILb1EEEv1XILUlvE0_EE", "void S::f<true>(X<[](){...}>)"},
     // FIXME: Consider special-casing the call operator of a lambda and
     // producing something like
     //   "auto inline_func()::'lambda'<int, int>(int, int) const"
     {"_ZZ11inline_funcvENKUlTyTyT_T0_E_clIiiEEDaS_S0_", "auto inline_func()::'lambda'<typename $T, typename $T0>($T, $T0)::operator()<int, int>($T, $T0) const"},
     {"_ZZ11inline_funcvENKUlTyTyT_T1_T0_E_clIiiiEEDaS_S0_S1_", "auto inline_func()::'lambda'<typename $T, typename $T0>($T, auto, $T0)::operator()<int, int, int>($T, auto, $T0) const"},
     {"_ZN1XIZ1fIiEvOT_EUlOT_DpT0_E_EclIJEEEvDpT_", "void X<void f<int>(int&&)::'lambda'(auto&&, auto...)>::operator()<>()"},
     // FIXME: This is wrong, should demangle to the same as the previous entry.
     // See https://github.com/itanium-cxx-abi/cxx-abi/issues/106.
     {"_ZN1XIZ1fIiEvOT_EUlS2_DpT0_E_EclIJEEEvDpT_", "void X<void f<int>(int&&)::'lambda'(int&&, auto...)>::operator()<>()"},
     {"_ZZZZN6abcdef9abcdefghi29abcdefabcdefabcdefabcefabcdef27xxxxxxxxxxxxxxxxxxxxxxxxxxxEN4absl8DurationERKNSt3__u12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS1_19yyyyyyyyyyyyyyyyyyyEENK3$_5clEvENKUlvE_clEvE6zzzzzz", "abcdef::abcdefghi::abcdefabcdefabcdefabcefabcdef::xxxxxxxxxxxxxxxxxxxxxxxxxxx(absl::Duration, std::__u::basic_string<char, std::__u::char_traits<char>, std::__u::allocator<char>> const&, abcdef::abcdefghi::abcdefabcdefabcdefabcefabcdef::yyyyyyyyyyyyyyyyyyy*)::$_5::operator()() const::'lambda'()::operator()() const::zzzzzz"},
+    // See https://github.com/itanium-cxx-abi/cxx-abi/issues/165.
+    {"_ZN1C1fIiEEvDTtlNS_UlT_TL0__E_EEE", "void C::f<int>(decltype(C::'lambda'(int, auto){}))"},
 
-    // C++2a class type non-type template parameters:
+    // C++20 class type non-type template parameters:
     {"_Z1fIXtl1BLPi0ELi1EEEEvv", "void f<B{(int*)0, 1}>()"},
     {"_Z1fIXtl1BLPi32EEEEvv", "void f<B{(int*)32}>()"},
     {"_Z1fIXtl1BrcPiLi0EEEEvv", "void f<B{reinterpret_cast<int*>(0)}>()"},
     {"_Z1fIXtl1BadsoiL_Z6nestedE_EEEEvv", "void f<B{&nested.<int at offset 0>}>()"},
     {"_Z1fIXtl1BadsoiL_Z6nestedE16_0pEEEEvv", "void f<B{&nested.<int at offset 16>}>()"},
     {"_Z1fIXtl2BRsoiL_Z7derivedE4EEEEvv", "void f<BR{derived.<int at offset 4>}>()"},
     {"_Z1fIXtl1BcvPiplcvPcadL_Z7derivedELl16EEEEvv", "void f<B{(int*)((char*)(&derived) + 16l)}>()"},
     {"_Z1fIXtl1CadsoKiL_Z7derivedE4EEEEvv", "void f<C{&derived.<int const at offset 4>}>()"},
//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     {"_ZN1NW3FooDC1a1bEE", "N::[a, b]@Foo"},
     {"_ZN3NMSW3MOD3FooB3ABIEv", "NMS::Foo@MOD[abi:ABI]()"},
     {"_ZGIW3Foo", "initializer for module Foo"},
     {"_ZGIW3FooW3Bar", "initializer for module Foo.Bar"},
     {"_ZGIW3FooWP3BarW3Baz", "initializer for module Foo:Bar.Baz"},
     {"_ZW1ML4Oink", "Oink@M"},
     {"_ZW1ML1fi", "f@M(int)"},
 
+    // C++20 concepts, see https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+    {"_Z2f0IiE1SIX1CIT_EEEv", "S<C<int>> f0<int>()"},
+    {"_ZN5test21AIiEF1fEzQ4TrueIT_E", "test2::A<int>::friend f(...) requires True<T>"},
+    {"_ZN5test2F1gIvEEvzQaa4TrueIT_E4TrueITL0__E", "void test2::friend g<void>(...) requires True<T> && True<TL0_>"},
+    {"_ZN5test21hIvEEvzQ4TrueITL0__E", "void test2::h<void>(...) requires True<TL0_>"},
+    {"_ZN5test2F1iIvQaa4TrueIT_E4TrueITL0__EEEvz", "void test2::friend i<void>(...)"},
+    {"_ZN5test21jIvQ4TrueITL0__EEEvz", "void test2::j<void>(...)"},
+    {"_ZN5test2F1kITk4TruevQ4TrueIT_EEEvz", "void test2::friend k<void>(...)"},
+    {"_ZN5test21lITk4TruevEEvz", "void test2::l<void>(...)"},
+    {"_ZN5test31dITnDaLi0EEEvv", "void test3::d<0>()"},
+    {"_ZN5test31eITnDcLi0EEEvv", "void test3::e<0>()"},
+    {"_ZN5test31fITnDk1CLi0EEEvv", "void test3::f<0>()"},
+    {"_ZN5test31gITnDk1DIiELi0EEEvv", "void test3::g<0>()"},
+    {"_ZN5test31hIiTnDk1DIT_ELi0EEEvv", "void test3::h<int, 0>()"},
+    {"_ZN5test31iIiEEvDTnw_Dk1CpicvT__EEE", "void test3::i<int>(decltype(new C auto((int)())))"},
+    {"_ZN5test31jIiEEvDTnw_DK1CpicvT__EEE", "void test3::j<int>(decltype(new C decltype(auto)((int)())))"},
+    {"_ZN5test41fITk1CiEEvv", "void test4::f<int>()"},
+    {"_ZN5test41gITk1DIiEiEEvv", "void test4::g<int>()"},
+    {"_ZN5test51fINS_1XEEEvv", "void test5::f<test5::X>()"},
+    {"_ZN5test51fITtTyTnTL0__ENS_1YEEEvv", "void test5::f<test5::Y>()"},
+    {"_ZN5test51fITtTyTnTL0__ENS_1ZEEEvv", "void test5::f<test5::Z>()"},
+    {"_ZN5test51gITtTyTnTL0__Q1CIS1_EENS_1XEEEvv", "void test5::g<test5::X>()"},
+    {"_ZN5test51gINS_1YEEEvv", "void test5::g<test5::Y>()"},
+    {"_ZN5test51gITtTyTnTL0__Q1CIS1_EENS_1ZEEEvv", "void test5::g<test5::Z>()"},
+    {"_ZN5test51hITtTk1CTnTL0__ENS_1XEEEvv", "void test5::h<test5::X>()"},
+    {"_ZN5test51hITtTk1CTnTL0__ENS_1YEEEvv", "void test5::h<test5::Y>()"},
+    {"_ZN5test51hINS_1ZEEEvv", "void test5::h<test5::Z>()"},
+    {"_ZN5test51iITpTtTk1CTnTL0__EJNS_1XENS_1YENS_1ZEEEEvv", "void test5::i<test5::X, test5::Y, test5::Z>()"},
+    {"_ZN5test51iITpTtTk1CTnTL0__EJNS_1YENS_1ZENS_1XEEEEvv", "void test5::i<test5::Y, test5::Z, test5::X>()"},
+    {"_ZN5test51iIJNS_1ZENS_1XENS_1YEEEEvv", "void test5::i<test5::Z, test5::X, test5::Y>()"},
+    {"_ZN5test51pINS_1AEEEvv", "void test5::p<test5::A>()"},
+    {"_ZN5test51pITtTpTyENS_1BEEEvv", "void test5::p<test5::B>()"},
+    {"_ZN5test51qITtTyTyENS_1AEEEvv", "void test5::q<test5::A>()"},
+    {"_ZN5test51qINS_1BEEEvv", "void test5::q<test5::B>()"},
+    {"_ZN5test61fITk1CiEEvT_", "void test6::f<int>(int)"},
+    {"_ZN5test61gIiTk1DIT_EiEEvT0_", "void test6::g<int, int>(int)"},
+    {"_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E_clIiiEEDaS3_Q1CIDtfp_EE", "auto void test7::f<int>()::'lambda'<typename $T> requires C<T> && C<TL0_> (auto)::operator()<int, int>(auto) const requires C<decltype(fp)>"},
+    {"_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E0_clIiiEEDaS3_Qaa1CIDtfp_EELb1E", "auto void test7::f<int>()::'lambda0'<typename $T> requires C<T> && C<TL0_> (auto)::operator()<int, int>(auto) const requires C<decltype(fp)> && true"},
+    {"_ZZN5test71fIiEEvvENKUlTyQaa1CIT_E1CITL0__ET0_E1_clIiiEEDaS3_Q1CIDtfp_EE", "auto void test7::f<int>()::'lambda1'<typename $T> requires C<T> && C<TL0_> (auto)::operator()<int, int>(auto) const requires C<decltype(fp)>"},
+    {"_ZZN5test71fIiEEvvENKUlTyT0_E_clIiiEEDaS1_", "auto void test7::f<int>()::'lambda'<typename $T>(auto)::operator()<int, int>(auto) const"},
+
+    // C++20 requires expressions, see https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+    {"_Z1fIiEviQrqXcvT__EXfp_Xeqfp_cvS0__EXplcvS0__ELi1ER5SmallXmicvS0__ELi1ENXmlcvS0__ELi2ENR11SmallerThanILi1234EETS0_T1XIS0_ETNS3_4typeETS2_IiEQ11SmallerThanIS0_Li256EEE", "void f<int>(int) requires requires { (T)(); fp; fp == (T)(); {(T)() + 1} -> Small; {(T)() - 1} noexcept; {(T)() * 2} noexcept -> SmallerThan<1234>; typename T; typename X<T>; typename X<T>::type; typename X<int>; requires SmallerThan<T, 256>; }"},
+    {"_Z1gIiEviQrQT__XplfL0p_fp_E", "void g<int>(int) requires requires (T) { fp + fp; }"},
+
     // Special Substs a, b, d, i, o, s (not including std::)
     {"_Z1fSaIiE", "f(std::allocator<int>)"},
     {"_Z1fSbIiE", "f(std::basic_string<int>)"},
     {"_Z1fSd", "f(std::iostream)"},
     {"_Z1fSi", "f(std::istream)"},
     {"_Z1fSo", "f(std::ostream)"},
     {"_Z1fSs", "f(std::string)"},
     {"_Z1fNSaIiE1gE", "f(std::allocator<int>::g)"},

llvm/include/llvm/Demangle/ItaniumDemangle.h

 //===----------------------------------------------------------------------===//
 
 #ifndef DEMANGLE_ITANIUMDEMANGLE_H
 #define DEMANGLE_ITANIUMDEMANGLE_H
 
 #include "DemangleConfig.h"
 #include "StringViewExtras.h"
 #include "Utility.h"
+#include <__cxxabi_config.h>
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <new>
 #include <string_view>
 #include <type_traits>
 #include <utility>
 
+#ifdef _LIBCXXABI_COMPILER_CLANG
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-template"
+#endif
+
 DEMANGLE_NAMESPACE_BEGIN
 
 template <class T, size_t N> class PODSmallVector {
   static_assert(std::is_pod<T>::value,
                 "T is required to be a plain old data type");
 
   T *First = nullptr;
   T *Last = nullptr;
public:
   }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
   void pop_back() {
     assert(Last != First && "Popping empty vector!");
     --Last;
   }
 
-  void dropBack(size_t Index) {
-    assert(Index <= size() && "dropBack() can't expand!");
+  void shrinkToSize(size_t Index) {
+    assert(Index <= size() && "shrinkToSize() can't expand!");
     Last = First + Index;
   }
 
   T *begin() { return First; }
   T *end() { return Last; }
 
   bool empty() const { return First == Last; }
   size_t size() const { return static_cast<size_t>(Last - First); }
public:
   }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
   const Node *Name;
   NodeArray Params;
   const Node *Attrs;
+  const Node *Requires;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
 
 public:
   FunctionEncoding(const Node *Ret_, const Node *Name_, NodeArray Params_,
-                   const Node *Attrs_, Qualifiers CVQuals_,
-                   FunctionRefQual RefQual_)
+                   const Node *Attrs_, const Node *Requires_,
+                   Qualifiers CVQuals_, FunctionRefQual RefQual_)
       : Node(KFunctionEncoding,
              /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
-        CVQuals(CVQuals_), RefQual(RefQual_) {}
+        Requires(Requires_), CVQuals(CVQuals_), RefQual(RefQual_) {}
 
   template<typename Fn> void match(Fn F) const {
-    F(Ret, Name, Params, Attrs, CVQuals, RefQual);
+    F(Ret, Name, Params, Attrs, Requires, CVQuals, RefQual);
   }
 
   Qualifiers getCVQuals() const { return CVQuals; }
   FunctionRefQual getRefQual() const { return RefQual; }
   NodeArray getParams() const { return Params; }
   const Node *getReturnType() const { return Ret; }
 
   bool hasRHSComponentSlow(OutputBuffer &) const override { return true; }
void printRight(OutputBuffer &OB) const override {
 
     if (RefQual == FrefQualLValue)
       OB += " &";
     else if (RefQual == FrefQualRValue)
       OB += " &&";
 
     if (Attrs != nullptr)
       Attrs->print(OB);
+
+    if (Requires != nullptr) {
+      OB += " requires ";
+      Requires->print(OB);
+    }
   }
 };
 
 class LiteralOperator : public Node {
   const Node *OpName;
 
 public:
   LiteralOperator(const Node *OpName_)
struct NestedName : Node {
 
   void printLeft(OutputBuffer &OB) const override {
     Qual->print(OB);
     OB += "::";
     Name->print(OB);
   }
 };
 
+struct MemberLikeFriendName : Node {
+  Node *Qual;
+  Node *Name;
+
+  MemberLikeFriendName(Node *Qual_, Node *Name_)
+      : Node(KMemberLikeFriendName), Qual(Qual_), Name(Name_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Qual, Name); }
+
+  std::string_view getBaseName() const override { return Name->getBaseName(); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    Qual->print(OB);
+    OB += "::friend ";
+    Name->print(OB);
+  }
+};
+
 struct ModuleName : Node {
   ModuleName *Parent;
   Node *Name;
   bool IsPartition;
 
   ModuleName(ModuleName *Parent_, Node *Name_, bool IsPartition_ = false)
       : Node(KModuleName), Parent(Parent_), Name(Name_),
         IsPartition(IsPartition_) {}
case TemplateParamKind::Template:
       OB += "$TT";
       break;
     }
     if (Index > 0)
       OB << Index - 1;
   }
 };
 
+class TemplateParamQualifiedArg final : public Node {
+  Node *Param;
+  Node *Arg;
+
+public:
+  TemplateParamQualifiedArg(Node *Param_, Node *Arg_)
+      : Node(KTemplateParamQualifiedArg), Param(Param_), Arg(Arg_) {}
+
+  template <typename Fn> void match(Fn F) const { F(Param, Arg); }
+
+  Node *getArg() { return Arg; }
+
+  void printLeft(OutputBuffer &OB) const override {
+    // Don't print Param to keep the output consistent.
+    Arg->print(OB);
+  }
+};
+
 /// A template type parameter declaration, 'typename T'.
 class TypeTemplateParamDecl final : public Node {
   Node *Name;
 
 public:
   TypeTemplateParamDecl(Node *Name_)
       : Node(KTypeTemplateParamDecl, Cache::Yes), Name(Name_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name); }
 
   void printLeft(OutputBuffer &OB) const override { OB += "typename "; }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
 };
 
+/// A constrained template type parameter declaration, 'C<U> T'.
+class ConstrainedTypeTemplateParamDecl final : public Node {
+  Node *Constraint;
+  Node *Name;
+
+public:
+  ConstrainedTypeTemplateParamDecl(Node *Constraint_, Node *Name_)
+      : Node(KConstrainedTypeTemplateParamDecl, Cache::Yes),
+        Constraint(Constraint_), Name(Name_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Constraint, Name); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    Constraint->print(OB);
+    OB += " ";
+  }
+
+  void printRight(OutputBuffer &OB) const override { Name->print(OB); }
+};
+
 /// A non-type template parameter declaration, 'int N'.
 class NonTypeTemplateParamDecl final : public Node {
   Node *Name;
   Node *Type;
 
 public:
   NonTypeTemplateParamDecl(Node *Name_, Node *Type_)
       : Node(KNonTypeTemplateParamDecl, Cache::Yes), Name(Name_), Type(Type_) {}
public:
   }
 };
 
 /// A template template parameter declaration,
 /// 'template<typename T> typename N'.
 class TemplateTemplateParamDecl final : public Node {
   Node *Name;
   NodeArray Params;
+  Node *Requires;
 
 public:
-  TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
+  TemplateTemplateParamDecl(Node *Name_, NodeArray Params_, Node *Requires_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
-        Params(Params_) {}
+        Params(Params_), Requires(Requires_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Name, Params); }
+  template <typename Fn> void match(Fn F) const { F(Name, Params, Requires); }
 
   void printLeft(OutputBuffer &OB) const override {
     ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
-  void printRight(OutputBuffer &OB) const override { Name->print(OB); }
+  void printRight(OutputBuffer &OB) const override {
+    Name->print(OB);
+    if (Requires != nullptr) {
+      OB += " requires ";
+      Requires->print(OB);
+    }
+  }
 };
 
 /// A template parameter pack declaration, 'typename ...T'.
 class TemplateParamPackDecl final : public Node {
   Node *Param;
 
 public:
   TemplateParamPackDecl(Node *Param_)
void printRight(OutputBuffer &OB) const override {
     size_t Idx = OB.CurrentPackIndex;
     if (Idx < Data.size())
       Data[Idx]->printRight(OB);
   }
 };
 
 /// A variadic template argument. This node represents an occurrence of
 /// J<something>E in some <template-args>. It isn't itself unexpanded, unless
-/// one of it's Elements is. The parser inserts a ParameterPack into the
+/// one of its Elements is. The parser inserts a ParameterPack into the
 /// TemplateParams table if the <template-args> this pack belongs to apply to an
 /// <encoding>.
 class TemplateArgumentPack final : public Node {
   NodeArray Elements;
 public:
   TemplateArgumentPack(NodeArray Elements_)
       : Node(KTemplateArgumentPack), Elements(Elements_) {}
 
for (unsigned I = 1, E = OB.CurrentPackMax; I < E; ++I) {
       OB.CurrentPackIndex = I;
       Child->print(OB);
     }
   }
 };
 
 class TemplateArgs final : public Node {
   NodeArray Params;
+  Node *Requires;
 
 public:
-  TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
+  TemplateArgs(NodeArray Params_, Node *Requires_)
+      : Node(KTemplateArgs), Params(Params_), Requires(Requires_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Params); }
+  template<typename Fn> void match(Fn F) const { F(Params, Requires); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
     ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     OB += ">";
+    // Don't print the requires clause to keep the output simple.
   }
 };
 
 /// A forward-reference to a template argument that was not known at the point
 /// where the template parameter name was parsed in a mangling.
 ///
 /// This is created when demangling the name of a specialization of a
 /// conversion function template:
SpecialSubstitution(SpecialSubKind SSK_)
       : ExpandedSpecialSubstitution(SSK_, KSpecialSubstitution) {}
 
   template<typename Fn> void match(Fn F) const { F(SSK); }
 
   std::string_view getBaseName() const override {
     std::string_view SV = ExpandedSpecialSubstitution::getBaseName();
     if (isInstantiation()) {
       // The instantiations are typedefs that drop the "basic_" prefix.
-      assert(llvm::itanium_demangle::starts_with(SV, "basic_"));
+      assert(starts_with(SV, "basic_"));
       SV.remove_prefix(sizeof("basic_") - 1);
     }
     return SV;
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB << "std::" << getBaseName();
   }
void printLeft(OutputBuffer &OB) const override {
     OB += "'unnamed";
     OB += Count;
     OB += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
   NodeArray TemplateParams;
+  const Node *Requires1;
   NodeArray Params;
+  const Node *Requires2;
   std::string_view Count;
 
 public:
-  ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
+  ClosureTypeName(NodeArray TemplateParams_, const Node *Requires1_,
+                  NodeArray Params_, const Node *Requires2_,
                   std::string_view Count_)
       : Node(KClosureTypeName), TemplateParams(TemplateParams_),
-        Params(Params_), Count(Count_) {}
+        Requires1(Requires1_), Params(Params_), Requires2(Requires2_),
+        Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
-    F(TemplateParams, Params, Count);
+    F(TemplateParams, Requires1, Params, Requires2, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
     if (!TemplateParams.empty()) {
       ScopedOverride<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       TemplateParams.printWithComma(OB);
       OB += ">";
     }
+    if (Requires1 != nullptr) {
+      OB += " requires ";
+      Requires1->print(OB);
+      OB += " ";
+    }
     OB.printOpen();
     Params.printWithComma(OB);
     OB.printClose();
+    if (Requires2 != nullptr) {
+      OB += " requires ";
+      Requires2->print(OB);
+    }
   }
 
   void printLeft(OutputBuffer &OB) const override {
+    // FIXME: This demangling is not particularly readable.
     OB += "\'lambda";
     OB += Count;
     OB += "\'";
     printDeclarator(OB);
   }
 };
 
 class StructuredBindingName : public Node {
void printLeft(OutputBuffer &OB) const override {
     else
       OB += Value;
 
     if (Type.size() <= 3)
       OB += Type;
   }
 };
 
+class RequiresExpr : public Node {
+  NodeArray Parameters;
+  NodeArray Requirements;
+public:
+  RequiresExpr(NodeArray Parameters_, NodeArray Requirements_)
+      : Node(KRequiresExpr), Parameters(Parameters_),
+        Requirements(Requirements_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Parameters, Requirements); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += "requires";
+    if (!Parameters.empty()) {
+      OB += ' ';
+      OB.printOpen();
+      Parameters.printWithComma(OB);
+      OB.printClose();
+    }
+    OB += ' ';
+    OB.printOpen('{');
+    for (const Node *Req : Requirements) {
+      Req->print(OB);
+    }
+    OB += ' ';
+    OB.printClose('}');
+  }
+};
+
+class ExprRequirement : public Node {
+  const Node *Expr;
+  bool IsNoexcept;
+  const Node *TypeConstraint;
+public:
+  ExprRequirement(const Node *Expr_, bool IsNoexcept_,
+                  const Node *TypeConstraint_)
+      : Node(KExprRequirement), Expr(Expr_), IsNoexcept(IsNoexcept_),
+        TypeConstraint(TypeConstraint_) {}
+
+  template <typename Fn> void match(Fn F) const {
+    F(Expr, IsNoexcept, TypeConstraint);
+  }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += " ";
+    if (IsNoexcept || TypeConstraint)
+      OB.printOpen('{');
+    Expr->print(OB);
+    if (IsNoexcept || TypeConstraint)
+      OB.printClose('}');
+    if (IsNoexcept)
+      OB += " noexcept";
+    if (TypeConstraint) {
+      OB += " -> ";
+      TypeConstraint->print(OB);
+    }
+    OB += ';';
+  }
+};
+
+class TypeRequirement : public Node {
+  const Node *Type;
+public:
+  TypeRequirement(const Node *Type_)
+      : Node(KTypeRequirement), Type(Type_) {}
+
+  template <typename Fn> void match(Fn F) const { F(Type); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += " typename ";
+    Type->print(OB);
+    OB += ';';
+  }
+};
+
+class NestedRequirement : public Node {
+  const Node *Constraint;
+public:
+  NestedRequirement(const Node *Constraint_)
+      : Node(KNestedRequirement), Constraint(Constraint_) {}
+
+  template <typename Fn> void match(Fn F) const { F(Constraint); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += " requires ";
+    Constraint->print(OB);
+    OB += ';';
+  }
+};
+
 template <class Float> struct FloatData;
 
 namespace float_literal_impl {
 constexpr Node::Kind getFloatLiteralKind(float *) {
   return Node::KFloatLiteral;
 }
 constexpr Node::Kind getFloatLiteralKind(double *) {
   return Node::KDoubleLiteral;
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   // the AST. Once the parser is finished, names.size() == 1.
   PODSmallVector<Node *, 32> Names;
 
   // Substitution table. Itanium supports name substitutions as a means of
   // compression. The string "S42_" refers to the 44nd entry (base-36) in this
   // table.
   PODSmallVector<Node *, 32> Subs;
 
+  // A list of template argument values corresponding to a template parameter
+  // list.
   using TemplateParamList = PODSmallVector<Node *, 8>;
 
   class ScopedTemplateParamList {
     AbstractManglingParser *Parser;
     size_t OldNumTemplateParamLists;
     TemplateParamList Params;
 
   public:
     ScopedTemplateParamList(AbstractManglingParser *TheParser)
         : Parser(TheParser),
           OldNumTemplateParamLists(TheParser->TemplateParams.size()) {
       Parser->TemplateParams.push_back(&Params);
     }
     ~ScopedTemplateParamList() {
       assert(Parser->TemplateParams.size() >= OldNumTemplateParamLists);
-      Parser->TemplateParams.dropBack(OldNumTemplateParamLists);
+      Parser->TemplateParams.shrinkToSize(OldNumTemplateParamLists);
     }
+    TemplateParamList *params() { return &Params; }
   };
 
   // Template parameter table. Like the above, but referenced like "T42_".
   // This has a smaller size compared to Subs and Names because it can be
   // stored on the stack.
   TemplateParamList OuterTemplateParams;
 
   // Lists of template parameters indexed by template parameter depth,
   // referenced like "TL2_4_". If nonempty, element 0 is always
   // OuterTemplateParams; inner elements are always template parameter lists of
   // lambda expressions. For a generic lambda with no explicit template
   // parameter list, the corresponding parameter list pointer will be null.
   PODSmallVector<TemplateParamList *, 4> TemplateParams;
 
+  class SaveTemplateParams {
+    AbstractManglingParser *Parser;
+    decltype(TemplateParams) OldParams;
+    decltype(OuterTemplateParams) OldOuterParams;
+
+  public:
+    SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
+      OldParams = std::move(Parser->TemplateParams);
+      OldOuterParams = std::move(Parser->OuterTemplateParams);
+      Parser->TemplateParams.clear();
+      Parser->OuterTemplateParams.clear();
+    }
+    ~SaveTemplateParams() {
+      Parser->TemplateParams = std::move(OldParams);
+      Parser->OuterTemplateParams = std::move(OldOuterParams);
+    }
+  };
+
   // Set of unresolved forward <template-param> references. These can occur in a
   // conversion operator's type, and are resolved in the enclosing <encoding>.
   PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
 
   bool TryToParseTemplateArgs = true;
   bool PermitForwardTemplateReferences = false;
+  bool InConstraintExpr = false;
   size_t ParsingLambdaParamsAtLevel = (size_t)-1;
 
   unsigned NumSyntheticTemplateParameters[3] = {};
 
   Alloc ASTAllocator;
 
   AbstractManglingParser(const char *First_, const char *Last_)
       : First(First_), Last(Last_) {}
template <class It> NodeArray makeNodeArray(It begin, It end) {
     std::copy(begin, end, data);
     return NodeArray(data, sz);
   }
 
   NodeArray popTrailingNodeArray(size_t FromPosition) {
     assert(FromPosition <= Names.size());
     NodeArray res =
         makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
-    Names.dropBack(FromPosition);
+    Names.shrinkToSize(FromPosition);
     return res;
   }
 
   bool consumeIf(std::string_view S) {
-    if (llvm::itanium_demangle::starts_with(
-            std::string_view(First, Last - First), S)) {
+    if (starts_with(std::string_view(First, Last - First), S)) {
       First += S.size();
       return true;
     }
     return false;
   }
 
   bool consumeIf(char C) {
     if (First != Last && *First == C) {
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   std::string_view parseNumber(bool AllowNegative = false);
   Qualifiers parseCVQualifiers();
   bool parsePositiveInteger(size_t *Out);
   std::string_view parseBareSourceName();
 
   bool parseSeqId(size_t *Out);
   Node *parseSubstitution();
   Node *parseTemplateParam();
-  Node *parseTemplateParamDecl();
+  Node *parseTemplateParamDecl(TemplateParamList *Params);
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
-  /// Parse the <expr> production.
+  bool isTemplateParamDecl() {
+    return look() == 'T' &&
+           std::string_view("yptnk").find(look(1)) != std::string_view::npos;
+  }
+
+  /// Parse the <expression> production.
   Node *parseExpr();
   Node *parsePrefixExpr(std::string_view Kind, Node::Prec Prec);
   Node *parseBinaryExpr(std::string_view Kind, Node::Prec Prec);
   Node *parseIntegerLiteral(std::string_view Lit);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
   Node *parsePointerToMemberConversionExpr(Node::Prec Prec);
   Node *parseSubobjectExpr();
+  Node *parseConstraintExpr();
+  Node *parseRequiresExpr();
 
   /// Parse the <type> production.
   Node *parseType();
   Node *parseFunctionType();
   Node *parseVectorType();
   Node *parseDecltype();
   Node *parseArrayType();
   Node *parsePointerToMemberType();
bool resolveForwardTemplateRefs(NameState &State) {
     size_t E = ForwardTemplateRefs.size();
     for (; I < E; ++I) {
       size_t Idx = ForwardTemplateRefs[I]->Index;
       if (TemplateParams.empty() || !TemplateParams[0] ||
           Idx >= TemplateParams[0]->size())
         return true;
       ForwardTemplateRefs[I]->Ref = (*TemplateParams[0])[Idx];
     }
-    ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
+    ForwardTemplateRefs.shrinkToSize(State.ForwardTemplateRefsBegin);
     return false;
   }
 
   /// Parse the <name> production>
   Node *parseName(NameState *State = nullptr);
   Node *parseLocalName(NameState *State);
   Node *parseOperatorName(NameState *State);
   bool parseModuleNameOpt(ModuleName *&Module);
bool operator==(const char *Peek) const {
       return Enc[0] == Peek[0] && Enc[1] == Peek[1];
     }
     bool operator!=(const char *Peek) const { return !this->operator==(Peek); }
 
   public:
     std::string_view getSymbol() const {
       std::string_view Res = Name;
       if (Kind < Unnameable) {
-        assert(llvm::itanium_demangle::starts_with(Res, "operator") &&
+        assert(starts_with(Res, "operator") &&
                "operator name does not start with 'operator'");
         Res.remove_prefix(sizeof("operator") - 1);
-        if (llvm::itanium_demangle::starts_with(Res, ' '))
+        if (starts_with(Res, ' '))
           Res.remove_prefix(1);
       }
       return Res;
     }
     std::string_view getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
     Node::Prec getPrecedence() const { return Prec; }
Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
   if (consumeIf('s')) {
     First = parse_discriminator(First, Last);
     auto *StringLitName = make<NameType>("string literal");
     if (!StringLitName)
       return nullptr;
     return make<LocalName>(Encoding, StringLitName);
   }
 
+  // The template parameters of the inner name are unrelated to those of the
+  // enclosing context.
+  SaveTemplateParams SaveTemplateParamsScope(this);
+
   if (consumeIf('d')) {
     parseNumber(true);
     if (!consumeIf('_'))
       return nullptr;
     Node *N = getDerived().parseName(State);
     if (N == nullptr)
       return nullptr;
     return make<LocalName>(Encoding, N);
AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State,
 
   if (Res == nullptr || Std != nullptr) {
     Res = getDerived().parseUnqualifiedName(State, Std, Module);
   }
 
   return Res;
 }
 
-// <unqualified-name> ::= [<module-name>] L? <operator-name> [<abi-tags>]
+// <unqualified-name> ::= [<module-name>] F? L? <operator-name> [<abi-tags>]
 //                    ::= [<module-name>] <ctor-dtor-name> [<abi-tags>]
-//                    ::= [<module-name>] L? <source-name> [<abi-tags>]
+//                    ::= [<module-name>] F? L? <source-name> [<abi-tags>]
 //                    ::= [<module-name>] L? <unnamed-type-name> [<abi-tags>]
 //      # structured binding declaration
 //                    ::= [<module-name>] L? DC <source-name>+ E
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(
     NameState *State, Node *Scope, ModuleName *Module) {
   if (getDerived().parseModuleNameOpt(Module))
     return nullptr;
 
+  bool IsMemberLikeFriend = Scope && consumeIf('F');
+
   consumeIf('L');
 
   Node *Result;
   if (look() >= '1' && look() <= '9') {
     Result = getDerived().parseSourceName(State);
   } else if (look() == 'U') {
     Result = getDerived().parseUnnamedTypeName(State);
   } else if (consumeIf("DC")) {
Node *AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(
   } else {
     Result = getDerived().parseOperatorName(State);
   }
 
   if (Result != nullptr && Module != nullptr)
     Result = make<ModuleEntity>(Module, Result);
   if (Result != nullptr)
     Result = getDerived().parseAbiTags(Result);
-  if (Result != nullptr && Scope != nullptr)
+  if (Result != nullptr && IsMemberLikeFriend)
+    Result = make<MemberLikeFriendName>(Scope, Result);
+  else if (Result != nullptr && Scope != nullptr)
     Result = make<NestedName>(Scope, Result);
 
   return Result;
 }
 
 // <module-name> ::= <module-subname>
 //     ::= <module-name> <module-subname>
 //     ::= <substitution>  # passed in by caller
bool AbstractManglingParser<Derived, Alloc>::parseModuleNameOpt(
   return false;
 }
 
 // <unnamed-type-name> ::= Ut [<nonnegative number>] _
 //                     ::= <closure-type-name>
 //
 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
 //
-// <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
+// <lambda-sig> ::= <template-param-decl>* [Q <requires-clause expression>]
+//                  <parameter type>+  # or "v" if the lambda has no parameters
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *State) {
   // <template-params> refer to the innermost <template-args>. Clear out any
   // outer args that we may have inserted into TemplateParams.
   if (State != nullptr)
     TemplateParams.clear();
 
   if (consumeIf("Ut")) {
     std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<UnnamedTypeName>(Count);
   }
   if (consumeIf("Ul")) {
     ScopedOverride<size_t> SwapParams(ParsingLambdaParamsAtLevel,
                                       TemplateParams.size());
     ScopedTemplateParamList LambdaTemplateParams(this);
 
     size_t ParamsBegin = Names.size();
-    while (look() == 'T' &&
-           std::string_view("yptn").find(look(1)) != std::string_view::npos) {
-      Node *T = parseTemplateParamDecl();
-      if (!T)
+    while (getDerived().isTemplateParamDecl()) {
+      Node *T =
+          getDerived().parseTemplateParamDecl(LambdaTemplateParams.params());
+      if (T == nullptr)
         return nullptr;
       Names.push_back(T);
     }
     NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
 
     // FIXME: If TempParams is empty and none of the function parameters
     // includes 'auto', we should remove LambdaTemplateParams from the
     // TemplateParams list. Unfortunately, we don't find out whether there are
if (consumeIf("Ul")) {
     // need to support it here.
     //
     // If we encounter an 'auto' in the function parameter types, we will
     // recreate a template parameter scope for it, but any intervening lambdas
     // will be parsed in the 'wrong' template parameter depth.
     if (TempParams.empty())
       TemplateParams.pop_back();
 
-    if (!consumeIf("vE")) {
+    Node *Requires1 = nullptr;
+    if (consumeIf('Q')) {
+      Requires1 = getDerived().parseConstraintExpr();
+      if (Requires1 == nullptr)
+        return nullptr;
+    }
+
+    if (!consumeIf("v")) {
       do {
         Node *P = getDerived().parseType();
         if (P == nullptr)
           return nullptr;
         Names.push_back(P);
-      } while (!consumeIf('E'));
+      } while (look() != 'E' && look() != 'Q');
     }
     NodeArray Params = popTrailingNodeArray(ParamsBegin);
 
+    Node *Requires2 = nullptr;
+    if (consumeIf('Q')) {
+      Requires2 = getDerived().parseConstraintExpr();
+      if (Requires2 == nullptr)
+        return nullptr;
+    }
+
+    if (!consumeIf('E'))
+      return nullptr;
+
     std::string_view Count = parseNumber();
     if (!consumeIf('_'))
       return nullptr;
-    return make<ClosureTypeName>(TempParams, Params, Count);
+    return make<ClosureTypeName>(TempParams, Requires1, Params, Requires2,
+                                 Count);
   }
   if (consumeIf("Ub")) {
     (void)parseNumber();
     if (!consumeIf('_'))
       return nullptr;
     return make<NameType>("'block-literal'");
   }
   return nullptr;
 }
 
 // <source-name> ::= <positive length number> <identifier>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
   size_t Length = 0;
   if (parsePositiveInteger(&Length))
     return nullptr;
   if (numLeft() < Length || Length == 0)
     return nullptr;
   std::string_view Name(First, Length);
   First += Length;
-  if (llvm::itanium_demangle::starts_with(Name, "_GLOBAL__N"))
+  if (starts_with(Name, "_GLOBAL__N"))
     return make<NameType>("(anonymous namespace)");
   return make<NameType>(Name);
 }
 
 // Operator encodings
 template <typename Derived, typename Alloc>
 const typename AbstractManglingParser<
     Derived, Alloc>::OperatorInfo AbstractManglingParser<Derived,

 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseQualifiedType() {
   if (consumeIf('U')) {
     std::string_view Qual = parseBareSourceName();
     if (Qual.empty())
       return nullptr;
 
     // extension            ::= U <objc-name> <objc-type>  # objc-type<identifier>
-    if (llvm::itanium_demangle::starts_with(Qual, "objcproto")) {
+    if (starts_with(Qual, "objcproto")) {
       constexpr size_t Len = sizeof("objcproto") - 1;
       std::string_view ProtoSourceName(Qual.data() + Len, Qual.size() - Len);
       std::string_view Proto;
       {
         ScopedOverride<const char *> SaveFirst(First, ProtoSourceName.data()),
             SaveLast(Last, &*ProtoSourceName.rbegin() + 1);
         Proto = parseBareSourceName();
       }
case 'D':
     //                ::= Da   # auto (in dependent new-expressions)
     case 'a':
       First += 2;
       return make<NameType>("auto");
     //                ::= Dc   # decltype(auto)
     case 'c':
       First += 2;
       return make<NameType>("decltype(auto)");
+    //                ::= Dk <type-constraint> # constrained auto
+    //                ::= DK <type-constraint> # constrained decltype(auto)
+    case 'k':
+    case 'K': {
+      std::string_view Kind = look(1) == 'k' ? " auto" : " decltype(auto)";
+      First += 2;
+      Node *Constraint = getDerived().parseName();
+      if (!Constraint)
+        return nullptr;
+      return make<PostfixQualifiedType>(Constraint, Kind);
+    }
     //                ::= Dn   # std::nullptr_t (i.e., decltype(nullptr))
     case 'n':
       First += 2;
       return make<NameType>("std::nullptr_t");
 
     //             ::= <decltype>
     case 't':
     case 'T': {
Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
   }
   bool OnePastTheEnd = consumeIf('p');
   if (!consumeIf('E'))
     return nullptr;
   return make<SubobjectExpr>(
       Ty, Expr, Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
 }
 
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseConstraintExpr() {
+  // Within this expression, all enclosing template parameter lists are in
+  // scope.
+  ScopedOverride<bool> SaveInConstraintExpr(InConstraintExpr, true);
+  return getDerived().parseExpr();
+}
+
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseRequiresExpr() {
+  NodeArray Params;
+  if (consumeIf("rQ")) {
+    // <expression> ::= rQ <bare-function-type> _ <requirement>+ E
+    size_t ParamsBegin = Names.size();
+    while (!consumeIf('_')) {
+      Node *Type = getDerived().parseType();
+      if (Type == nullptr)
+        return nullptr;
+      Names.push_back(Type);
+    }
+    Params = popTrailingNodeArray(ParamsBegin);
+  } else if (!consumeIf("rq")) {
+    // <expression> ::= rq <requirement>+ E
+    return nullptr;
+  }
+
+  size_t ReqsBegin = Names.size();
+  do {
+    Node *Constraint = nullptr;
+    if (consumeIf('X')) {
+      // <requirement> ::= X <expression> [N] [R <type-constraint>]
+      Node *Expr = getDerived().parseExpr();
+      if (Expr == nullptr)
+        return nullptr;
+      bool Noexcept = consumeIf('N');
+      Node *TypeReq = nullptr;
+      if (consumeIf('R')) {
+        TypeReq = getDerived().parseName();
+        if (TypeReq == nullptr)
+          return nullptr;
+      }
+      Constraint = make<ExprRequirement>(Expr, Noexcept, TypeReq);
+    } else if (consumeIf('T')) {
+      // <requirement> ::= T <type>
+      Node *Type = getDerived().parseType();
+      if (Type == nullptr)
+        return nullptr;
+      Constraint = make<TypeRequirement>(Type);
+    } else if (consumeIf('Q')) {
+      // <requirement> ::= Q <constraint-expression>
+      //
+      // FIXME: We use <expression> instead of <constraint-expression>. Either
+      // the requires expression is already inside a constraint expression, in
+      // which case it makes no difference, or we're in a requires-expression
+      // that might be partially-substituted, where the language behavior is
+      // not yet settled and clang mangles after substitution.
+      Node *NestedReq = getDerived().parseExpr();
+      if (NestedReq == nullptr)
+        return nullptr;
+      Constraint = make<NestedRequirement>(NestedReq);
+    }
+    if (Constraint == nullptr)
+      return nullptr;
+    Names.push_back(Constraint);
+  } while (!consumeIf('E'));
+
+  return make<RequiresExpr>(Params, popTrailingNodeArray(ReqsBegin));
+}
+
 // <expression> ::= <unary operator-name> <expression>
 //              ::= <binary operator-name> <expression> <expression>
 //              ::= <ternary operator-name> <expression> <expression> <expression>
 //              ::= cl <expression>+ E                                   # call
 //              ::= cv <type> <expression>                               # conversion with one argument
 //              ::= cv <type> _ <expression>* E                          # conversion with a different number of arguments
 //              ::= [gs] nw <expression>* _ <type> E                     # new (expr-list) type
 //              ::= [gs] nw <expression>* _ <type> <initializer>         # new (expr-list) type (init)
Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
   if (consumeIf("mc"))
     return parsePointerToMemberConversionExpr(Node::Prec::Unary);
   if (consumeIf("nx")) {
     Node *Ex = getDerived().parseExpr();
     if (Ex == nullptr)
       return Ex;
     return make<EnclosingExpr>("noexcept ", Ex, Node::Prec::Unary);
   }
+  if (look() == 'r' && (look(1) == 'q' || look(1) == 'Q'))
+    return parseRequiresExpr();
   if (consumeIf("so"))
     return parseSubobjectExpr();
   if (consumeIf("sp")) {
     Node *Child = getDerived().parseExpr();
     if (Child == nullptr)
       return nullptr;
     return make<ParameterPackExpansion>(Child);
   }
case 'I': {
       return make<SpecialName>("initializer for module ", Module);
     }
     }
   }
   return nullptr;
 }
 
 // <encoding> ::= <function name> <bare-function-type>
+//                    [`Q` <requires-clause expr>]
 //            ::= <data name>
 //            ::= <special-name>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
   // The template parameters of an encoding are unrelated to those of the
   // enclosing context.
-  class SaveTemplateParams {
-    AbstractManglingParser *Parser;
-    decltype(TemplateParams) OldParams;
-    decltype(OuterTemplateParams) OldOuterParams;
-
-  public:
-    SaveTemplateParams(AbstractManglingParser *TheParser) : Parser(TheParser) {
-      OldParams = std::move(Parser->TemplateParams);
-      OldOuterParams = std::move(Parser->OuterTemplateParams);
-      Parser->TemplateParams.clear();
-      Parser->OuterTemplateParams.clear();
-    }
-    ~SaveTemplateParams() {
-      Parser->TemplateParams = std::move(OldParams);
-      Parser->OuterTemplateParams = std::move(OldOuterParams);
-    }
-  } SaveTemplateParams(this);
+  SaveTemplateParams SaveTemplateParamsScope(this);
 
   if (look() == 'G' || look() == 'T')
     return getDerived().parseSpecialName();
 
   auto IsEndOfEncoding = [&] {
     // The set of chars that can potentially follow an <encoding> (none of which
     // can start a <type>). Enumerating these allows us to avoid speculative
     // parsing.
Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
 
   Node *ReturnType = nullptr;
   if (!NameInfo.CtorDtorConversion && NameInfo.EndsWithTemplateArgs) {
     ReturnType = getDerived().parseType();
     if (ReturnType == nullptr)
       return nullptr;
   }
 
-  if (consumeIf('v'))
-    return make<FunctionEncoding>(ReturnType, Name, NodeArray(),
-                                  Attrs, NameInfo.CVQualifiers,
-                                  NameInfo.ReferenceQualifier);
-
+  NodeArray Params;
+  if (!consumeIf('v')) {
     size_t ParamsBegin = Names.size();
     do {
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return nullptr;
       Names.push_back(Ty);
-  } while (!IsEndOfEncoding());
+    } while (!IsEndOfEncoding() && look() != 'Q');
+    Params = popTrailingNodeArray(ParamsBegin);
+  }
+
+  Node *Requires = nullptr;
+  if (consumeIf('Q')) {
+    Requires = getDerived().parseConstraintExpr();
+    if (!Requires)
+      return nullptr;
+  }
 
-  return make<FunctionEncoding>(ReturnType, Name,
-                                popTrailingNodeArray(ParamsBegin),
-                                Attrs, NameInfo.CVQualifiers,
+  return make<FunctionEncoding>(ReturnType, Name, Params, Attrs, Requires,
+                                NameInfo.CVQualifiers,
                                 NameInfo.ReferenceQualifier);
 }
 
 template <class Float>
 struct FloatData;
 
 template <>
 struct FloatData<float>

 }
 
 // <template-param> ::= T_    # first template parameter
 //                  ::= T <parameter-2 non-negative number> _
 //                  ::= TL <level-1> __
 //                  ::= TL <level-1> _ <parameter-2 non-negative number> _
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
+  const char *Begin = First;
   if (!consumeIf('T'))
     return nullptr;
 
   size_t Level = 0;
   if (consumeIf('L')) {
     if (parsePositiveInteger(&Level))
       return nullptr;
     ++Level;
     if (!consumeIf('_'))
       return nullptr;
   }
 
   size_t Index = 0;
   if (!consumeIf('_')) {
     if (parsePositiveInteger(&Index))
       return nullptr;
     ++Index;
     if (!consumeIf('_'))
       return nullptr;
   }
 
+  // We don't track enclosing template parameter levels well enough to reliably
+  // substitute them all within a <constraint-expression>, so print the
+  // parameter numbering instead for now.
+  // TODO: Track all enclosing template parameters and substitute them here.
+  if (InConstraintExpr) {
+    return make<NameType>(std::string_view(Begin, First - 1 - Begin));
+  }
+
   // If we're in a context where this <template-param> refers to a
   // <template-arg> further ahead in the mangled name (currently just conversion
   // operator types), then we should only look it up in the right context.
   // This can only happen at the outermost level.
   if (PermitForwardTemplateReferences && Level == 0) {
     Node *ForwardRef = make<ForwardTemplateReference>(Index);
     if (!ForwardRef)
       return nullptr;
Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
   return (*TemplateParams[Level])[Index];
 }
 
 // <template-param-decl> ::= Ty                          # type parameter
 //                       ::= Tn <type>                   # non-type parameter
 //                       ::= Tt <template-param-decl>* E # template parameter
 //                       ::= Tp <template-param-decl>    # parameter pack
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl() {
+Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl(
+    TemplateParamList *Params) {
   auto InventTemplateParamName = [&](TemplateParamKind Kind) {
     unsigned Index = NumSyntheticTemplateParameters[(int)Kind]++;
     Node *N = make<SyntheticTemplateParamName>(Kind, Index);
-    if (N) TemplateParams.back()->push_back(N);
+    if (N && Params)
+      Params->push_back(N);
     return N;
   };
 
   if (consumeIf("Ty")) {
     Node *Name = InventTemplateParamName(TemplateParamKind::Type);
     if (!Name)
       return nullptr;
     return make<TypeTemplateParamDecl>(Name);
   }
 
+  if (consumeIf("Tk")) {
+    Node *Constraint = getDerived().parseName();
+    if (!Constraint)
+      return nullptr;
+    Node *Name = InventTemplateParamName(TemplateParamKind::Type);
+    if (!Name)
+      return nullptr;
+    return make<ConstrainedTypeTemplateParamDecl>(Constraint, Name);
+  }
+
   if (consumeIf("Tn")) {
     Node *Name = InventTemplateParamName(TemplateParamKind::NonType);
     if (!Name)
       return nullptr;
     Node *Type = parseType();
     if (!Type)
       return nullptr;
     return make<NonTypeTemplateParamDecl>(Name, Type);
   }
 
   if (consumeIf("Tt")) {
     Node *Name = InventTemplateParamName(TemplateParamKind::Template);
     if (!Name)
       return nullptr;
     size_t ParamsBegin = Names.size();
     ScopedTemplateParamList TemplateTemplateParamParams(this);
-    while (!consumeIf("E")) {
-      Node *P = parseTemplateParamDecl();
+    Node *Requires = nullptr;
+    while (!consumeIf('E')) {
+      Node *P = parseTemplateParamDecl(TemplateTemplateParamParams.params());
       if (!P)
         return nullptr;
       Names.push_back(P);
+      if (consumeIf('Q')) {
+        Requires = getDerived().parseConstraintExpr();
+        if (Requires == nullptr || !consumeIf('E'))
+          return nullptr;
+        break;
       }
-    NodeArray Params = popTrailingNodeArray(ParamsBegin);
-    return make<TemplateTemplateParamDecl>(Name, Params);
+    }
+    NodeArray InnerParams = popTrailingNodeArray(ParamsBegin);
+    return make<TemplateTemplateParamDecl>(Name, InnerParams, Requires);
   }
 
   if (consumeIf("Tp")) {
-    Node *P = parseTemplateParamDecl();
+    Node *P = parseTemplateParamDecl(Params);
     if (!P)
       return nullptr;
     return make<TemplateParamPackDecl>(P);
   }
 
   return nullptr;
 }
 
 // <template-arg> ::= <type>                    # type or template
 //                ::= X <expression> E          # expression
 //                ::= <expr-primary>            # simple expressions
 //                ::= J <template-arg>* E       # argument pack
 //                ::= LZ <encoding> E           # extension
+//                ::= <template-param-decl> <template-arg>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseTemplateArg() {
   switch (look()) {
   case 'X': {
     ++First;
     Node *Arg = getDerived().parseExpr();
     if (Arg == nullptr || !consumeIf('E'))
       return nullptr;
if (look(1) == 'Z') {
       Node *Arg = getDerived().parseEncoding();
       if (Arg == nullptr || !consumeIf('E'))
         return nullptr;
       return Arg;
     }
     //                ::= <expr-primary>            # simple expressions
     return getDerived().parseExprPrimary();
   }
+  case 'T': {
+    // Either <template-param> or a <template-param-decl> <template-arg>.
+    if (!getDerived().isTemplateParamDecl())
+      return getDerived().parseType();
+    Node *Param = getDerived().parseTemplateParamDecl(nullptr);
+    if (!Param)
+      return nullptr;
+    Node *Arg = getDerived().parseTemplateArg();
+    if (!Arg)
+      return nullptr;
+    return make<TemplateParamQualifiedArg>(Param, Arg);
+  }
   default:
     return getDerived().parseType();
   }
 }
 
 // <template-args> ::= I <template-arg>* E
 //     extension, the abi says <template-arg>+
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseTemplateArgs(bool TagTemplates) {
   if (!consumeIf('I'))
     return nullptr;
 
   // <template-params> refer to the innermost <template-args>. Clear out any
   // outer args that we may have inserted into TemplateParams.
   if (TagTemplates) {
     TemplateParams.clear();
     TemplateParams.push_back(&OuterTemplateParams);
     OuterTemplateParams.clear();
   }
 
   size_t ArgsBegin = Names.size();
+  Node *Requires = nullptr;
   while (!consumeIf('E')) {
     if (TagTemplates) {
-      auto OldParams = std::move(TemplateParams);
       Node *Arg = getDerived().parseTemplateArg();
-      TemplateParams = std::move(OldParams);
       if (Arg == nullptr)
         return nullptr;
       Names.push_back(Arg);
       Node *TableEntry = Arg;
+      if (Arg->getKind() == Node::KTemplateParamQualifiedArg) {
+        TableEntry =
+            static_cast<TemplateParamQualifiedArg *>(TableEntry)->getArg();
+      }
       if (Arg->getKind() == Node::KTemplateArgumentPack) {
         TableEntry = make<ParameterPack>(
             static_cast<TemplateArgumentPack*>(TableEntry)->getElements());
         if (!TableEntry)
           return nullptr;
       }
-      TemplateParams.back()->push_back(TableEntry);
+      OuterTemplateParams.push_back(TableEntry);
     } else {
       Node *Arg = getDerived().parseTemplateArg();
       if (Arg == nullptr)
         return nullptr;
       Names.push_back(Arg);
     }
+    if (consumeIf('Q')) {
+      Requires = getDerived().parseConstraintExpr();
+      if (!Requires || !consumeIf('E'))
+        return nullptr;
+      break;
+    }
   }
-  return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin));
+  return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin), Requires);
 }
 
 // <mangled-name> ::= _Z <encoding>
 //                ::= <type>
 // extension      ::= ___Z <encoding> _block_invoke
 // extension      ::= ___Z <encoding> _block_invoke<decimal-digit>+
 // extension      ::= ___Z <encoding> _block_invoke_<decimal-digit>+
 template <typename Derived, typename Alloc>

 template <typename Alloc>
 struct ManglingParser : AbstractManglingParser<ManglingParser<Alloc>, Alloc> {
   using AbstractManglingParser<ManglingParser<Alloc>,
                                Alloc>::AbstractManglingParser;
 };
 
 DEMANGLE_NAMESPACE_END
 
+#ifdef _LIBCXXABI_COMPILER_CLANG
+#pragma clang diagnostic pop
+#endif
+
 #endif // DEMANGLE_ITANIUMDEMANGLE_H

llvm/include/llvm/Demangle/ItaniumNodes.def

 NODE(NoexceptSpec)
 NODE(DynamicExceptionSpec)
 NODE(FunctionEncoding)
 NODE(LiteralOperator)
 NODE(SpecialName)
 NODE(CtorVtableSpecialName)
 NODE(QualifiedName)
 NODE(NestedName)
+NODE(MemberLikeFriendName)
 NODE(LocalName)
 NODE(ModuleName)
 NODE(ModuleEntity)
 NODE(VectorType)
 NODE(PixelVectorType)
 NODE(BinaryFPType)
 NODE(BitIntType)
 NODE(SyntheticTemplateParamName)
+NODE(TemplateParamQualifiedArg)
 NODE(TypeTemplateParamDecl)
+NODE(ConstrainedTypeTemplateParamDecl)
 NODE(NonTypeTemplateParamDecl)
 NODE(TemplateTemplateParamDecl)
 NODE(TemplateParamPackDecl)
 NODE(ParameterPack)
 NODE(TemplateArgumentPack)
 NODE(ParameterPackExpansion)
 NODE(TemplateArgs)
 NODE(ForwardTemplateReference)

 NODE(LambdaExpr)
 NODE(EnumLiteral)
 NODE(IntegerLiteral)
 NODE(FloatLiteral)
 NODE(DoubleLiteral)
 NODE(LongDoubleLiteral)
 NODE(BracedExpr)
 NODE(BracedRangeExpr)
+NODE(RequiresExpr)
+NODE(ExprRequirement)
+NODE(TypeRequirement)
+NODE(NestedRequirement)
 
 #undef NODE