Deferred Concept Instantiation Implementation Take 2

[erichkeane]

Summary

This is a continuation of D119544. Based on @rsmith 's feed back
showing me https://eel.is/c++draft/temp#friend-9, We should properly
handle friend functions now.

There are two followups that will need to be made on this (1 to make
sure these get properly differentiated in modules, and 1 to make sure
they get mangled differently see: https://reviews.llvm.org/D110641), but
they will need the visitor we developed here.

Note the changes vs the previous accepted versions of this all start in
SemaOverload.cpp, and call into the SemaTemplate work (For the visitor)
plus a declaration in Sema.h.

[erichkeane]

In D126907#3585626, @erichkeane wrote:

See here: https://github.com/llvm/llvm-project/issues/55673

This might be the same issue, the crash at least looks the same.

Note: Looks to not be the same problem :/ Additionally, the fix I thought would work here does not, so I'm back at square 1 on that crash again. I was trying to move the 'isEvaluatingAConstraint' out of Sema (since we don't want to isntantiate a type constraint until we are checking it!) but that causes us to fail a number of OTHER tests for checking an uninstantiated constraint.

[ChuanqiXu]

From what I can see, the crash reason would be the mismatch depth and the setting of MultiLevelTemplateArgumentList. In ::CheckConstraintSatisfaction, the depth of RawCompletionToken is 0, while the depth of corresponding MultiLevelTemplateArgumentList is 2. So the compiler would get the outermost template argument incorrectly (which is a template pack in the example) in TransformTemplateTypeParmType.

The first though was that we should set the depth of RawCompletionToken to 1 correctly. But I felt this might not be good later since in the normal process of template instantiation (without concepts and constraints), the depth of RawCompletionToken is 0 indeed. What is different that time is the depth of corresponding MultiLevelTemplateArgumentList is 1. So it looks like the process is constructed on the fly. It makes sense for the perspective of compilation speed.

So I feel like what we should do here is in Sema::CheckInstantiatedFunctionTemplateConstraints, when we are computing the desired MultiLevelTemplateArgumentList, we should compute a result with depth of 1 in the particular case.

---

Another idea is to not do instantiation when we're checking constraints. But I need to think more about this.

[erichkeane]

In D126907#3588417, @ChuanqiXu wrote:

From what I can see, the crash reason would be the mismatch depth and the setting of MultiLevelTemplateArgumentList. In ::CheckConstraintSatisfaction, the depth of RawCompletionToken is 0, while the depth of corresponding MultiLevelTemplateArgumentList is 2. So the compiler would get the outermost template argument incorrectly (which is a template pack in the example) in TransformTemplateTypeParmType.

The first though was that we should set the depth of RawCompletionToken to 1 correctly. But I felt this might not be good later since in the normal process of template instantiation (without concepts and constraints), the depth of RawCompletionToken is 0 indeed. What is different that time is the depth of corresponding MultiLevelTemplateArgumentList is 1. So it looks like the process is constructed on the fly. It makes sense for the perspective of compilation speed.

So I feel like what we should do here is in Sema::CheckInstantiatedFunctionTemplateConstraints, when we are computing the desired MultiLevelTemplateArgumentList, we should compute a result with depth of 1 in the particular case.

---

Another idea is to not do instantiation when we're checking constraints. But I need to think more about this.

I don't know of the 'another idea'? We have to do instantiation before checking, and if we do it too early, we aren't doing the deferred instantiation. And the problem is that the RawCompletionToken uses a concept to refer to 'itself'. However, this version of 'itself' isn't valid, since the 'depth' is wrong once it tries to instantiate relative to the 'top level'. However, this IS happening during instantiation?

My latest thought is that perhaps the "IsEvaluatingAConstraint" should NOT happen at the Sema level (but at the instantiator level), since it ends up catching things it shouldn't? I tried it and have a handful of failures of trying to check uninstantiated constraints, but I've not dug completely into it.

[ChuanqiXu]

In D126907#3588708, @erichkeane wrote:

In D126907#3588417, @ChuanqiXu wrote:

From what I can see, the crash reason would be the mismatch depth and the setting of MultiLevelTemplateArgumentList. In ::CheckConstraintSatisfaction, the depth of RawCompletionToken is 0, while the depth of corresponding MultiLevelTemplateArgumentList is 2. So the compiler would get the outermost template argument incorrectly (which is a template pack in the example) in TransformTemplateTypeParmType.

The first though was that we should set the depth of RawCompletionToken to 1 correctly. But I felt this might not be good later since in the normal process of template instantiation (without concepts and constraints), the depth of RawCompletionToken is 0 indeed. What is different that time is the depth of corresponding MultiLevelTemplateArgumentList is 1. So it looks like the process is constructed on the fly. It makes sense for the perspective of compilation speed.

So I feel like what we should do here is in Sema::CheckInstantiatedFunctionTemplateConstraints, when we are computing the desired MultiLevelTemplateArgumentList, we should compute a result with depth of 1 in the particular case.

---

Another idea is to not do instantiation when we're checking constraints. But I need to think more about this.

I don't know of the 'another idea'? We have to do instantiation before checking, and if we do it too early, we aren't doing the deferred instantiation. And the problem is that the RawCompletionToken uses a concept to refer to 'itself'. However, this version of 'itself' isn't valid, since the 'depth' is wrong once it tries to instantiate relative to the 'top level'. However, this IS happening during instantiation?

My latest thought is that perhaps the "IsEvaluatingAConstraint" should NOT happen at the Sema level (but at the instantiator level), since it ends up catching things it shouldn't? I tried it and have a handful of failures of trying to check uninstantiated constraints, but I've not dug completely into it.

Yeah, we have to do instantiation before checking. My point is that it looks like we're doing another instantiation when we check the concepts. And my point is that if it we should avoid the second instantiation.

[erichkeane]

In D126907#3591195, @ChuanqiXu wrote:

In D126907#3588708, @erichkeane wrote:

In D126907#3588417, @ChuanqiXu wrote:

From what I can see, the crash reason would be the mismatch depth and the setting of MultiLevelTemplateArgumentList. In ::CheckConstraintSatisfaction, the depth of RawCompletionToken is 0, while the depth of corresponding MultiLevelTemplateArgumentList is 2. So the compiler would get the outermost template argument incorrectly (which is a template pack in the example) in TransformTemplateTypeParmType.

The first though was that we should set the depth of RawCompletionToken to 1 correctly. But I felt this might not be good later since in the normal process of template instantiation (without concepts and constraints), the depth of RawCompletionToken is 0 indeed. What is different that time is the depth of corresponding MultiLevelTemplateArgumentList is 1. So it looks like the process is constructed on the fly. It makes sense for the perspective of compilation speed.

So I feel like what we should do here is in Sema::CheckInstantiatedFunctionTemplateConstraints, when we are computing the desired MultiLevelTemplateArgumentList, we should compute a result with depth of 1 in the particular case.

---

Another idea is to not do instantiation when we're checking constraints. But I need to think more about this.

I don't know of the 'another idea'? We have to do instantiation before checking, and if we do it too early, we aren't doing the deferred instantiation. And the problem is that the RawCompletionToken uses a concept to refer to 'itself'. However, this version of 'itself' isn't valid, since the 'depth' is wrong once it tries to instantiate relative to the 'top level'. However, this IS happening during instantiation?

My latest thought is that perhaps the "IsEvaluatingAConstraint" should NOT happen at the Sema level (but at the instantiator level), since it ends up catching things it shouldn't? I tried it and have a handful of failures of trying to check uninstantiated constraints, but I've not dug completely into it.

Yeah, we have to do instantiation before checking. My point is that it looks like we're doing another instantiation when we check the concepts. And my point is that if it we should avoid the second instantiation.

Hmm... yeah, I think we actually want to skip the FIRST instantiation? I think the work I did above in Sema for IsEvaluatingAConstraint was too greedy, it ends up instantiating constraints on the 'while we are there' type things, rather than the things being currently checked. I found that if I can make it a state of the instantiators themselves, it seems to work, at least for your example. I've got it down to 1 'lit' test failure, but have been looking at the other problem first (below).

The Github-Issue crash IS a regression from this patch, and I've minimized it sufficiently. I believe I have a hold on how to fix it, I just have to do so :) If I make any further progress, I'll clean this up and put it up here, even if it DOES have the lit test failure.

[erichkeane]

Made good progress today, but got trapped down the CheckDeducedArgs path for quite a bit longer with partial specializations. I have all of the crashes I know of 'fixed', but have a few tests that still fail for unknown reasons. Because of that, i don't have anything I can really upload, so I'll have to do so mid-next-week.

[erichkeane]

As promised, got it down to the 1 failure, and added tests for @ChuanqiXu and the std::vector example. That all seems to work, just a problem with the CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp test left.

[erichkeane]

Note that the failure comes down to:

template<typename T> concept C = T::f();
template<template<C> class P> struct S1{};
template<C> struct X{};
S1<X> s11;

and requires the -frelaxed-template-template-args flag:

[ekeane1@scsel-clx-24 build]$  ./bin/clang -cc1 -std=c++20 temp.cpp -frelaxed-template-template-args
temp.cpp:5:4: error: template template argument 'X' is more constrained than template template parameter 'P'
S1<X> s11;
   ^
temp.cpp:3:29: note: 'P' declared here
template <template<C> class P> struct S1{};
                            ^
temp.cpp:4:20: note: 'X' declared here
template<C> struct X{};
                   ^
1 error generated.

[ChuanqiXu]

Great progress!

In D126907#3599835, @erichkeane wrote:

Note that the failure comes down to:

template<typename T> concept C = T::f();
template<template<C> class P> struct S1{};
template<C> struct X{};
S1<X> s11;

and requires the -frelaxed-template-template-args flag:

[ekeane1@scsel-clx-24 build]$  ./bin/clang -cc1 -std=c++20 temp.cpp -frelaxed-template-template-args
temp.cpp:5:4: error: template template argument 'X' is more constrained than template template parameter 'P'
S1<X> s11;
   ^
temp.cpp:3:29: note: 'P' declared here
template <template<C> class P> struct S1{};
                            ^
temp.cpp:4:20: note: 'X' declared here
template<C> struct X{};
                   ^
1 error generated.

As far as I could tell, we could omit the diagnostic by deleting https://github.com/llvm/llvm-project/blob/bc74bca5363270e987c2e3c263bfaaeb6ceab66f/clang/include/clang/Sema/SemaConcept.h#L45-L53

This change is obsolutely wrong but it shows the bug comes from ParameterMapping so we could locate https://github.com/llvm/llvm-project/blob/bc74bca5363270e987c2e3c263bfaaeb6ceab66f/clang/lib/Sema/SemaConcept.cpp#L723 further.

clang/lib/Sema/SemaTemplateInstantiate.cpp

2488

clang/test/Driver/crash-report.cpp

28 ↗

(On Diff #438781)

What's the meaning of RUNX?

[erichkeane]

In D126907#3600876, @ChuanqiXu wrote:

Great progress!

In D126907#3599835, @erichkeane wrote:

Note that the failure comes down to:

template<typename T> concept C = T::f();
template<template<C> class P> struct S1{};
template<C> struct X{};
S1<X> s11;

and requires the -frelaxed-template-template-args flag:

[ekeane1@scsel-clx-24 build]$  ./bin/clang -cc1 -std=c++20 temp.cpp -frelaxed-template-template-args
temp.cpp:5:4: error: template template argument 'X' is more constrained than template template parameter 'P'
S1<X> s11;
   ^
temp.cpp:3:29: note: 'P' declared here
template <template<C> class P> struct S1{};
                            ^
temp.cpp:4:20: note: 'X' declared here
template<C> struct X{};
                   ^
1 error generated.

As far as I could tell, we could omit the diagnostic by deleting https://github.com/llvm/llvm-project/blob/bc74bca5363270e987c2e3c263bfaaeb6ceab66f/clang/include/clang/Sema/SemaConcept.h#L45-L53

This change is obsolutely wrong but it shows the bug comes from ParameterMapping so we could locate https://github.com/llvm/llvm-project/blob/bc74bca5363270e987c2e3c263bfaaeb6ceab66f/clang/lib/Sema/SemaConcept.cpp#L723 further.

Thanks for the debugging help! I'm not sure what you mean by "Locating it further"? Best I can tell looking so far, is the fact that the 'depths' still point based on the 'root', but this is comparing thinking they are relative to the decl themselves. I see the 'SubstTemplateArguments' there that looks suspicious, so there is probably something about setting up my template parameters correctly there/the MLTAL.

Thanks for the comments and debugging help again!

clang/test/Driver/crash-report.cpp

28 ↗

(On Diff #438781)

Woops! I didn't add this test change to GIT, but it apparently still showed up with 'diff'. For some reason, once I switched to lldb the llvm-symbolizer takes a HUGE amount of time during this test when doing check-all, so I used the 'X' to disable the test locally. This is not intended to be committed.

[erichkeane]

All tests pass now, I was able to get the template-template checks working correctly, and it passes all the tests I have available. @ChuanqiXu if you could review/run what tests you have, it would be greatly appreciated.

[erichkeane]

Rebased!

[ChuanqiXu]

In D126907#3615807, @erichkeane wrote:

All tests pass now, I was able to get the template-template checks working correctly, and it passes all the tests I have available. @ChuanqiXu if you could review/run what tests you have, it would be greatly appreciated.

I've tested some of our workloads and libunifex (I know it contains a lot of uses for concept). And all the tests passed now. So it looks like it wouldn't cause regression failure.

The implementation basically looks good to me. (This is really large and I can't be sure I don't miss something). Only some minor issues remained.

clang/include/clang/AST/Decl.h

1961–1962

Could we give a new abstract like XXXInfo to replace NamedDecl* here? The NamedDecl* covers a lot of things. It looks more consistent.

clang/include/clang/Sema/Sema.h

7181–7192

Remove this before landing.

7182

ditto

clang/lib/AST/Decl.cpp

3793

static_cast is rarely used in clang/LLVM to me. I know the reason is that TemplateOrSpecialization contains a NamedDecl* member. I guess it might be better to refactor it.

clang/lib/AST/DeclBase.cpp

286–304 ↗

(On Diff #440712)

How about:

clang/lib/Sema/SemaConcept.cpp

65

69

184–185

clang/lib/Sema/SemaTemplate.cpp

2346–2347

[erichkeane]

In D126907#3617713, @ChuanqiXu wrote:

In D126907#3615807, @erichkeane wrote:

All tests pass now, I was able to get the template-template checks working correctly, and it passes all the tests I have available. @ChuanqiXu if you could review/run what tests you have, it would be greatly appreciated.

I've tested some of our workloads and libunifex (I know it contains a lot of uses for concept). And all the tests passed now. So it looks like it wouldn't cause regression failure.

The implementation basically looks good to me. (This is really large and I can't be sure I don't miss something). Only some minor issues remained.

Thank you SO much for your testing and reviews, I very much appreciate all the help you've given me. I'm sorry that this has become such a huge patch, I really wish it was something I could have done in smaller increments, but that doesn't seem like it is possible since it is changing something so fundamental, and the fallout from that is huge.

clang/include/clang/AST/Decl.h

1961–1962

All of those 'Info' types contain significantly more information, which we really don't have a need for here. Basically all this patch is doing is using the FunctionTemplateDecl* that was already in the list and generalizing it a bit. AND unfortunately, the only commonality between FunctionTemplateDecl and FunctionDecl is NamedDecl.

So any type we would use would end up causing an additional allocation here, and make its use require us to unpack it :/

I guess what I'm saying, is I'm not sure what that would look like in a way that wouldn't make this worse. Do you have an idea you could share that would improve that?

clang/include/clang/Sema/Sema.h

7181–7192

Yikes! Thanks for catching this!

clang/lib/AST/Decl.cpp

3793

Ah, looks like the static-casts weren't necessary anyway. No idea why I thought they were. Removed. See comment above about the refactor.

[erichkeane]

All but the 1 comment from @ChuanqiXu fixed, not sure what to do about the 'info'.

[ChuanqiXu]

In D126907#3619270, @erichkeane wrote:

All but the 1 comment from @ChuanqiXu fixed, not sure what to do about the 'info'.

LGTM. But the 'info' comment doesn't matter a lot. The current complexity is acceptable and its semantics is stated clearly in the comments. My intention is to make its semantics more clear and more readable so that it is easier to maintain and change it. But this is required. Since the patch is really large. So my preference is to do other unnecessary changes in other revision to make the patch easier to read. (Just a preference. I know some people prefer large patches.)

clang/include/clang/AST/Decl.h

1961–1962

My idea would be something like:

C++
llvm::PointerUnion<FunctionDecl *, FunctionTemplateDecl*, MemberSpecializationInfo *,
                     FunctionTemplateSpecializationInfo *,

So any type we would use would end up causing an additional allocation here, and make its use require us to unpack it :/

This is a union so it wouldn't cause additional allocations?

[erichkeane]

clang/include/clang/AST/Decl.h

1961–1962

I tried doing FunctionDecl and FunctionTemplateDecl at one point, but we endd up running out of bits for the pointer-union to work on 32 bit builds. Otherwise I would have done that.

I misunderstood the 'Info' thing and thought you wanted a new wrapper type (an 'Info' type), which would need to be allocated and contain just a pointer, which is why I was thinking about needing allocations.

[JDevlieghere]

This change triggers an assertion when building an LLDB test case:

UNREACHABLE executed at /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Sema/SemaTemplate.cpp:1726!
Assertion failed: (InstantiatingSpecializations.empty() && "failed to clean up an InstantiatingTemplate?"), function ~Sema, file /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Sema/Sema.cpp, line 458.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/clang -fmodules -gmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lldb-test-build.noindex/module-cache-clang/lldb-api -gmodules -fcxx-modules -std=c++11 -g -O0 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk -arch x86_64 -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make/../../../../../include -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make -include /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make/test_common.h -fno-limit-debug-info -fmodules -gmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lldb-test-build.noindex/module-cache-clang/lldb-api -gmodules -fcxx-modules -DLLDB_USING_LIBCPP -stdlib=libc++ -std=c++20 --driver-mode=g++ -MT main.o -MD -MP -MF main.d -c -o main.o /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span/main.cpp
1.	/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span/main.cpp:1:2: current parser token 'include'
Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it):
0  clang                    0x0000000106bc157e llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) + 46
1  clang                    0x0000000106bc0258 llvm::sys::RunSignalHandlers() + 248
2  clang                    0x0000000106bc0962 llvm::sys::CleanupOnSignal(unsigned long) + 210
3  clang                    0x0000000106adb82a (anonymous namespace)::CrashRecoveryContextImpl::HandleCrash(int, unsigned long) + 106
4  clang                    0x0000000106adba2e CrashRecoverySignalHandler(int) + 110
5  libsystem_platform.dylib 0x00007fff67b405fd _sigtramp + 29
6  libsystem_platform.dylib 0x00007ffeeab5b460 _sigtramp + 18446744071612509824
7  libsystem_c.dylib        0x00007fff67a12808 abort + 120
8  libsystem_c.dylib        0x00007fff67a11ac6 err + 0
9  clang                    0x0000000108a1325c clang::Sema::~Sema() + 5660
10 clang                    0x0000000107698e41 clang::CompilerInstance::~CompilerInstance() + 625
11 clang                    0x00000001076a7fe5 compileModuleImpl(clang::CompilerInstance&, clang::SourceLocation, llvm::StringRef, clang::FrontendInputFile, llvm::StringRef, llvm::StringRef, llvm::function_ref<void (clang::CompilerInstance&)>, llvm::function_ref<void (clang::CompilerInstance&)>) + 4517
12 clang                    0x00000001076a9b16 compileModuleAndReadASTImpl(clang::CompilerInstance&, clang::SourceLocation, clang::SourceLocation, clang::Module*, llvm::StringRef) + 1238
13 clang                    0x00000001076a370b compileModuleAndReadAST(clang::CompilerInstance&, clang::SourceLocation, clang::SourceLocation, clang::Module*, llvm::StringRef) + 1947
14 clang                    0x00000001076a2b97 clang::CompilerInstance::findOrCompileModuleAndReadAST(llvm::StringRef, clang::SourceLocation, clang::SourceLocation, bool) + 3783
15 clang                    0x00000001076a3aa7 clang::CompilerInstance::loadModule(clang::SourceLocation, llvm::ArrayRef<std::__1::pair<clang::IdentifierInfo*, clang::SourceLocation>>, clang::Module::NameVisibilityKind, bool) + 695
16 clang                    0x0000000109b8a630 clang::Preprocessor::HandleHeaderIncludeOrImport(clang::SourceLocation, clang::Token&, clang::Token&, clang::SourceLocation, clang::detail::SearchDirIteratorImpl<true>, clang::FileEntry const*) + 7792
17 clang                    0x0000000109b822e1 clang::Preprocessor::HandleIncludeDirective(clang::SourceLocation, clang::Token&, clang::detail::SearchDirIteratorImpl<true>, clang::FileEntry const*) + 177
18 clang                    0x0000000109b82f8c clang::Preprocessor::HandleDirective(clang::Token&) + 2604
19 clang                    0x0000000109b50877 clang::Lexer::LexTokenInternal(clang::Token&, bool) + 6199
20 clang                    0x0000000109b4cf15 clang::Lexer::Lex(clang::Token&) + 133
21 clang                    0x0000000109bc4889 clang::Preprocessor::Lex(clang::Token&) + 89
22 clang                    0x000000010899438a clang::Parser::Initialize() + 5018
23 clang                    0x00000001088b9759 clang::ParseAST(clang::Sema&, bool, bool) + 441
24 clang                    0x000000010772aac3 clang::FrontendAction::Execute() + 99
25 clang                    0x000000010769fb6f clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) + 863
26 clang                    0x00000001077b6493 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) + 707
27 clang                    0x00000001050aa241 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) + 2065
28 clang                    0x00000001050a56ad ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) + 285
29 clang                    0x00000001074b2227 void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<llvm::Optional<llvm::StringRef>>, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>*, bool*) const::$_4>(long) + 23
30 clang                    0x0000000106adb73c llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) + 236
31 clang                    0x00000001074b1c95 clang::driver::CC1Command::Execute(llvm::ArrayRef<llvm::Optional<llvm::StringRef>>, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>*, bool*) const + 293
32 clang                    0x0000000107474af7 clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&, bool) const + 1111
33 clang                    0x0000000107474de0 clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::__1::pair<int, clang::driver::Command const*>>&, bool) const + 144
34 clang                    0x000000010749285f clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::__1::pair<int, clang::driver::Command const*>>&) + 911
35 clang                    0x00000001050a4d1b clang_main(int, char**) + 10315
36 libdyld.dylib            0x00007fff67943cc9 start + 1
37 libdyld.dylib            0x0000000000000026 start + 18446603338778395486

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/44981/testReport/junit/lldb-api/functionalities_data-formatter_data-formatter-stl_libcxx_span/TestDataFormatterLibcxxSpan_py/

[erichkeane]

In D126907#3623120, @JDevlieghere wrote:

This change triggers an assertion when building an LLDB test case:

UNREACHABLE executed at /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Sema/SemaTemplate.cpp:1726!
Assertion failed: (InstantiatingSpecializations.empty() && "failed to clean up an InstantiatingTemplate?"), function ~Sema, file /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/clang/lib/Sema/Sema.cpp, line 458.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/clang -fmodules -gmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lldb-test-build.noindex/module-cache-clang/lldb-api -gmodules -fcxx-modules -std=c++11 -g -O0 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk -arch x86_64 -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make/../../../../../include -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span -I/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make -include /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/make/test_common.h -fno-limit-debug-info -fmodules -gmodules -fmodules-cache-path=/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lldb-test-build.noindex/module-cache-clang/lldb-api -gmodules -fcxx-modules -DLLDB_USING_LIBCPP -stdlib=libc++ -std=c++20 --driver-mode=g++ -MT main.o -MD -MP -MF main.d -c -o main.o /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span/main.cpp
1.	/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span/main.cpp:1:2: current parser token 'include'
Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it):
0  clang                    0x0000000106bc157e llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) + 46
1  clang                    0x0000000106bc0258 llvm::sys::RunSignalHandlers() + 248
2  clang                    0x0000000106bc0962 llvm::sys::CleanupOnSignal(unsigned long) + 210
3  clang                    0x0000000106adb82a (anonymous namespace)::CrashRecoveryContextImpl::HandleCrash(int, unsigned long) + 106
4  clang                    0x0000000106adba2e CrashRecoverySignalHandler(int) + 110
5  libsystem_platform.dylib 0x00007fff67b405fd _sigtramp + 29
6  libsystem_platform.dylib 0x00007ffeeab5b460 _sigtramp + 18446744071612509824
7  libsystem_c.dylib        0x00007fff67a12808 abort + 120
8  libsystem_c.dylib        0x00007fff67a11ac6 err + 0
9  clang                    0x0000000108a1325c clang::Sema::~Sema() + 5660
10 clang                    0x0000000107698e41 clang::CompilerInstance::~CompilerInstance() + 625
11 clang                    0x00000001076a7fe5 compileModuleImpl(clang::CompilerInstance&, clang::SourceLocation, llvm::StringRef, clang::FrontendInputFile, llvm::StringRef, llvm::StringRef, llvm::function_ref<void (clang::CompilerInstance&)>, llvm::function_ref<void (clang::CompilerInstance&)>) + 4517
12 clang                    0x00000001076a9b16 compileModuleAndReadASTImpl(clang::CompilerInstance&, clang::SourceLocation, clang::SourceLocation, clang::Module*, llvm::StringRef) + 1238
13 clang                    0x00000001076a370b compileModuleAndReadAST(clang::CompilerInstance&, clang::SourceLocation, clang::SourceLocation, clang::Module*, llvm::StringRef) + 1947
14 clang                    0x00000001076a2b97 clang::CompilerInstance::findOrCompileModuleAndReadAST(llvm::StringRef, clang::SourceLocation, clang::SourceLocation, bool) + 3783
15 clang                    0x00000001076a3aa7 clang::CompilerInstance::loadModule(clang::SourceLocation, llvm::ArrayRef<std::__1::pair<clang::IdentifierInfo*, clang::SourceLocation>>, clang::Module::NameVisibilityKind, bool) + 695
16 clang                    0x0000000109b8a630 clang::Preprocessor::HandleHeaderIncludeOrImport(clang::SourceLocation, clang::Token&, clang::Token&, clang::SourceLocation, clang::detail::SearchDirIteratorImpl<true>, clang::FileEntry const*) + 7792
17 clang                    0x0000000109b822e1 clang::Preprocessor::HandleIncludeDirective(clang::SourceLocation, clang::Token&, clang::detail::SearchDirIteratorImpl<true>, clang::FileEntry const*) + 177
18 clang                    0x0000000109b82f8c clang::Preprocessor::HandleDirective(clang::Token&) + 2604
19 clang                    0x0000000109b50877 clang::Lexer::LexTokenInternal(clang::Token&, bool) + 6199
20 clang                    0x0000000109b4cf15 clang::Lexer::Lex(clang::Token&) + 133
21 clang                    0x0000000109bc4889 clang::Preprocessor::Lex(clang::Token&) + 89
22 clang                    0x000000010899438a clang::Parser::Initialize() + 5018
23 clang                    0x00000001088b9759 clang::ParseAST(clang::Sema&, bool, bool) + 441
24 clang                    0x000000010772aac3 clang::FrontendAction::Execute() + 99
25 clang                    0x000000010769fb6f clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) + 863
26 clang                    0x00000001077b6493 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) + 707
27 clang                    0x00000001050aa241 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) + 2065
28 clang                    0x00000001050a56ad ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) + 285
29 clang                    0x00000001074b2227 void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<llvm::Optional<llvm::StringRef>>, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>*, bool*) const::$_4>(long) + 23
30 clang                    0x0000000106adb73c llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) + 236
31 clang                    0x00000001074b1c95 clang::driver::CC1Command::Execute(llvm::ArrayRef<llvm::Optional<llvm::StringRef>>, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>*, bool*) const + 293
32 clang                    0x0000000107474af7 clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&, bool) const + 1111
33 clang                    0x0000000107474de0 clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::__1::pair<int, clang::driver::Command const*>>&, bool) const + 144
34 clang                    0x000000010749285f clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::__1::pair<int, clang::driver::Command const*>>&) + 911
35 clang                    0x00000001050a4d1b clang_main(int, char**) + 10315
36 libdyld.dylib            0x00007fff67943cc9 start + 1
37 libdyld.dylib            0x0000000000000026 start + 18446603338778395486

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/44981/testReport/junit/lldb-api/functionalities_data-formatter_data-formatter-stl_libcxx_span/TestDataFormatterLibcxxSpan_py/

Yikes! Thanks for the revert. I didn't see the email from the bot until just about 2 minutes before you reverted. I'll see if I can reproduce.

[vitalybuka]

Yikes! Thanks for the revert. I didn't see the email from the bot until just about 2 minutes before you reverted. I'll see if I can reproduce.

FYI. The same on a different bot https://lab.llvm.org/buildbot/#/builders/5/builds/25486/steps/19/logs/stdio

[erichkeane]

I tried the ninja stage2-check-all on my local build with this patch applied and don't reproduce the issue. Is there any way someone could get me the preprocessed source that this crashed on off the servers or something? @JDevlieghere or @vitalybuka ?

[erichkeane]

@shafik was able to help me figure out how to repro, and I think I've about fixed this, so I'll try another commit soon.

[vitalybuka]

@erichkeane can you please make sure that committed revisions in git have "Differential Revision: ....". Usually it's added by "arc" when you upload review.
Also it would be nice if reapply have the same link.

Regarding reproducer, you can follow https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild
But it's already related, let see if it resolved for our bot as well.

[erichkeane]

In D126907#3625600, @vitalybuka wrote:

@erichkeane can you please make sure that committed revisions in git have "Differential Revision: ....". Usually it's added by "arc" when you upload review.
Also it would be nice if reapply have the same link.

Regarding reproducer, you can follow https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild
But it's already related, let see if it resolved for our bot as well.

Yep, I'll make sure to remember that next time. Corporate IT prevents me from using arc, so I am stuck doing it m anually and forget sometimes.

[erichkeane]

Crash that required the revert : https://reviews.llvm.org/rGbefa8cf087dbb8159a4d9dc8fa4d6748d6d5049a

reduces to :

 template<class _Ip>
 concept sentinel_for =
   requires(_Ip __i) {
     __i++;
   };

 template<class _Ip>
 concept bidirectional_iterator =
   sentinel_for<_Ip>;

 
template <class _Iter>
class move_iterator
{
public:
    auto operator++(int)
        requires
        sentinel_for<_Iter>;
};
 
static_assert( bidirectional_iterator<move_iterator<int>>);

In other news, I discovered that 'check-all' and 'stage2-check-all' doesn't include 'check-runtimes', which managed to be why I missed this :/

I won't have time to poke that this until Tuesday since Monday is a US holiday and I'm done for the day, so if @ChuanqiXu or others wish to mess with this, feel free, otherwise I'll get back on it next week!

[vitalybuka]

In D126907#3623377, @vitalybuka wrote:

FYI. The same on a different bot https://lab.llvm.org/buildbot/#/builders/5/builds/25486/steps/19/logs/stdio

Not sure if the URL above was not related, as lease I see no red builds after "relanded patch"

However these are 100% relevant, I tested msan one locally 258c3aee54e1 vs 188582b7e0f3
https://lab.llvm.org/buildbot/#/builders/74/builds/11706
https://lab.llvm.org/buildbot/#/builders/85/builds/8938
https://lab.llvm.org/buildbot/#/builders/168/builds/7114

However sanitizers has nothing to do with the problems, you just need compilers builds with asserts, and then use that one to build and run libcxx tests.

This reproduces the issue on 188582b7e0f357bb9b137b995f773d114472a9c4

mkdir b0
cd b0/
# ${HOME}/src/clang/bin/clang++ is some stable good build of clang.
cmake -GNinja ${HOME}/src/llvm.git/llvm-project/llvm '-DLLVM_ENABLE_PROJECTS=clang;lld'   -DLLVM_CCACHE_BUILD=ON -DCMAKE_C_COMPILER=${HOME}/src/clang/bin/clang -DCMAKE_CXX_COMPILER=${HOME}/src/clang/bin/clang++  -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON
ninja

mkdir ../b1
cd ../b1
cmake -GNinja ${HOME}/src/llvm.git/llvm-project/llvm '-DLLVM_ENABLE_PROJECTS=libcxx;libcxxabi'  -DCMAKE_C_COMPILER=$(readlink -f ../b0)/bin/clang -DCMAKE_CXX_COMPILER=$(readlink -f ../b0)/bin/clang++  -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON
ninja check-cxx

[erichkeane]

Welp, fixed THIS problem but lead to another issue in libc++ that I'm still running down. Stand by all :/

[erichkeane]

SO I've been playing with this for a while and all the libcxx issues. I THINK we really need to just bit the bullet and figure out how to correctly re-add things to the instantiation scope (after making the CheckFunctionConstraints LocalInstantiationScope 'false' for the 2nd param). I can do it well enough with functions since we have a function for it, but likely need to do the same for at least RecordDecl.

[erichkeane]

In D126907#3636830, @erichkeane wrote:

SO I've been playing with this for a while and all the libcxx issues. I THINK we really need to just bit the bullet and figure out how to correctly re-add things to the instantiation scope (after making the CheckFunctionConstraints LocalInstantiationScope 'false' for the 2nd param). I can do it well enough with functions since we have a function for it, but likely need to do the same for at least RecordDecl.

URGH.... And its not clear to me that I CAN do this, since a containing function template's body doesn't exist yet, so we cant go back and make those work. So we are at a point where we both have to inherit AND not inherit the paretn scope, and I have no idea on which basis to do so.

[erichkeane]

This version passes check-runtimes, so libc++ is fine, and it passes everything I have available. @ChuanqiXu : Would you be able to do 1 more run over this to make sure it won't break something? Thanks in advance either way!

[ChuanqiXu]

In D126907#3642530, @erichkeane wrote:

This version passes check-runtimes, so libc++ is fine, and it passes everything I have available. @ChuanqiXu : Would you be able to do 1 more run over this to make sure it won't break something? Thanks in advance either way!

I've tested some our internal workloads and all of them looks fine. But it is expected since we don't use concept heavily. I had tried to run libcxx before but it looks like my previous config is wrong...

[erichkeane]

In D126907#3644127, @ChuanqiXu wrote:

In D126907#3642530, @erichkeane wrote:

This version passes check-runtimes, so libc++ is fine, and it passes everything I have available. @ChuanqiXu : Would you be able to do 1 more run over this to make sure it won't break something? Thanks in advance either way!

I've tested some our internal workloads and all of them looks fine. But it is expected since we don't use concept heavily. I had tried to run libcxx before but it looks like my previous config is wrong...

Ok, thanks! I DID test the libcxx test suite on the above, I figured it out through check-runtimes. If you were able to take a quick look at the diff and make sure I'm not doing anything horrible, it would be appreciated.

[ChuanqiXu]

In D126907#3645198, @erichkeane wrote:

In D126907#3644127, @ChuanqiXu wrote:

In D126907#3642530, @erichkeane wrote:

This version passes check-runtimes, so libc++ is fine, and it passes everything I have available. @ChuanqiXu : Would you be able to do 1 more run over this to make sure it won't break something? Thanks in advance either way!

I've tested some our internal workloads and all of them looks fine. But it is expected since we don't use concept heavily. I had tried to run libcxx before but it looks like my previous config is wrong...

Ok, thanks! I DID test the libcxx test suite on the above, I figured it out through check-runtimes. If you were able to take a quick look at the diff and make sure I'm not doing anything horrible, it would be appreciated.

Yeah, things looks good to me basically.

clang/lib/Sema/SemaTemplateInstantiate.cpp

973–974

I would like to see this in call site and a comment to tell us that we don't want to evaluate constraints in dependent context.

[erichkeane]

clang/lib/Sema/SemaTemplateInstantiate.cpp

973–974

So you want this logic moved to the call-sites? Or am I misinterpreting that?

[ChuanqiXu]

clang/lib/Sema/SemaTemplateInstantiate.cpp

973–974

Yes. It is odd for me to do logic operations in the initialization list.

[erichkeane]

clang/lib/Sema/SemaTemplateInstantiate.cpp

973–974

Got it, that makes sense.

Though when looking at it, I found myself wondering why I did this change, it seems to 'undo' a lot of the deferred concepts work :/

[erichkeane]

Ah... I remember now, and I think that solution isn't quite right. The idea is that we want to defer constraint evaluation when the constraint is on a function decl/template decl. The PROBLEM I need to solve is when it is in a body of a struct or function.

[erichkeane]

Hmm... I think my approach was slightly off... I have to spend more time on this, but thanks for the review! I hope I'm learning each time we go again :/

[erichkeane]

The more I look at this... the more I question my approach. I now am definitely sure we won't make Clang15, and hope that I can figure something better out for 16 :/

[ChuanqiXu]

In D126907#3665900, @erichkeane wrote:

The more I look at this... the more I question my approach. I now am definitely sure we won't make Clang15, and hope that I can figure something better out for 16 :/

I feel like it could be helpful to split it into several small patches next time.

[erichkeane]

In D126907#3667265, @ChuanqiXu wrote:

In D126907#3665900, @erichkeane wrote:

The more I look at this... the more I question my approach. I now am definitely sure we won't make Clang15, and hope that I can figure something better out for 16 :/

I feel like it could be helpful to split it into several small patches next time.

I REALLY wish I knew how to make that happen. The problem is the main idea (deferring instantiation) is an 'all or nothing' that really seems to break things. There are a handful of small-ish 'cleanup' tasks that I did along the way, and could probably come up with another, but I'm not sure how much I can remove from the patch to split it up :/

[erichkeane]

I pulled out a good amount of this patch as NFC, which should shrink the patch.

I have a 'new approach' that I think will work, which is to suppress the constraint
evaluation the same way we did with the requires clause (though, with a flag,
rather than just being able to skip it).

At the moment, I have 1 lit test failure in Clang. Additionally, I have 2-3 libcxx
failures where we seem to static-assert where we didn't before, PLUS 1 test that seems
to hang. I'm hopeful I am on the right track and can continue to make progress.

[erichkeane]

Ok, fixed the test failure in clang, AND it managed to fix
all the failures in libcxx!

HOWEVER, it appears that libcxx/test/libcxx/modules_include.sh.cpp
is now hanging?

I don't know much about the modules implementation (perhaps someone
like @ChuanqiXu can help out?), so I'm at least somewhat stuck until
I can figure out how to get it to give me more info.

[ChuanqiXu]

In D126907#3710656, @erichkeane wrote:

Ok, fixed the test failure in clang, AND it managed to fix
all the failures in libcxx!

HOWEVER, it appears that libcxx/test/libcxx/modules_include.sh.cpp
is now hanging?

I don't know much about the modules implementation (perhaps someone
like @ChuanqiXu can help out?), so I'm at least somewhat stuck until
I can figure out how to get it to give me more info.

I may not be able to look into the details recently. What's the error message from the modules?

[erichkeane]

In D126907#3711956, @ChuanqiXu wrote:

In D126907#3710656, @erichkeane wrote:

Ok, fixed the test failure in clang, AND it managed to fix
all the failures in libcxx!

HOWEVER, it appears that libcxx/test/libcxx/modules_include.sh.cpp
is now hanging?

I don't know much about the modules implementation (perhaps someone
like @ChuanqiXu can help out?), so I'm at least somewhat stuck until
I can figure out how to get it to give me more info.

I may not be able to look into the details recently. What's the error message from the modules?

At the moment, there IS no error message! Just that the modules_include.sh.cpp test now takes a REALLY long time (I thought it was a 'hang', but it finished overnight). So it is more like an extreme compile-time regression. I can't make heads or tails of what the test is SUPPOSED to be doing, so I don't have a good idea what the issue is, nor what is happening...

[erichkeane]

In D126907#3711956, @ChuanqiXu wrote:

In D126907#3710656, @erichkeane wrote:

Ok, fixed the test failure in clang, AND it managed to fix
all the failures in libcxx!

HOWEVER, it appears that libcxx/test/libcxx/modules_include.sh.cpp
is now hanging?

I don't know much about the modules implementation (perhaps someone
like @ChuanqiXu can help out?), so I'm at least somewhat stuck until
I can figure out how to get it to give me more info.

I may not be able to look into the details recently. What's the error message from the modules?

Looking deeper... this test is a monstrosity (https://github.com/llvm/llvm-project/blob/main/libcxx/test/libcxx/modules_include.sh.cpp), and I'm not necessarily sure it is necessarily modules-related, other than enabling it on every header. So it just seems like one of the STL headers is taking significantly longer to compile? I have no idea how to move forward with this... it AT LEAST "finishes", but it takes a very long time to get through now.

[ChuanqiXu]

In D126907#3712363, @erichkeane wrote:

In D126907#3711956, @ChuanqiXu wrote:

In D126907#3710656, @erichkeane wrote:

Ok, fixed the test failure in clang, AND it managed to fix
all the failures in libcxx!

HOWEVER, it appears that libcxx/test/libcxx/modules_include.sh.cpp
is now hanging?

I don't know much about the modules implementation (perhaps someone
like @ChuanqiXu can help out?), so I'm at least somewhat stuck until
I can figure out how to get it to give me more info.

I may not be able to look into the details recently. What's the error message from the modules?

Looking deeper... this test is a monstrosity (https://github.com/llvm/llvm-project/blob/main/libcxx/test/libcxx/modules_include.sh.cpp), and I'm not necessarily sure it is necessarily modules-related, other than enabling it on every header. So it just seems like one of the STL headers is taking significantly longer to compile? I have no idea how to move forward with this... it AT LEAST "finishes", but it takes a very long time to get through now.

I tried to reproduce and I am not sure if reproduced. With this patch, modules_include.sh.cpp takes 562s to complete. And without this patch, it takes a 557s. So it looks not your fault.

[erichkeane]

In D126907#3715436, @ChuanqiXu wrote:

In D126907#3712363, @erichkeane wrote:

In D126907#3711956, @ChuanqiXu wrote:

In D126907#3710656, @erichkeane wrote:

Ok, fixed the test failure in clang, AND it managed to fix
all the failures in libcxx!

HOWEVER, it appears that libcxx/test/libcxx/modules_include.sh.cpp
is now hanging?

I don't know much about the modules implementation (perhaps someone
like @ChuanqiXu can help out?), so I'm at least somewhat stuck until
I can figure out how to get it to give me more info.

I may not be able to look into the details recently. What's the error message from the modules?

Looking deeper... this test is a monstrosity (https://github.com/llvm/llvm-project/blob/main/libcxx/test/libcxx/modules_include.sh.cpp), and I'm not necessarily sure it is necessarily modules-related, other than enabling it on every header. So it just seems like one of the STL headers is taking significantly longer to compile? I have no idea how to move forward with this... it AT LEAST "finishes", but it takes a very long time to get through now.

I tried to reproduce and I am not sure if reproduced. With this patch, modules_include.sh.cpp takes 562s to complete. And without this patch, it takes a 557s. So it looks not your fault.

Hmm... ok, thanks for checking! I'm going to try to prove to myself that it isn't too bad then. This might just be a case of the Debug version of this taking a horribly long-time and me not noticing it normally.

If that is the case, I think this is ready for review!

[erichkeane]

I think I've proved to myself that there IS a compile-time regression, but it is reasonably minor. I suspect a lot of it is going to be the 'friend' comparisons not caching, which I might look into doing.

[erichkeane]

SO, I charted the differences in runtimes, and my patch is BETTER time-wise in release mode, but WORSE with asserts enabled. I don't know of any expensive assert that I added. SO, if everyone could review this, I'd love to get this committed to see if it beats the buildbots this time:)

[ChuanqiXu]

I am not sure if I don't miss any points. But if it is OK to run libc++/libstdc++, I think it should be good to land this.

clang/include/clang/Sema/Sema.h

3671

The meaning of TemplateDepth is unclear. Do it mean top-down or start from the constraint expression?

clang/include/clang/Sema/Template.h

508–519

Could we remove the duplicates? For example, is it possible to make ConstraintEvalRAII a subclass of Sema?

clang/lib/Sema/SemaTemplateDeduction.cpp

2851–2864

nit:

clang/lib/Sema/SemaTemplateInstantiate.cpp

1232

Do we have any method to detect if the template parameter list lives in a require clause or not? The current duplicating looks a little bit bad.

If there is no such methods, I guess it may be better by using enums:

TemplateParameterList *TransformTemplateParameterList(
                              TemplateParameterList *OrigTPL, enum IsInRequire = Normal) {
   ...
   if (IsInRequire == ...)
      DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
   ...
}

3598–3599

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

2444

Is this used?

[erichkeane]

clang/include/clang/Sema/Sema.h

3671

It is top-down, as the constraint is uninstantiated. I've added a comment to clarify.

clang/include/clang/Sema/Template.h

508–519

It ends up having to be a template, and for a 'getter' to exist, but done.

clang/lib/Sema/SemaTemplateDeduction.cpp

2851–2864

These are specializations, so they cant have a storage class. They inherit them from the primary template.

clang/lib/Sema/SemaTemplateInstantiate.cpp

1232

Turns out I don't think this was required anyway, so I just removed it.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

2444

Yes, see line 2453, 2459, 2470, and 2476.

[erichkeane]

Respond/fix all of the things @ChuanqiXu mentioned. Intend to commit early tomorrow based on latest feedback unless others have concerns.

[Mordante]

This change breaks libc++'s modular build see build https://buildkite.com/llvm-project/libcxx-ci/builds/12991
Reverting this commit on top of yesterday's build (before your revert) fixes the issue.

libc++'s modular build uses Clang's pre-C++20 modules.

It can be reproduced building libc++ and running the following lit invocation
${LIT} -Denable_modules=True libcxx/test/libcxx/ranges/range.adaptors/range.all/all.nodiscard.verify.cpp

If you need assistance testing a new version of this patch on libc++ please let me know.

[erichkeane]

In D126907#3737375, @Mordante wrote:

This change breaks libc++'s modular build see build https://buildkite.com/llvm-project/libcxx-ci/builds/12991
Reverting this commit on top of yesterday's build (before your revert) fixes the issue.

libc++'s modular build uses Clang's pre-C++20 modules.

It can be reproduced building libc++ and running the following lit invocation
${LIT} -Denable_modules=True libcxx/test/libcxx/ranges/range.adaptors/range.all/all.nodiscard.verify.cpp

If you need assistance testing a new version of this patch on libc++ please let me know.

Is this not part of check-runtimes or check-cxx? I ran both of those INCLUDING a modules-builds-all...

[Mordante]

In D126907#3737641, @erichkeane wrote:

In D126907#3737375, @Mordante wrote:

This change breaks libc++'s modular build see build https://buildkite.com/llvm-project/libcxx-ci/builds/12991
Reverting this commit on top of yesterday's build (before your revert) fixes the issue.

libc++'s modular build uses Clang's pre-C++20 modules.

It can be reproduced building libc++ and running the following lit invocation
${LIT} -Denable_modules=True libcxx/test/libcxx/ranges/range.adaptors/range.all/all.nodiscard.verify.cpp

If you need assistance testing a new version of this patch on libc++ please let me know.

Is this not part of check-runtimes or check-cxx? I ran both of those INCLUDING a modules-builds-all...

It should be tested in check-cxx when you use the cmake option -DLIBCXX_TEST_PARAMS="enable_modules=True" and you need to configure libc++ to use your just build clang to be used for the tests. (The command I posted just does a single test, which is faster during bisecting.)

I'm not sure what you mean with modules-builds-all.

[erichkeane]

In D126907#3737986, @Mordante wrote:

In D126907#3737641, @erichkeane wrote:

In D126907#3737375, @Mordante wrote:

This change breaks libc++'s modular build see build https://buildkite.com/llvm-project/libcxx-ci/builds/12991
Reverting this commit on top of yesterday's build (before your revert) fixes the issue.

libc++'s modular build uses Clang's pre-C++20 modules.

It can be reproduced building libc++ and running the following lit invocation
${LIT} -Denable_modules=True libcxx/test/libcxx/ranges/range.adaptors/range.all/all.nodiscard.verify.cpp

If you need assistance testing a new version of this patch on libc++ please let me know.

Is this not part of check-runtimes or check-cxx? I ran both of those INCLUDING a modules-builds-all...

It should be tested in check-cxx when you use the cmake option -DLIBCXX_TEST_PARAMS="enable_modules=True" and you need to configure libc++ to use your just build clang to be used for the tests. (The command I posted just does a single test, which is faster during bisecting.)

I'm not sure what you mean with modules-builds-all.

There was a test I dealt with previously where a ton of the header files were run with modules enabled (and an auto generated files), so I'm shocked to find there is MORE differences here. @ldionne : This is another example where trying to test libcxx is particularly difficult to do apparently.

[Mordante]

In D126907#3738383, @erichkeane wrote:

There was a test I dealt with previously where a ton of the header files were run with modules enabled (and an auto generated files), so I'm shocked to find there is MORE differences here. @ldionne : This is another example where trying to test libcxx is particularly difficult to do apparently.

I disagree; testing libcxx is easy. Unfortunately what's missing is good documentation explaining how to test different configurations. A similar libc++ related issue came up in another Clang review recently where the libc++ CI setup was unclear. Afterwards I had a talk with @aaron.ballman and I agreed to improve the documentation. While improving the documentation I noticed some issues with our CI setup. So before publishing documentation that doesn't reflect reality, I first wanted to fix these issues. While testing my fixes I ran into the build failure due to this patch. So now we're at a full circle.

With the revert of this patch it's possible to fix the CI issues for libc++ and I will continue with improving the documentation.

Note that this specific issue isn't directly detected in the libc++ CI. This would require a full clang build and testing with modules. That's not done, full builds are only tested without modules. If wanted I supply a patch how to test this configuration in the libc++ CI.

If you need further assistance feel free to reach out to me or other libc++ developers, the easiest way to reach us is #libcxx on Discord.

[aaron.ballman]

In D126907#3739750, @Mordante wrote:

In D126907#3738383, @erichkeane wrote:

There was a test I dealt with previously where a ton of the header files were run with modules enabled (and an auto generated files), so I'm shocked to find there is MORE differences here. @ldionne : This is another example where trying to test libcxx is particularly difficult to do apparently.

I disagree; testing libcxx is easy.

FWIW, that's not been my experience. I can't even get libcxx to build for me on Windows with Visual Studio cmake integration, let alone test it. These are the results I got when I tried again today from the instructions from the website:

CMake Error in F:/source/llvm-project/libcxx/benchmarks/CMakeLists.txt:
  No known features for CXX compiler

  "Clang"

  version 16.0.0.


CMake Generate step failed.  Build files cannot be regenerated correctly.
FAILED: runtimes/runtimes-stamps/runtimes-configure

That said, I recall at one point I was able to get libcxx to build for me, but then I ran into issues getting the tests to run (and we document this on the website: "Building with Visual Studio currently does not permit running tests."). The result is that I stopped trying to build or test libcxx locally ages ago and I rely entirely on the bots to tell me if something's gone wrong.

Unfortunately what's missing is good documentation explaining how to test different configurations. A similar libc++ related issue came up in another Clang review recently where the libc++ CI setup was unclear. Afterwards I had a talk with @aaron.ballman and I agreed to improve the documentation. While improving the documentation I noticed some issues with our CI setup. So before publishing documentation that doesn't reflect reality, I first wanted to fix these issues. While testing my fixes I ran into the build failure due to this patch. So now we're at a full circle.

And I greatly appreciate the improvements that have been going on here!

[erichkeane]

In D126907#3739750, @Mordante wrote:

In D126907#3738383, @erichkeane wrote:

There was a test I dealt with previously where a ton of the header files were run with modules enabled (and an auto generated files), so I'm shocked to find there is MORE differences here. @ldionne : This is another example where trying to test libcxx is particularly difficult to do apparently.

I disagree; testing libcxx is easy. Unfortunately what's missing is good documentation explaining how to test different configurations. A similar libc++ related issue came up in another Clang review recently where the libc++ CI setup was unclear. Afterwards I had a talk with @aaron.ballman and I agreed to improve the documentation. While improving the documentation I noticed some issues with our CI setup. So before publishing documentation that doesn't reflect reality, I first wanted to fix these issues. While testing my fixes I ran into the build failure due to this patch. So now we're at a full circle.

With the revert of this patch it's possible to fix the CI issues for libc++ and I will continue with improving the documentation.

Note that this specific issue isn't directly detected in the libc++ CI. This would require a full clang build and testing with modules. That's not done, full builds are only tested without modules. If wanted I supply a patch how to test this configuration in the libc++ CI.

If you need further assistance feel free to reach out to me or other libc++ developers, the easiest way to reach us is #libcxx on Discord.

This is the 3rd time some non-obvious-how-to-run libcxx test failure has caused a revert request to this patch, which is obviously getting frustrating. Additionally, in none of the 3 cases was I alerted automatically.

I appreciate that there are actually ways to RUN these tests on my machine (Aaron is not as lucky, see above), but the lack of a "test all the libcxx things" flag is shocking. It seems that I'd need at least 2 separate CMake directories to test these configurations? That seems shocking to me.

[erichkeane]

FWIW, while I wasn't able to reproduce the problem that @Mordante reported, I found that the test suite as given has a large number of asserts in debug mode while trying to compare parameter-mappings during constraint normalization(assert is clang-15: /iusers/ekeane1/workspaces/delayed-concepts/clang/lib/AST/ASTContext.cpp:4753: clang::QualType clang::ASTContext::getSubstTemplateTypeParmType(const clang::TemplateTypeParmType*, clang::QualType, llvm::Optional<unsigned int>) const: Assertion `Replacement.isCanonical() && "replacement types must always be canonical"' failed.`).

One Reproducer is:

#pragma clang module import std.array
template<std::input_or_output_iterator>
struct iter_value_or_void { using type = void; };
  
template<std::input_iterator I>
struct iter_value_or_void<I> {
    using type = std::iter_value_t<I>;

BUT debugging seems to show a lot of 'imported' symbols that I'm not particularly sure how they work, so I suspect they are coming from the clang-module-import.

So I'm going to have to try to figure out what is going on here with the clang modules.

[Mordante]

In D126907#3739923, @aaron.ballman wrote:

In D126907#3739750, @Mordante wrote:

In D126907#3738383, @erichkeane wrote:

There was a test I dealt with previously where a ton of the header files were run with modules enabled (and an auto generated files), so I'm shocked to find there is MORE differences here. @ldionne : This is another example where trying to test libcxx is particularly difficult to do apparently.

I disagree; testing libcxx is easy.

FWIW, that's not been my experience. I can't even get libcxx to build for me on Windows with Visual Studio cmake integration, let alone test it.

Fair point, I can't vouch for how well that build is supported, since I don't have access to Windows. This version isn't tested in libc++ CI. The other two Windows builds CMake + ninja (MSVC) and CMake + ninja (MSVC) are tested in libc++ CI. The wording on the website is similar to what is used in libc++ CI libcxx/utils/ci/run-buildbot but it misses the -DLIBCXX_EXTRA_SITE_DEFINES="_LIBCPP_HAS_NO_INT128".

Unfortunately what's missing is good documentation explaining how to test different configurations. A similar libc++ related issue came up in another Clang review recently where the libc++ CI setup was unclear. Afterwards I had a talk with @aaron.ballman and I agreed to improve the documentation. While improving the documentation I noticed some issues with our CI setup. So before publishing documentation that doesn't reflect reality, I first wanted to fix these issues. While testing my fixes I ran into the build failure due to this patch. So now we're at a full circle.

And I greatly appreciate the improvements that have been going on here!

You're welcome!

In D126907#3739967, @erichkeane wrote:

In D126907#3739750, @Mordante wrote:

If you need further assistance feel free to reach out to me or other libc++ developers, the easiest way to reach us is #libcxx on Discord.

This is the 3rd time some non-obvious-how-to-run libcxx test failure has caused a revert request to this patch, which is obviously getting frustrating. Additionally, in none of the 3 cases was I alerted automatically.

I understand that it's frustrating. I haven't seen the other two reverts, but by default non libc++ patches aren't tested in the libc++ pre-commit CI. The reason is simple; a pre-commit build runs 50+ builds and takes about one hour to complete. So the CI doesn't have the capacity to test every Clang diff. If you want to run the libc++ pre-commit CI the easiest way is to add a dummy file in the libc++ tree. Note that will add the libc++ review group to this review.

Next to testing pre-commit changes it tests main every 4 hours, but doesn't send e-mails when an error occurs. This is something @ldionne wanted to look into.

This behaviour is exactly the kind of documentation that is missing for Clang developers and what @aaron.ballman and I talked about. (There is more documentation that should be added, but that is generic information.)

I appreciate that there are actually ways to RUN these tests on my machine (Aaron is not as lucky, see above), but the lack of a "test all the libcxx things" flag is shocking. It seems that I'd need at least 2 separate CMake directories to test these configurations? That seems shocking to me.

You can use one libc++ installation to test multiple different configuration as long as they don't use different build-time options. So testing with the different language standards c++03, c++11, c++17, c++20, c++2b, the modular build, and several other options can be done from one build. But you need to invoke the tests for each option or combination of options separately.

If you want to test without wchar_t support you need to build a different libc++, simply since that removes parts of the dylib, like the wchar_t facets from the locales. (Basically the same as when you want to test Clang with or without assertions, there you need two builds too.)

What do you exactly mean with "test all the libcxx things" flag?

[erichkeane]

I get that libcxx doesn't run on precommit CI (which is unfortunate for those of us modifying the CFE), but it becomes difficult to run locally, when check-all (requires check-runtimes or check-cxx) don't cover it, and now even check-cxx doesn't cover it.

What do you exactly mean with "test all the libcxx things" flag?

For example, this enable-modules flag isn't covered by my local check-cxx, which I went out of my way to run on this patch locally.

[erichkeane]

In D126907#3740249, @erichkeane wrote:

FWIW, while I wasn't able to reproduce the problem that @Mordante reported, I found that the test suite as given has a large number of asserts in debug mode while trying to compare parameter-mappings during constraint normalization(assert is clang-15: /iusers/ekeane1/workspaces/delayed-concepts/clang/lib/AST/ASTContext.cpp:4753: clang::QualType clang::ASTContext::getSubstTemplateTypeParmType(const clang::TemplateTypeParmType*, clang::QualType, llvm::Optional<unsigned int>) const: Assertion `Replacement.isCanonical() && "replacement types must always be canonical"' failed.`).

One Reproducer is:

#pragma clang module import std.array
template<std::input_or_output_iterator>
struct iter_value_or_void { using type = void; };
  
template<std::input_iterator I>
struct iter_value_or_void<I> {
    using type = std::iter_value_t<I>;

BUT debugging seems to show a lot of 'imported' symbols that I'm not particularly sure how they work, so I suspect they are coming from the clang-module-import.

So I'm going to have to try to figure out what is going on here with the clang modules.

Fixing the assert was pretty easy, and fixing it revealed the same 8 failures from the buildbot above.

[Mordante]

In D126907#3740536, @erichkeane wrote:

For example, this enable-modules flag isn't covered by my local check-cxx, which I went out of my way to run on this patch locally.

Unfortunately there are a lot of different options and combination of options to test libc++.
So it's indeed not possible to test all options with once check-cxx invocation.

In D126907#3746408, @erichkeane wrote:

Fixing the assert was pretty easy, and fixing it revealed the same 8 failures from the buildbot above.

Great to hear you can reproduce the issue!

[erichkeane]

Still WIP, but uploading to show that I'm still on this :/

The two modules related issues from libcxx are now fixed (as reported by @Mordante), and that configuration builds and passes all tests with MOST of this change.

HOWEVER, the first of two fixes for @wlei messes up how constraint expressions on class templates are compared, so the result is ~800 additional libcxx failures. I'm still working through that.

There is a 2nd bug I found from @wlei 's reproducer which is captured in a commented out test in concepts.cpp.

[ldionne]

In D126907#3746477, @Mordante wrote:

Unfortunately there are a lot of different options and combination of options to test libc++.
So it's indeed not possible to test all options with once check-cxx invocation.

This ^. We could include all the libc++ configurations in a single check-cxx invokation, but the tests would run for like 70 hours on most machines. Instead, we test different configurations in different CI jobs.

In D126907#3777056, @erichkeane wrote:

Still WIP, but uploading to show that I'm still on this :/

The two modules related issues from libcxx are now fixed (as reported by @Mordante), and that configuration builds and passes all tests with MOST of this change.

HOWEVER, the first of two fixes for @wlei messes up how constraint expressions on class templates are compared, so the result is ~800 additional libcxx failures. I'm still working through that.

Just to make sure we're on the same page, I assume most of those issues are things that would have been encountered in user code otherwise and filed as bugs. So in a way, I think libc++ is simply acting like some kind of early-in-the-loop pre-release testing. This is similar to what some other open-source projects like Chrome do -- they build from trunk often and will report actual issues to us early. I do get why it can be annoying and disruptive to landing patches sometimes, though.

Concretely, what we could do is probably add LLVM_ENABLE_RUNTIMES=libcxx to the Clang pre-commit CI that already runs. That would catch some (but of course not all) issues. In particular, that should catch issues that would otherwise immediately break the libc++ "Bootstrapping build" CI job. For other issues (like an arbitrary combination of -std=c++xy -fmodules -fno-rtti), I think we can only rely on slower feedback when libc++ updates the nightly version of Clang that we use in our CI (which would act like a super-early adopter from the POV of Clang at that point).

[erichkeane]

In D126907#3777088, @ldionne wrote:

In D126907#3746477, @Mordante wrote:

Unfortunately there are a lot of different options and combination of options to test libc++.
So it's indeed not possible to test all options with once check-cxx invocation.

This ^. We could include all the libc++ configurations in a single check-cxx invokation, but the tests would run for like 70 hours on most machines. Instead, we test different configurations in different CI jobs.

In D126907#3777056, @erichkeane wrote:

Still WIP, but uploading to show that I'm still on this :/

The two modules related issues from libcxx are now fixed (as reported by @Mordante), and that configuration builds and passes all tests with MOST of this change.

HOWEVER, the first of two fixes for @wlei messes up how constraint expressions on class templates are compared, so the result is ~800 additional libcxx failures. I'm still working through that.

Just to make sure we're on the same page, I assume most of those issues are things that would have been encountered in user code otherwise and filed as bugs. So in a way, I think libc++ is simply acting like some kind of early-in-the-loop pre-release testing. This is similar to what some other open-source projects like Chrome do -- they build from trunk often and will report actual issues to us early. I do get why it can be annoying and disruptive to landing patches sometimes, though.

Yep, this is the case. Just frustrating to be surprised by things like this as late in the process as I was, so I was a little grumpy above. Unfortunately it seems like each of these cycles costs a month here :/

Concretely, what we could do is probably add LLVM_ENABLE_RUNTIMES=libcxx to the Clang pre-commit CI that already runs. That would catch some (but of course not all) issues. In particular, that should catch issues that would otherwise immediately break the libc++ "Bootstrapping build" CI job. For other issues (like an arbitrary combination of -std=c++xy -fmodules -fno-rtti), I think we can only rely on slower feedback when libc++ updates the nightly version of Clang that we use in our CI (which would act like a super-early adopter from the POV of Clang at that point).

[erichkeane]

I have a replacement patch that should fix all of the bugs I'm aware of.

[erichkeane]

Now fully runs libcxx modules configuration as well, and passes the minimization examples from @wlei .

@wlei and anyone else: can you please try running this against your workloads before I commit it?

[erichkeane]

I spoke too soon, I found another crash that came out of @wlei s repro from last time.

[erichkeane]

In D126907#3805640, @erichkeane wrote:

I spoke too soon, I found another crash that came out of @wlei s repro from last time.

Actually, what I found was a reduction that had gone haywire before and generated invalid code, so I don't think it is worth blocking this patch. The actual preprocessed file from @wlei actually compiles perfectly.

[erichkeane]

Failure I noticed was NOT a regression: https://godbolt.org/z/MnvqP88vv

[wlei]

In D126907#3805606, @erichkeane wrote:

Now fully runs libcxx modules configuration as well, and passes the minimization examples from @wlei .

@wlei and anyone else: can you please try running this against your workloads before I commit it?

Thanks for the fix, I will try to run it internally today.

[Mordante]

In D126907#3805606, @erichkeane wrote:

Now fully runs libcxx modules configuration as well, and passes the minimization examples from @wlei .

@wlei and anyone else: can you please try running this against your workloads before I commit it?

I tried this with several configurations (modular, c++2b, c++20, and c++03) in libc++'s bootstrapping build and the tests passed.

[erichkeane]

In D126907#3806760, @Mordante wrote:

In D126907#3805606, @erichkeane wrote:

Now fully runs libcxx modules configuration as well, and passes the minimization examples from @wlei .

@wlei and anyone else: can you please try running this against your workloads before I commit it?

I tried this with several configurations (modular, c++2b, c++20, and c++03) in libc++'s bootstrapping build and the tests passed.

Thank you so much!

[ChuanqiXu]

Tested with our internal workloads and things look fine.

[wlei]

Tested this and confirmed the issue I reported is gone, thanks!

[erichkeane]

In D126907#3807707, @wlei wrote:

Tested this and confirmed the issue I reported is gone, thanks!

Thank you all for the quick responses!

[BertalanD]

Hi @erichkeane,

This change broke compilation of this program (https://godbolt.org/z/KrWGvcf8h; reduced from https://github.com/SerenityOS/ladybird):

template<typename T, typename U>
constexpr bool IsSame = false;

template<typename T>
constexpr bool IsSame<T, T> = true;

template<typename T>
struct Foo {
    template<typename U>
    Foo(U&&) requires (!IsSame<U, Foo>);
};

template<>
struct Foo<void> : Foo<int> {
    using Foo<int>::Foo;
};

Foo<void> test() { return 0; }

<source>:18:27: error: invalid reference to function 'Foo': constraints not satisfied
Foo<void> test() { return 0; }
                          ^
<source>:10:24: note: because substituted constraint expression is ill-formed: value of type '<dependent type>' is not contextually convertible to 'bool'
    Foo(U&&) requires (!IsSame<U, Foo>);
                       ^

[erichkeane]

In D126907#3844788, @BertalanD wrote:

Hi @erichkeane,

This change broke compilation of this program (https://godbolt.org/z/KrWGvcf8h; reduced from https://github.com/SerenityOS/ladybird):

template<typename T, typename U>
constexpr bool IsSame = false;

template<typename T>
constexpr bool IsSame<T, T> = true;

template<typename T>
struct Foo {
    template<typename U>
    Foo(U&&) requires (!IsSame<U, Foo>);
};

template<>
struct Foo<void> : Foo<int> {
    using Foo<int>::Foo;
};

Foo<void> test() { return 0; }

<source>:18:27: error: invalid reference to function 'Foo': constraints not satisfied
Foo<void> test() { return 0; }
                          ^
<source>:10:24: note: because substituted constraint expression is ill-formed: value of type '<dependent type>' is not contextually convertible to 'bool'
    Foo(U&&) requires (!IsSame<U, Foo>);
                       ^

Thanks for the report! I'll look into it ASAP.

[erichkeane]

In D126907#3846591, @erichkeane wrote:

In D126907#3844788, @BertalanD wrote:

Hi @erichkeane,

This change broke compilation of this program (https://godbolt.org/z/KrWGvcf8h; reduced from https://github.com/SerenityOS/ladybird):

template<typename T, typename U>
constexpr bool IsSame = false;

template<typename T>
constexpr bool IsSame<T, T> = true;

template<typename T>
struct Foo {
    template<typename U>
    Foo(U&&) requires (!IsSame<U, Foo>);
};

template<>
struct Foo<void> : Foo<int> {
    using Foo<int>::Foo;
};

Foo<void> test() { return 0; }

<source>:18:27: error: invalid reference to function 'Foo': constraints not satisfied
Foo<void> test() { return 0; }
                          ^
<source>:10:24: note: because substituted constraint expression is ill-formed: value of type '<dependent type>' is not contextually convertible to 'bool'
    Foo(U&&) requires (!IsSame<U, Foo>);
                       ^

Thanks for the report! I'll look into it ASAP.

Quick note: I believe I understand the cause of this, which requires a bit more work than I otherwise would have expected. I have a candidate patch I'm running through my testing right now that should fix this, but it still needs cleaning up. Expect it in the next day or two if all goes well.

[BertalanD]

In D126907#3849583, @erichkeane wrote:

In D126907#3846591, @erichkeane wrote:

In D126907#3844788, @BertalanD wrote:

Hi @erichkeane,

This change broke compilation of this program (https://godbolt.org/z/KrWGvcf8h; reduced from https://github.com/SerenityOS/ladybird):

template<typename T, typename U>
constexpr bool IsSame = false;

template<typename T>
constexpr bool IsSame<T, T> = true;

template<typename T>
struct Foo {
    template<typename U>
    Foo(U&&) requires (!IsSame<U, Foo>);
};

template<>
struct Foo<void> : Foo<int> {
    using Foo<int>::Foo;
};

Foo<void> test() { return 0; }

<source>:18:27: error: invalid reference to function 'Foo': constraints not satisfied
Foo<void> test() { return 0; }
                          ^
<source>:10:24: note: because substituted constraint expression is ill-formed: value of type '<dependent type>' is not contextually convertible to 'bool'
    Foo(U&&) requires (!IsSame<U, Foo>);
                       ^

Thanks for the report! I'll look into it ASAP.

Quick note: I believe I understand the cause of this, which requires a bit more work than I otherwise would have expected. I have a candidate patch I'm running through my testing right now that should fix this, but it still needs cleaning up. Expect it in the next day or two if all goes well.

Thank you for your quick response and for creating this massive yak shave of a patch :D

Please ping me if you want me to test the fix on our code, or if I can help in some other way.

[erichkeane]

In D126907#3849583, @erichkeane wrote:

In D126907#3846591, @erichkeane wrote:

In D126907#3844788, @BertalanD wrote:

Hi @erichkeane,

This change broke compilation of this program (https://godbolt.org/z/KrWGvcf8h; reduced from https://github.com/SerenityOS/ladybird):

template<typename T, typename U>
constexpr bool IsSame = false;

template<typename T>
constexpr bool IsSame<T, T> = true;

template<typename T>
struct Foo {
    template<typename U>
    Foo(U&&) requires (!IsSame<U, Foo>);
};

template<>
struct Foo<void> : Foo<int> {
    using Foo<int>::Foo;
};

Foo<void> test() { return 0; }

<source>:18:27: error: invalid reference to function 'Foo': constraints not satisfied
Foo<void> test() { return 0; }
                          ^
<source>:10:24: note: because substituted constraint expression is ill-formed: value of type '<dependent type>' is not contextually convertible to 'bool'
    Foo(U&&) requires (!IsSame<U, Foo>);
                       ^

Thanks for the report! I'll look into it ASAP.

Quick note: I believe I understand the cause of this, which requires a bit more work than I otherwise would have expected. I have a candidate patch I'm running through my testing right now that should fix this, but it still needs cleaning up. Expect it in the next day or two if all goes well.

In D126907#3850735, @BertalanD wrote:

In D126907#3849583, @erichkeane wrote:

In D126907#3846591, @erichkeane wrote:

In D126907#3844788, @BertalanD wrote:

Hi @erichkeane,

This change broke compilation of this program (https://godbolt.org/z/KrWGvcf8h; reduced from https://github.com/SerenityOS/ladybird):

template<typename T, typename U>
constexpr bool IsSame = false;

template<typename T>
constexpr bool IsSame<T, T> = true;

template<typename T>
struct Foo {
    template<typename U>
    Foo(U&&) requires (!IsSame<U, Foo>);
};

template<>
struct Foo<void> : Foo<int> {
    using Foo<int>::Foo;
};

Foo<void> test() { return 0; }

<source>:18:27: error: invalid reference to function 'Foo': constraints not satisfied
Foo<void> test() { return 0; }
                          ^
<source>:10:24: note: because substituted constraint expression is ill-formed: value of type '<dependent type>' is not contextually convertible to 'bool'
    Foo(U&&) requires (!IsSame<U, Foo>);
                       ^

Thanks for the report! I'll look into it ASAP.

Quick note: I believe I understand the cause of this, which requires a bit more work than I otherwise would have expected. I have a candidate patch I'm running through my testing right now that should fix this, but it still needs cleaning up. Expect it in the next day or two if all goes well.

Thank you for your quick response and for creating this massive yak shave of a patch :D

Please ping me if you want me to test the fix on our code, or if I can help in some other way.

Thanks for the offer! I ended up taking a less-aggressive yak shave on this one, and have a patch here: https://reviews.llvm.org/D135772

If you could give it a try, it would be very useful!

[BertalanD]

I tried out D135772, and our build got significantly farther than before! I unfortunately discovered another piece of code that pre babdef27c503c0bbbcc017e9f88affddda90ea4e Clang and GCC accept in C++20 mode, but Clang trunk does not (https://godbolt.org/z/q1q4nfobK):

struct String {
  String(char *);
  bool operator==(String const &);
  void operator!=(String const &);
};

extern char* c;
extern String s;
int test() {
  return c == s;
}

<source>:10:12: error: invalid operands to binary expression ('char *' and 'String')
  return c == s;
         ~ ^  ~

[erichkeane]

In D126907#3852909, @BertalanD wrote:

I tried out D135772, and our build got significantly farther than before! I unfortunately discovered another piece of code that pre babdef27c503c0bbbcc017e9f88affddda90ea4e Clang and GCC accept in C++20 mode, but Clang trunk does not (https://godbolt.org/z/q1q4nfobK):

struct String {
  String(char *);
  bool operator==(String const &);
  void operator!=(String const &);
};

extern char* c;
extern String s;
int test() {
  return c == s;
}

<source>:10:12: error: invalid operands to binary expression ('char *' and 'String')
  return c == s;
         ~ ^  ~

Thanks! I'll look into that as well.

[BertalanD]

(I know this is a very contrived example with void operator!=, but that is what CVise spat out, and the actual failures are related to comparison operators too)

edit: hah, it repros when it returns bool too -- not sure how that void came to be...

[erichkeane]

In D126907#3852975, @BertalanD wrote:

(I know this is a very contrived example with void operator!=, but that is what CVise spat out, and the actual failures are related to comparison operators too)

edit: hah, it repros when it returns bool too -- not sure how that void came to be...

Looking more closely at that, I don't think it has anything to do with this patch. I know operator== (and the materialized inverse) stuff was worked on separately recently by @Uthkarsh in 38b9d313e6945804fffc654f849cfa05ba2c713d. See: https://reviews.llvm.org/D134529

The Equality-operator stuff has been particularly awkward in the C++ committee I think (whether or not reversed candidates work or not have had a bunch of tweaking), so you'll have to follow that up there.

[cor3ntin]

@erichkeane I was looking at Daisy meta programming shenanigans and found this crashes https://cute.godbolt.org/z/6fWoEheKc - seems related to your work, probably? It used to work in Clang 15. I thought you might want to know!

[erichkeane]

In D126907#3854983, @cor3ntin wrote:

@erichkeane I was looking at Daisy meta programming shenanigans and found this crashes https://cute.godbolt.org/z/6fWoEheKc - seems related to your work, probably? It used to work in Clang 15. I thought you might want to know!

Thanks! I'll take a look. That DOES look like some other failures I've had with this patch.

[erichkeane]

In D126907#3855552, @erichkeane wrote:

In D126907#3854983, @cor3ntin wrote:

@erichkeane I was looking at Daisy meta programming shenanigans and found this crashes https://cute.godbolt.org/z/6fWoEheKc - seems related to your work, probably? It used to work in Clang 15. I thought you might want to know!

Thanks! I'll take a look. That DOES look like some other failures I've had with this patch.

I've reduced it a bit to remove the STL stuff, but it looks like the template-lambda is a part of it: https://cute.godbolt.org/z/Prh6xsesz

It manages to hit quite a few things that I suspect the getTemplateInstantiationArgs doesn't get right, so I'm guessing the 'fix' is going to be in there somewhere. I'll start taking a look this week.

[erichkeane]

Daisy's bug ended up being more complicated than I expected... there is a lot to unpack here. In the meantime, I've captured the bug here: https://github.com/llvm/llvm-project/issues/58368 and will continue looking at it.

[mizvekov]

clang/lib/Sema/SemaConcept.cpp

513–534

Unchecked access to MLTAL (Optional).

Following reduction reproduces a crash here: -cc1 -std=c++20 -fsyntax-only -ferror-limit 19.

template a b < ;
template c e ag < ;
ah) ;
am = ;
template <class... ap> class aq {
  aq(ap...; __attribute__) auto aj() requires(am)
}
f() {                  [;                  aq d;                  d.aj

[mizvekov]

clang/lib/Sema/SemaConcept.cpp

513–534

By the way, disregard that repro, it needs another patch that is not in master.

The unchecked access still does look suspicious though.

[erichkeane]

clang/lib/Sema/SemaConcept.cpp

513–534

Thanks for the comment! I'll look into it.

[erichkeane]

clang/lib/Sema/SemaConcept.cpp

513–534

Huh... that must be leftover from some other attempt I made at that, the MLTAL is always set. I'll do an NFC patch to remove it, but thanks for looking!

[erichkeane]

clang/lib/Sema/SemaConcept.cpp

513–534

Woops... nvm... you're right, in an error condition we can get an errored one. I'll add a check. Thanks again!

clang/docs/ReleaseNotes.rst

 - Fixes an assert crash caused by looking up missing vtable information on ``consteval``
   virtual functions. Fixes `Issue 55065 <https://github.com/llvm/llvm-project/issues/55065>`_.
 - Skip rebuilding lambda expressions in arguments of immediate invocations.
   This fixes `Issue 56183 <https://github.com/llvm/llvm-project/issues/56183>`_,
   `Issue 51695 <https://github.com/llvm/llvm-project/issues/51695>`_,
   `Issue 50455 <https://github.com/llvm/llvm-project/issues/50455>`_,
   `Issue 54872 <https://github.com/llvm/llvm-project/issues/54872>`_,
   `Issue 54587 <https://github.com/llvm/llvm-project/issues/54587>`_.
+- Clang now correctly delays the instantiation of function constraints until
+  the time of checking, which should now allow the libstdc++ ranges implementation
+  to work for at least trivial examples.  This fixes
+  `Issue 44178 <https://github.com/llvm/llvm-project/issues/44178>`_.
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Support label at end of compound statement (`P2324 <https://wg21.link/p2324r2>`_).
 
 CUDA/HIP Language Changes in Clang
 ----------------------------------

clang/include/clang/AST/ASTContext.h

public:
   /// nested-name-specifier, which itself contains all canonical
   /// types, values, and templates.
   TemplateName getCanonicalTemplateName(const TemplateName &Name) const;
 
   /// Determine whether the given template names refer to the same
   /// template.
   bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const;
 
+  /// Determine whether two Friend functions are different because constraints
+  /// that refer to an enclosing template, according to [temp.friend] p9.
+  bool FriendsDifferByConstraints(const FunctionDecl *X,
+                                  const FunctionDecl *Y) const;
+
   /// Determine whether the two declarations refer to the same entity.
   bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const;
 
   /// Determine whether two template parameter lists are similar enough
   /// that they may be used in declarations of the same template.
   bool isSameTemplateParameterList(const TemplateParameterList *X,
                                    const TemplateParameterList *Y) const;
 

clang/include/clang/AST/Decl.h

private:
   /// declarations that describe a function template, this will be a pointer to
   /// a FunctionTemplateDecl, stored in the NamedDecl. For member functions of
   /// class template specializations, this will be a MemberSpecializationInfo
   /// pointer containing information about the specialization.
   /// For function template specializations, this will be a
   /// FunctionTemplateSpecializationInfo, which contains information about
   /// the template being specialized and the template arguments involved in
   /// that specialization.
   llvm::PointerUnion<NamedDecl *, MemberSpecializationInfo *,
                      FunctionTemplateSpecializationInfo *,
                      DependentFunctionTemplateSpecializationInfo *>
       TemplateOrSpecialization;
 
   /// Provides source/type location info for the declaration name embedded in
   /// the DeclaratorDecl base class.
   DeclarationNameLoc DNLoc;
 
   /// Specify that this function declaration is actually a function
public:
   }
 
   /// Sets the multiversion state for this declaration and all of its
   /// redeclarations.
   void setIsMultiVersion(bool V = true) {
     getCanonicalDecl()->FunctionDeclBits.IsMultiVersion = V;
   }
 
+  // Sets that this is a constrained friend where the constraint refers to an
+  // enclosing template.
+  void setFriendConstraintRefersToEnclosingTemplate(bool V = true) {
+    getCanonicalDecl()
+        ->FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate = V;
+  }
+  // Indicates this function is a constrained friend, where the constraint
+  // refers to an enclosing template for hte purposes of [temp.friend]p9.
+  bool FriendConstraintRefersToEnclosingTemplate() const {
+    return getCanonicalDecl()
+        ->FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate;
+  }
+
   /// Gets the kind of multiversioning attribute this declaration has. Note that
   /// this can return a value even if the function is not multiversion, such as
   /// the case of 'target'.
   MultiVersionKind getMultiVersionKind() const;
 
 
   /// True if this function is a multiversioned dispatch function as a part of
   /// the cpu_specific/cpu_dispatch functionality.

clang/include/clang/AST/DeclBase.h

class FunctionDeclBitfields {
     /// deduction candidate' (is used during overload resolution).
     uint64_t IsCopyDeductionCandidate : 1;
 
     /// Store the ODRHash after first calculation.
     uint64_t HasODRHash : 1;
 
     /// Indicates if the function uses Floating Point Constrained Intrinsics
     uint64_t UsesFPIntrin : 1;
+
+    // Indicates this function is a constrained friend, where the constraint
+    // refers to an enclosing template for hte purposes of [temp.friend]p9.
+    uint64_t FriendConstraintRefersToEnclosingTemplate : 1;
   };
 
   /// Number of non-inherited bits in FunctionDeclBitfields.
-  enum { NumFunctionDeclBits = 28 };
+  enum { NumFunctionDeclBits = 29 };
 
   /// Stores the bits used by CXXConstructorDecl. If modified
   /// NumCXXConstructorDeclBits and the accessor
   /// methods in CXXConstructorDecl should be updated appropriately.
   class CXXConstructorDeclBitfields {
     friend class CXXConstructorDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
     /// For the bits in FunctionDeclBitfields.
     uint64_t : NumFunctionDeclBits;
 
-    /// 23 bits to fit in the remaining available space.
+    /// 22 bits to fit in the remaining available space.
     /// Note that this makes CXXConstructorDeclBitfields take
     /// exactly 64 bits and thus the width of NumCtorInitializers
     /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
     /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
-    uint64_t NumCtorInitializers : 20;
+    uint64_t NumCtorInitializers : 19;
     uint64_t IsInheritingConstructor : 1;
 
     /// Whether this constructor has a trail-allocated explicit specifier.
     uint64_t HasTrailingExplicitSpecifier : 1;
     /// If this constructor does't have a trail-allocated explicit specifier.
     /// Whether this constructor is explicit specified.
     uint64_t IsSimpleExplicit : 1;
   };

clang/include/clang/Sema/Sema.h

OverloadKind CheckOverload(Scope *S,
                              FunctionDecl *New,
                              const LookupResult &OldDecls,
                              NamedDecl *&OldDecl,
                              bool IsForUsingDecl);
   bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
                   bool ConsiderCudaAttrs = true,
                   bool ConsiderRequiresClauses = true);
 
+  // Calculates whether the expression Constraint depends on an enclosing
+  // template, for the purposes of [temp.friend] p9.
+  // TemplateDepth is the 'depth' of the friend function, which is used to
+  // compare whether a declaration reference is referring to a containing
+  // template, or just the current friend function. A 'lower' TemplateDepth in
+  // the AST refers to a 'containing' template. As the constraint is
+  // uninstantiated, this is relative to the 'top' of the TU.
+  bool ConstraintExpressionDependsOnEnclosingTemplate(unsigned TemplateDepth,
+                                                      const Expr *Constraint);
+
+  // Calculates whether the friend function depends on an enclosing template for
+  // the purposes of [temp.friend] p9.
+  bool FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD);
+
+  // Calculates whether two constraint expressions are equal irrespective of a
+  // difference in 'depth'. This takes a pair of optional 'NamedDecl's 'Old' and
+  // 'New', which are the "source" of the constraint, since this is necessary
+  // for figuring out the relative 'depth' of the constraint. The depth of the
+  // 'primary template' and the 'instantiated from' templates aren't necessarily
+  // the same, such as a case when one is a 'friend' defined in a class.
+  bool AreConstraintExpressionsEqual(const NamedDecl *Old,
+                                     const Expr *OldConstr,
+                                     const NamedDecl *New,
+                                     const Expr *NewConstr);
+
   enum class AllowedExplicit {
     /// Allow no explicit functions to be used.
     None,
     /// Allow explicit conversion functions but not explicit constructors.
     Conversions,
     /// Allow both explicit conversion functions and explicit constructors.
     All
   };
private:
   /// Introduce the instantiated function parameters into the local
   /// instantiation scope, and set the parameter names to those used
   /// in the template.
   bool addInstantiatedParametersToScope(
       FunctionDecl *Function, const FunctionDecl *PatternDecl,
       LocalInstantiationScope &Scope,
       const MultiLevelTemplateArgumentList &TemplateArgs);
 
+  /// used by SetupConstraintCheckingTemplateArgumentsAndScope to recursively(in
+  /// the case of lambdas) set up the LocalInstantiationScope of the current
+  /// function.
+  bool SetupConstraintScope(
+      FunctionDecl *FD, llvm::Optional<ArrayRef<TemplateArgument>> TemplateArgs,
+      MultiLevelTemplateArgumentList MLTAL, LocalInstantiationScope &Scope);
+
+  /// Used during constraint checking, sets up the constraint template arguemnt
+  /// lists, and calls SetupConstraintScope to set up the
+  /// LocalInstantiationScope to have the proper set of ParVarDecls configured.
+  llvm::Optional<MultiLevelTemplateArgumentList>
+  SetupConstraintCheckingTemplateArgumentsAndScope(
+      FunctionDecl *FD, llvm::Optional<ArrayRef<TemplateArgument>> TemplateArgs,
+      LocalInstantiationScope &Scope);
+
 public:
   const NormalizedConstraint *
   getNormalizedAssociatedConstraints(
       NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
 
   /// \brief Check whether the given declaration's associated constraints are
   /// at least as constrained than another declaration's according to the
   /// partial ordering of constraints.
   ///
   /// \param Result If no error occurred, receives the result of true if D1 is
   /// at least constrained than D2, and false otherwise.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
                               NamedDecl *D2, ArrayRef<const Expr *> AC2,
                               bool &Result);
 
   /// If D1 was not at least as constrained as D2, but would've been if a pair
   /// of atomic constraints involved had been declared in a concept and not
   /// repeated in two separate places in code.
public:
   /// \param Satisfaction if true is returned, will contain details of the
   /// satisfaction, with enough information to diagnose an unsatisfied
   /// expression.
   /// \returns true if an error occurred and satisfaction could not be checked,
   /// false otherwise.
   bool CheckConstraintSatisfaction(
       const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
       const MultiLevelTemplateArgumentList &TemplateArgLists,
+      SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
+    llvm::SmallVector<Expr *, 4> Converted;
+    return CheckConstraintSatisfaction(Template, ConstraintExprs, Converted,
+                                       TemplateArgLists, TemplateIDRange,
+                                       Satisfaction);
+  }
+
+  /// \brief Check whether the given list of constraint expressions are
+  /// satisfied (as if in a 'conjunction') given template arguments.
+  /// Additionally, takes an empty list of Expressions which is populated with
+  /// the instantiated versions of the ConstraintExprs.
+  /// \param Template the template-like entity that triggered the constraints
+  /// check (either a concept or a constrained entity).
+  /// \param ConstraintExprs a list of constraint expressions, treated as if
+  /// they were 'AND'ed together.
+  /// \param ConvertedConstraints a out parameter that will get populated with
+  /// the instantiated version of the ConstraintExprs if we successfully checked
+  /// satisfaction.
+  /// \param TemplateArgList the multi-level list of template arguments to
+  /// substitute into the constraint expression. This should be relative to the
+  /// top-level (hence multi-level), since we need to instantiate fully at the
+  /// time of checking.
+  /// \param TemplateIDRange The source range of the template id that
+  /// caused the constraints check.
+  /// \param Satisfaction if true is returned, will contain details of the
+  /// satisfaction, with enough information to diagnose an unsatisfied
+  /// expression.
+  /// \returns true if an error occurred and satisfaction could not be checked,
+  /// false otherwise.
+  bool CheckConstraintSatisfaction(
+      const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+      llvm::SmallVectorImpl<Expr *> &ConvertedConstraints,
+      const MultiLevelTemplateArgumentList &TemplateArgList,
       SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
 
   /// \brief Check whether the given non-dependent constraint expression is
   /// satisfied. Returns false and updates Satisfaction with the satisfaction
   /// verdict if successful, emits a diagnostic and returns true if an error
   /// occurred and satisfaction could not be determined.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
                                    ConstraintSatisfaction &Satisfaction);
 
   /// Check whether the given function decl's trailing requires clause is
   /// satisfied, if any. Returns false and updates Satisfaction with the
   /// satisfaction verdict if successful, emits a diagnostic and returns true if
   /// an error occurred and satisfaction could not be determined.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool CheckFunctionConstraints(const FunctionDecl *FD,
                                 ConstraintSatisfaction &Satisfaction,
-                                SourceLocation UsageLoc = SourceLocation());
-
+                                SourceLocation UsageLoc = SourceLocation(),
+                                bool ForOverloadResolution = false);
 
   /// \brief Ensure that the given template arguments satisfy the constraints
   /// associated with the given template, emitting a diagnostic if they do not.
   ///
   /// \param Template The template to which the template arguments are being
   /// provided.
   ///
   /// \param TemplateArgs The converted, canonicalized template arguments.
enum TemplateParameterListEqualKind {
     /// \code
     /// template<template<int Value> class Metafun> struct X;
     /// template<int Value> struct integer_c;
     /// X<integer_c> xic;
     /// \endcode
     TPL_TemplateTemplateArgumentMatch
   };
 
-  bool TemplateParameterListsAreEqual(TemplateParameterList *New,
-                                      TemplateParameterList *Old,
-                                      bool Complain,
-                                      TemplateParameterListEqualKind Kind,
-                                      SourceLocation TemplateArgLoc
-                                        = SourceLocation());
+  bool TemplateParameterListsAreEqual(
+      const NamedDecl *NewInstFrom, TemplateParameterList *New,
+      const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain,
+      SourceLocation TemplateArgLoc = SourceLocation());
+
+  bool TemplateParameterListsAreEqual(
+      TemplateParameterList *New, TemplateParameterList *Old, bool Complain,
+      TemplateParameterListEqualKind Kind,
+      SourceLocation TemplateArgLoc = SourceLocation()) {
+    return TemplateParameterListsAreEqual(nullptr, New, nullptr, Old, Complain,
+                                          Kind, TemplateArgLoc);
+  }
 
   bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
 
   /// Called when the parser has parsed a C++ typename
   /// specifier, e.g., "typename T::type".
   ///
   /// \param S The scope in which this typename type occurs.
   /// \param TypenameLoc the location of the 'typename' keyword
static void MarkDeducedTemplateParameters(ASTContext &Ctx,
                                   llvm::SmallBitVector &Deduced);
 
   //===--------------------------------------------------------------------===//
   // C++ Template Instantiation
   //
 
   MultiLevelTemplateArgumentList getTemplateInstantiationArgs(
       const NamedDecl *D, const TemplateArgumentList *Innermost = nullptr,
-      bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr);
+      bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr,
+      bool LookBeyondLambda = false, bool IncludeContainingStruct = false);
 
   /// A context in which code is being synthesized (where a source location
   /// alone is not sufficient to identify the context). This covers template
   /// instantiation and various forms of implicitly-generated functions.
   struct CodeSynthesisContext {
     /// The kind of template instantiation we are performing
     enum SynthesisKind {
       /// We are instantiating a template declaration. The entity is

   QualType SubstType(QualType T,
                      const MultiLevelTemplateArgumentList &TemplateArgs,
                      SourceLocation Loc, DeclarationName Entity);
 
   TypeSourceInfo *SubstType(TypeLoc TL,
                             const MultiLevelTemplateArgumentList &TemplateArgs,
                             SourceLocation Loc, DeclarationName Entity);
 
-  TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                                        SourceLocation Loc,
-                                        DeclarationName Entity,
-                                        CXXRecordDecl *ThisContext,
-                                        Qualifiers ThisTypeQuals);
+  TypeSourceInfo *SubstFunctionDeclType(
+      TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs,
+      SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext,
+      Qualifiers ThisTypeQuals, bool EvaluateConstraints = true);
   void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
                           const MultiLevelTemplateArgumentList &Args);
   bool SubstExceptionSpec(SourceLocation Loc,
                           FunctionProtoType::ExceptionSpecInfo &ESI,
                           SmallVectorImpl<QualType> &ExceptionStorage,
                           const MultiLevelTemplateArgumentList &Args);
-  ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                                int indexAdjustment,
-                                Optional<unsigned> NumExpansions,
-                                bool ExpectParameterPack);
+  ParmVarDecl *
+  SubstParmVarDecl(ParmVarDecl *D,
+                   int indexAdjustment, Optional<unsigned> NumExpansions,
+                   bool ExpectParameterPack, bool EvaluateConstraints = true);
   bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
                       const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SmallVectorImpl<QualType> &ParamTypes,
                       SmallVectorImpl<ParmVarDecl *> *OutParams,
                       ExtParameterInfoBuilder &ParamInfos);
   ExprResult SubstExpr(Expr *E,
                        const MultiLevelTemplateArgumentList &TemplateArgs);
 
+  // A RAII type used by the TemplateDeclInstantiator and TemplateInstantiator
+  // to disable constraint evaluation, then restore the state.
+  template <typename InstTy> struct ConstraintEvalRAII {
+    InstTy &TI;
+    bool OldValue;
+
+    ConstraintEvalRAII(InstTy &TI)
+        : TI(TI), OldValue(TI.getEvaluateConstraints()) {
+      TI.setEvaluateConstraints(false);
+    }
+    ~ConstraintEvalRAII() { TI.setEvaluateConstraints(OldValue); }
+  };
+
+  // Unlike the above, this evaluates constraints, which should only happen at
+  // 'constraint checking' time.
+  ExprResult
+  SubstConstraintExpr(Expr *E,
+                      const MultiLevelTemplateArgumentList &TemplateArgs);
+
   /// Substitute the given template arguments into a list of
   /// expressions, expanding pack expansions if required.
   ///
   /// \param Exprs The list of expressions to substitute into.
   ///
   /// \param IsCall Whether this is some form of call, in which case
   /// default arguments will be dropped.
   ///

   SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
                       const MultiLevelTemplateArgumentList &TemplateArgs);
 
   bool
   SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
                          TemplateArgumentListInfo &Outputs);
 
-
   Decl *SubstDecl(Decl *D, DeclContext *Owner,
                   const MultiLevelTemplateArgumentList &TemplateArgs);
 
   /// Substitute the name and return type of a defaulted 'operator<=>' to form
   /// an implicit 'operator=='.
   FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
                                            FunctionDecl *Spaceship);
 

   SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
                            const MultiLevelTemplateArgumentList &TemplateArgs);
   TemplateName
   SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
                     SourceLocation Loc,
                     const MultiLevelTemplateArgumentList &TemplateArgs);
 
   bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
-                           const MultiLevelTemplateArgumentList &TemplateArgs);
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EvaluateConstraint);
 
   bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
                                   ParmVarDecl *Param);
   void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                 FunctionDecl *Function);
   bool CheckInstantiatedFunctionTemplateConstraints(
       SourceLocation PointOfInstantiation, FunctionDecl *Decl,
       ArrayRef<TemplateArgument> TemplateArgs,

clang/include/clang/Sema/Template.h

public:
     /// Retrieve the innermost template argument list.
     const ArgList &getInnermost() const {
       return TemplateArgumentLists.front();
     }
     /// Retrieve the outermost template argument list.
     const ArgList &getOutermost() const {
       return TemplateArgumentLists.back();
     }
     ArgListsIterator begin() { return TemplateArgumentLists.begin(); }
     ConstArgListsIterator begin() const {
       return TemplateArgumentLists.begin();
     }
     ArgListsIterator end() { return TemplateArgumentLists.end(); }
     ConstArgListsIterator end() const { return TemplateArgumentLists.end(); }
   };
 
   /// The context in which partial ordering of function templates occurs.
   enum TPOC {
     /// Partial ordering of function templates for a function call.
     TPOC_Call,
 
     /// Partial ordering of function templates for a call to a
class TemplateDeclInstantiator
     : public DeclVisitor<TemplateDeclInstantiator, Decl *>
   {
     Sema &SemaRef;
     Sema::ArgumentPackSubstitutionIndexRAII SubstIndex;
     DeclContext *Owner;
     const MultiLevelTemplateArgumentList &TemplateArgs;
     Sema::LateInstantiatedAttrVec* LateAttrs = nullptr;
     LocalInstantiationScope *StartingScope = nullptr;
+    bool EvaluateConstraints = true;
 
     /// A list of out-of-line class template partial
     /// specializations that will need to be instantiated after the
     /// enclosing class's instantiation is complete.
     SmallVector<std::pair<ClassTemplateDecl *,
                                 ClassTemplatePartialSpecializationDecl *>, 4>
       OutOfLinePartialSpecs;
 
     /// A list of out-of-line variable template partial
     /// specializations that will need to be instantiated after the
     /// enclosing variable's instantiation is complete.
     /// FIXME: Verify that this is needed.
     SmallVector<
         std::pair<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>, 4>
     OutOfLineVarPartialSpecs;
 
   public:
     TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner,
                              const MultiLevelTemplateArgumentList &TemplateArgs)
         : SemaRef(SemaRef),
           SubstIndex(SemaRef, SemaRef.ArgumentPackSubstitutionIndex),
           Owner(Owner), TemplateArgs(TemplateArgs) {}
 
+    void setEvaluateConstraints(bool B) {
+      EvaluateConstraints = B;
+    }
+    bool getEvaluateConstraints() {
+      return EvaluateConstraints;
+    }
+
 // Define all the decl visitors using DeclNodes.inc
 #define DECL(DERIVED, BASE) \
     Decl *Visit ## DERIVED ## Decl(DERIVED ## Decl *D);
 #define ABSTRACT_DECL(DECL)
 
 // Decls which never appear inside a class or function.
 #define OBJCCONTAINER(DERIVED, BASE)
 #define FILESCOPEASM(DERIVED, BASE)

clang/lib/AST/ASTContext.cpp

for (auto Pair : zip_longest(AEnableIfAttrs, BEnableIfAttrs)) {
     // Return false if any of the enable_if expressions of A and B are
     // different.
     if (Cand1ID != Cand2ID)
       return false;
   }
   return true;
 }
 
+bool ASTContext::FriendsDifferByConstraints(const FunctionDecl *X,
+                                            const FunctionDecl *Y) const {
+  // If these aren't friends, then they aren't friends that differ by
+  // constraints.
+  if (!X->getFriendObjectKind() || !Y->getFriendObjectKind())
+    return false;
+
+  // If the the two functions share lexical declaration context, they are not in
+  // separate instantations, and thus in the same scope.
+  if (X->getLexicalDeclContext() == Y->getLexicalDeclContext())
+    return false;
+
+  if (!X->getDescribedFunctionTemplate()) {
+    assert(!Y->getDescribedFunctionTemplate() &&
+           "How would these be the same if they aren't both templates?");
+
+    // If these friends don't have constraints, they aren't constrained, and
+    // thus don't fall under temp.friend p9. Else the simple presence of a
+    // constraint makes them unique.
+    return X->getTrailingRequiresClause();
+  }
+
+  return X->FriendConstraintRefersToEnclosingTemplate();
+}
+
 bool ASTContext::isSameEntity(const NamedDecl *X, const NamedDecl *Y) const {
   if (X == Y)
     return true;
 
   if (X->getDeclName() != Y->getDeclName())
     return false;
 
   // Must be in the same context.
if (FuncX->isMultiVersion()) {
       if (TAX->getFeaturesStr() != TAY->getFeaturesStr())
         return false;
     }
 
     if (!isSameConstraintExpr(FuncX->getTrailingRequiresClause(),
                               FuncY->getTrailingRequiresClause()))
       return false;
 
+    // Constrained friends are different in certain cases, see: [temp.friend]p9.
+    if (FriendsDifferByConstraints(FuncX, FuncY))
+      return false;
+
     auto GetTypeAsWritten = [](const FunctionDecl *FD) {
       // Map to the first declaration that we've already merged into this one.
       // The TSI of redeclarations might not match (due to calling conventions
       // being inherited onto the type but not the TSI), but the TSI type of
       // the first declaration of the function should match across modules.
       FD = FD->getCanonicalDecl();
       return FD->getTypeSourceInfo() ? FD->getTypeSourceInfo()->getType()
                                      : FD->getType();

clang/lib/AST/ASTImporter.cpp

ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
   ToFunction->setAccess(D->getAccess());
   ToFunction->setLexicalDeclContext(LexicalDC);
   ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
   ToFunction->setTrivial(D->isTrivial());
   ToFunction->setPure(D->isPure());
   ToFunction->setDefaulted(D->isDefaulted());
   ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
   ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
+  ToFunction->setFriendConstraintRefersToEnclosingTemplate(
+      D->FriendConstraintRefersToEnclosingTemplate());
   ToFunction->setRangeEnd(ToEndLoc);
 
   // Set the parameters.
   for (auto *Param : Parameters) {
     Param->setOwningFunction(ToFunction);
     ToFunction->addDeclInternal(Param);
     if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
       LT->update(Param, Importer.getToContext().getTranslationUnitDecl());

clang/lib/AST/Decl.cpp

FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
   FunctionDeclBits.InstantiationIsPending = false;
   FunctionDeclBits.UsesSEHTry = false;
   FunctionDeclBits.UsesFPIntrin = UsesFPIntrin;
   FunctionDeclBits.HasSkippedBody = false;
   FunctionDeclBits.WillHaveBody = false;
   FunctionDeclBits.IsMultiVersion = false;
   FunctionDeclBits.IsCopyDeductionCandidate = false;
   FunctionDeclBits.HasODRHash = false;
+  FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate = false;
   if (TrailingRequiresClause)
     setTrailingRequiresClause(TrailingRequiresClause);
 }
 
 void FunctionDecl::getNameForDiagnostic(
     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
   const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
FunctionTemplateDecl *FunctionDecl::getDescribedFunctionTemplate() const {
   return dyn_cast_or_null<FunctionTemplateDecl>(
       TemplateOrSpecialization.dyn_cast<NamedDecl *>());
 }
 
 void FunctionDecl::setDescribedFunctionTemplate(
     FunctionTemplateDecl *Template) {
   assert(TemplateOrSpecialization.isNull() &&
          "Member function is already a specialization");
   TemplateOrSpecialization = Template;
 }
 
 void FunctionDecl::setInstantiatedFromDecl(FunctionDecl *FD) {
   assert(TemplateOrSpecialization.isNull() &&
          "Function is already a specialization");
   TemplateOrSpecialization = FD;
 }
 

clang/lib/Sema/SemaConcept.cpp

 //===-- SemaConcept.cpp - Semantic Analysis for Constraints and Concepts --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ constraints and concepts.
 //
 //===----------------------------------------------------------------------===//
 
+#include "TreeTransform.h"
 #include "clang/Sema/SemaConcept.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/Initialization.h"
+#include "clang/AST/ASTLambda.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/OperatorPrecedence.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace clang;
 using namespace sema;
 
 namespace {
 class LogicalBinOp {
+  SourceLocation Loc;
   OverloadedOperatorKind Op = OO_None;
   const Expr *LHS = nullptr;
   const Expr *RHS = nullptr;
 
 public:
   LogicalBinOp(const Expr *E) {
     if (auto *BO = dyn_cast<BinaryOperator>(E)) {
       Op = BinaryOperator::getOverloadedOperator(BO->getOpcode());
       LHS = BO->getLHS();
       RHS = BO->getRHS();
+      Loc = BO->getExprLoc();
     } else if (auto *OO = dyn_cast<CXXOperatorCallExpr>(E)) {
       // If OO is not || or && it might not have exactly 2 arguments.
       if (OO->getNumArgs() == 2) {
         Op = OO->getOperator();
         LHS = OO->getArg(0);
         RHS = OO->getArg(1);
+        Loc = OO->getOperatorLoc();
       }
     }
   }
 
   bool isAnd() const { return Op == OO_AmpAmp; }
   bool isOr() const { return Op == OO_PipePipe; }
   explicit operator bool() const { return isAnd() || isOr(); }
 
   const Expr *getLHS() const { return LHS; }
   const Expr *getRHS() const { return RHS; }
+
+  ExprResult recreateBinOp(Sema &SemaRef, ExprResult LHS) const {
+    return recreateBinOp(SemaRef, LHS, const_cast<Expr *>(getRHS()));
+  }
+
+  ExprResult recreateBinOp(Sema &SemaRef, ExprResult LHS,
+                           ExprResult RHS) const {
+    assert((isAnd() || isOr()) && "Not the right kind of op?");
+    assert((!LHS.isInvalid() && !RHS.isInvalid()) && "not good expressions?");
+
+    if (!LHS.isUsable() || !RHS.isUsable())
+      return ExprEmpty();
+
+    // We should just be able to 'normalize' these to the builtin Binary
+    // Operator, since that is how they are evaluated in constriant checks.
+    return BinaryOperator::Create(SemaRef.Context, LHS.get(), RHS.get(),
+                                  BinaryOperator::getOverloadedOpcode(Op),
+                                  SemaRef.Context.BoolTy, VK_PRValue,
+                                  OK_Ordinary, Loc, FPOptionsOverride{});
+  }
 };
 }
 
 bool Sema::CheckConstraintExpression(const Expr *ConstraintExpression,
                                      Token NextToken, bool *PossibleNonPrimary,
                                      bool IsTrailingRequiresClause) {
   // C++2a [temp.constr.atomic]p1
   // ..E shall be a constant expression of type bool.
bool Sema::CheckConstraintExpression(const Expr *ConstraintExpression,
   }
 
   if (PossibleNonPrimary)
       *PossibleNonPrimary = false;
   return true;
 }
 
 template <typename AtomicEvaluator>
-static bool
+static ExprResult
 calculateConstraintSatisfaction(Sema &S, const Expr *ConstraintExpr,
                                 ConstraintSatisfaction &Satisfaction,
                                 AtomicEvaluator &&Evaluator) {
   ConstraintExpr = ConstraintExpr->IgnoreParenImpCasts();
 
   if (LogicalBinOp BO = ConstraintExpr) {
-    if (calculateConstraintSatisfaction(S, BO.getLHS(), Satisfaction,
-                                        Evaluator))
-      return true;
+    ExprResult LHSRes = calculateConstraintSatisfaction(
+        S, BO.getLHS(), Satisfaction, Evaluator);
+
+    if (LHSRes.isInvalid())
+      return ExprError();
 
     bool IsLHSSatisfied = Satisfaction.IsSatisfied;
 
     if (BO.isOr() && IsLHSSatisfied)
       // [temp.constr.op] p3
       //    A disjunction is a constraint taking two operands. To determine if
       //    a disjunction is satisfied, the satisfaction of the first operand
       //    is checked. If that is satisfied, the disjunction is satisfied.
       //    Otherwise, the disjunction is satisfied if and only if the second
       //    operand is satisfied.
-      return false;
+      return BO.recreateBinOp(S, LHSRes);
 
     if (BO.isAnd() && !IsLHSSatisfied)
       // [temp.constr.op] p2
       //    A conjunction is a constraint taking two operands. To determine if
       //    a conjunction is satisfied, the satisfaction of the first operand
       //    is checked. If that is not satisfied, the conjunction is not
       //    satisfied. Otherwise, the conjunction is satisfied if and only if
       //    the second operand is satisfied.
-      return false;
+      return BO.recreateBinOp(S, LHSRes);
 
-    return calculateConstraintSatisfaction(
+    ExprResult RHSRes = calculateConstraintSatisfaction(
         S, BO.getRHS(), Satisfaction, std::forward<AtomicEvaluator>(Evaluator));
-  } else if (auto *C = dyn_cast<ExprWithCleanups>(ConstraintExpr)) {
-    return calculateConstraintSatisfaction(S, C->getSubExpr(), Satisfaction,
+    if (RHSRes.isInvalid())
+      return ExprError();
+
+    return BO.recreateBinOp(S, LHSRes, RHSRes);
+  }
+
+  if (auto *C = dyn_cast<ExprWithCleanups>(ConstraintExpr)) {
+    // These aren't evaluated, so we don't care about cleanups, so we can just
+    // evaluate these as if the cleanups didn't exist.
+    return calculateConstraintSatisfaction(
+        S, C->getSubExpr(), Satisfaction,
         std::forward<AtomicEvaluator>(Evaluator));
   }
 
   // An atomic constraint expression
   ExprResult SubstitutedAtomicExpr = Evaluator(ConstraintExpr);
 
   if (SubstitutedAtomicExpr.isInvalid())
-    return true;
+    return ExprError();
 
   if (!SubstitutedAtomicExpr.isUsable())
     // Evaluator has decided satisfaction without yielding an expression.
-    return false;
+    return ExprEmpty();
 
   EnterExpressionEvaluationContext ConstantEvaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
   SmallVector<PartialDiagnosticAt, 2> EvaluationDiags;
   Expr::EvalResult EvalResult;
   EvalResult.Diag = &EvaluationDiags;
   if (!SubstitutedAtomicExpr.get()->EvaluateAsConstantExpr(EvalResult,
                                                            S.Context) ||
       !EvaluationDiags.empty()) {
     // C++2a [temp.constr.atomic]p1
     //   ...E shall be a constant expression of type bool.
     S.Diag(SubstitutedAtomicExpr.get()->getBeginLoc(),
            diag::err_non_constant_constraint_expression)
         << SubstitutedAtomicExpr.get()->getSourceRange();
     for (const PartialDiagnosticAt &PDiag : EvaluationDiags)
       S.Diag(PDiag.first, PDiag.second);
-    return true;
+    return ExprError();
   }
 
   assert(EvalResult.Val.isInt() &&
          "evaluating bool expression didn't produce int");
   Satisfaction.IsSatisfied = EvalResult.Val.getInt().getBoolValue();
   if (!Satisfaction.IsSatisfied)
     Satisfaction.Details.emplace_back(ConstraintExpr,
                                       SubstitutedAtomicExpr.get());
 
-  return false;
+  return SubstitutedAtomicExpr;
 }
 
-static bool calculateConstraintSatisfaction(
+static ExprResult calculateConstraintSatisfaction(
     Sema &S, const NamedDecl *Template, SourceLocation TemplateNameLoc,
     const MultiLevelTemplateArgumentList &MLTAL, const Expr *ConstraintExpr,
     ConstraintSatisfaction &Satisfaction) {
   return calculateConstraintSatisfaction(
       S, ConstraintExpr, Satisfaction, [&](const Expr *AtomicExpr) {
         EnterExpressionEvaluationContext ConstantEvaluated(
             S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
         // Atomic constraint - substitute arguments and check satisfaction.
         ExprResult SubstitutedExpression;
         {
           TemplateDeductionInfo Info(TemplateNameLoc);
           Sema::InstantiatingTemplate Inst(S, AtomicExpr->getBeginLoc(),
               Sema::InstantiatingTemplate::ConstraintSubstitution{},
               const_cast<NamedDecl *>(Template), Info,
               AtomicExpr->getSourceRange());
           if (Inst.isInvalid())
             return ExprError();
           // We do not want error diagnostics escaping here.
           Sema::SFINAETrap Trap(S);
-          SubstitutedExpression = S.SubstExpr(const_cast<Expr *>(AtomicExpr),
-                                              MLTAL);
+          SubstitutedExpression =
+              S.SubstConstraintExpr(const_cast<Expr *>(AtomicExpr), MLTAL);
           // Substitution might have stripped off a contextual conversion to
           // bool if this is the operand of an '&&' or '||'. For example, we
           // might lose an lvalue-to-rvalue conversion here. If so, put it back
           // before we try to evaluate.
           if (!SubstitutedExpression.isInvalid())
             SubstitutedExpression =
                 S.PerformContextuallyConvertToBool(SubstitutedExpression.get());
           if (SubstitutedExpression.isInvalid() || Trap.hasErrorOccurred()) {
return calculateConstraintSatisfaction(
           return ExprError();
 
         return SubstitutedExpression;
       });
 }
 
 static bool CheckConstraintSatisfaction(
     Sema &S, const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+    llvm::SmallVectorImpl<Expr *> &Converted,
     const MultiLevelTemplateArgumentList &TemplateArgsLists,
     SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction) {
   if (ConstraintExprs.empty()) {
     Satisfaction.IsSatisfied = true;
     return false;
   }
 
   if (TemplateArgsLists.isAnyArgInstantiationDependent()) {
     // No need to check satisfaction for dependent constraint expressions.
     Satisfaction.IsSatisfied = true;
     return false;
   }
 
   ArrayRef<TemplateArgument> TemplateArgs =
       TemplateArgsLists.getNumSubstitutedLevels() > 0
           ? TemplateArgsLists.getOutermost()
           : ArrayRef<TemplateArgument> {};
   Sema::InstantiatingTemplate Inst(S, TemplateIDRange.getBegin(),
       Sema::InstantiatingTemplate::ConstraintsCheck{},
       const_cast<NamedDecl *>(Template), TemplateArgs, TemplateIDRange);
   if (Inst.isInvalid())
     return true;
 
   for (const Expr *ConstraintExpr : ConstraintExprs) {
-    if (calculateConstraintSatisfaction(S, Template, TemplateIDRange.getBegin(),
-                                        TemplateArgsLists, ConstraintExpr,
-                                        Satisfaction))
+    ExprResult Res = calculateConstraintSatisfaction(
+        S, Template, TemplateIDRange.getBegin(), TemplateArgsLists,
+        ConstraintExpr, Satisfaction);
+    if (Res.isInvalid())
       return true;
-    if (!Satisfaction.IsSatisfied)
+
+    Converted.push_back(Res.get());
+    if (!Satisfaction.IsSatisfied) {
+      // Backfill the 'converted' list with nulls so we can keep the Converted
+      // and unconverted lists in sync.
+      Converted.append(ConstraintExprs.size() - Converted.size(), nullptr);
       // [temp.constr.op] p2
-      //   [...] To determine if a conjunction is satisfied, the satisfaction
-      //   of the first operand is checked. If that is not satisfied, the
-      //   conjunction is not satisfied. [...]
+      // [...] To determine if a conjunction is satisfied, the satisfaction
+      // of the first operand is checked. If that is not satisfied, the
+      // conjunction is not satisfied. [...]
       return false;
     }
+  }
   return false;
 }
 
 bool Sema::CheckConstraintSatisfaction(
     const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
+    llvm::SmallVectorImpl<Expr *> &ConvertedConstraints,
     const MultiLevelTemplateArgumentList &TemplateArgsLists,
     SourceRange TemplateIDRange, ConstraintSatisfaction &OutSatisfaction) {
   if (ConstraintExprs.empty()) {
     OutSatisfaction.IsSatisfied = true;
     return false;
   }
   if (!Template) {
-    return ::CheckConstraintSatisfaction(*this, nullptr, ConstraintExprs,
-                                         TemplateArgsLists, TemplateIDRange,
-                                         OutSatisfaction);
+    return ::CheckConstraintSatisfaction(
+        *this, nullptr, ConstraintExprs, ConvertedConstraints,
+        TemplateArgsLists, TemplateIDRange, OutSatisfaction);
   }
 
   // A list of the template argument list flattened in a predictible manner for
   // the purposes of caching. The ConstraintSatisfaction type is in AST so it
   // has no access to the MultiLevelTemplateArgumentList, so this has to happen
   // here.
   llvm::SmallVector<TemplateArgument, 4> FlattenedArgs;
   for (ArrayRef<TemplateArgument> List : TemplateArgsLists)
     FlattenedArgs.insert(FlattenedArgs.end(), List.begin(), List.end());
 
   llvm::FoldingSetNodeID ID;
   ConstraintSatisfaction::Profile(ID, Context, Template, FlattenedArgs);
   void *InsertPos;
   if (auto *Cached = SatisfactionCache.FindNodeOrInsertPos(ID, InsertPos)) {
     OutSatisfaction = *Cached;
     return false;
   }
   auto Satisfaction =
       std::make_unique<ConstraintSatisfaction>(Template, FlattenedArgs);
   if (::CheckConstraintSatisfaction(*this, Template, ConstraintExprs,
-                                    TemplateArgsLists, TemplateIDRange,
-                                    *Satisfaction)) {
+                                    ConvertedConstraints, TemplateArgsLists,
+                                    TemplateIDRange, *Satisfaction)) {
     return true;
   }
   OutSatisfaction = *Satisfaction;
   // We cannot use InsertPos here because CheckConstraintSatisfaction might have
   // invalidated it.
   // Note that entries of SatisfactionCache are deleted in Sema's destructor.
   SatisfactionCache.InsertNode(Satisfaction.release());
   return false;
 }
 
 bool Sema::CheckConstraintSatisfaction(const Expr *ConstraintExpr,
                                        ConstraintSatisfaction &Satisfaction) {
   return calculateConstraintSatisfaction(
              *this, ConstraintExpr, Satisfaction,
              [this](const Expr *AtomicExpr) -> ExprResult {
                // We only do this to immitate lvalue-to-rvalue conversion.
-        return PerformContextuallyConvertToBool(const_cast<Expr *>(AtomicExpr));
-      });
+               return PerformContextuallyConvertToBool(
+                   const_cast<Expr *>(AtomicExpr));
+             })
+      .isInvalid();
+}
+
+bool Sema::SetupConstraintScope(
+    FunctionDecl *FD, llvm::Optional<ArrayRef<TemplateArgument>> TemplateArgs,
+    MultiLevelTemplateArgumentList MLTAL, LocalInstantiationScope &Scope) {
+  if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
+    FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate();
+    InstantiatingTemplate Inst(
+        *this, FD->getPointOfInstantiation(),
+        Sema::InstantiatingTemplate::ConstraintsCheck{}, PrimaryTemplate,
+        TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
+        SourceRange());
+    if (Inst.isInvalid())
+      return true;
+
+    // addInstantiatedParametersToScope creates a map of 'uninstantiated' to
+    // 'instantiated' parameters and adds it to the context. For the case where
+    // this function is a template being instantiated NOW, we also need to add
+    // the list of current template arguments to the list so that they also can
+    // be picked out of the map.
+    if (auto *SpecArgs = FD->getTemplateSpecializationArgs()) {
+      MultiLevelTemplateArgumentList JustTemplArgs(*SpecArgs);
+      if (addInstantiatedParametersToScope(
+              FD, PrimaryTemplate->getTemplatedDecl(), Scope, JustTemplArgs))
+        return true;
+    }
+
+    // If this is a member function, make sure we get the parameters that
+    // reference the original primary template.
+    if (const auto *FromMemTempl =
+            PrimaryTemplate->getInstantiatedFromMemberTemplate()) {
+      if (addInstantiatedParametersToScope(FD, FromMemTempl->getTemplatedDecl(),
+                                           Scope, MLTAL))
+        return true;
+    }
+
+    return false;
+  }
+
+  if (FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
+      FD->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate) {
+    FunctionDecl *InstantiatedFrom =
+        FD->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization
+            ? FD->getInstantiatedFromMemberFunction()
+            : FD->getInstantiatedFromDecl();
+
+    InstantiatingTemplate Inst(
+        *this, FD->getPointOfInstantiation(),
+        Sema::InstantiatingTemplate::ConstraintsCheck{}, InstantiatedFrom,
+        TemplateArgs ? *TemplateArgs : ArrayRef<TemplateArgument>{},
+        SourceRange());
+    if (Inst.isInvalid())
+      return true;
+
+    // Case where this was not a template, but instantiated as a
+    // child-function.
+    if (addInstantiatedParametersToScope(FD, InstantiatedFrom, Scope, MLTAL))
+      return true;
+  }
+
+  return false;
+}
+
+// This function collects all of the template arguments for the purposes of
+// constraint-instantiation and checking.
+llvm::Optional<MultiLevelTemplateArgumentList>
+Sema::SetupConstraintCheckingTemplateArgumentsAndScope(
+    FunctionDecl *FD, llvm::Optional<ArrayRef<TemplateArgument>> TemplateArgs,
+    LocalInstantiationScope &Scope) {
+  MultiLevelTemplateArgumentList MLTAL;
+
+  // Collect the list of template arguments relative to the 'primary' template.
+  // We need the entire list, since the constraint is completely uninstantiated
+  // at this point.
+  MLTAL = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary*/ true,
+                                       /*Pattern*/ nullptr,
+                                       /*LookBeyondLambda*/ true);
+  if (SetupConstraintScope(FD, TemplateArgs, MLTAL, Scope))
+    return {};
+
+  return MLTAL;
 }
 
 bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
                                     ConstraintSatisfaction &Satisfaction,
-                                    SourceLocation UsageLoc) {
-  const Expr *RC = FD->getTrailingRequiresClause();
-  if (RC->isInstantiationDependent()) {
+                                    SourceLocation UsageLoc,
+                                    bool ForOverloadResolution) {
+  // Don't check constraints if the function is dependent. Also don't check if
+  // this is a function template specialization, as the call to
+  // CheckinstantiatedFunctionTemplateConstraints after this will check it
+  // better.
+  if (FD->isDependentContext() ||
+      FD->getTemplatedKind() ==
+          FunctionDecl::TK_FunctionTemplateSpecialization) {
     Satisfaction.IsSatisfied = true;
     return false;
   }
+
+  ContextRAII SavedContext{
+      *this, cast<DeclContext>(
+                 const_cast<FunctionDecl *>(FD)->getNonClosureContext())};
+  LocalInstantiationScope Scope(*this, !ForOverloadResolution ||
+                                           isLambdaCallOperator(FD));
+  llvm::Optional<MultiLevelTemplateArgumentList> MLTAL =
+      SetupConstraintCheckingTemplateArgumentsAndScope(
+          const_cast<FunctionDecl *>(FD), {}, Scope);
+
   Qualifiers ThisQuals;
   CXXRecordDecl *Record = nullptr;
   if (auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
     ThisQuals = Method->getMethodQualifiers();
     Record = const_cast<CXXRecordDecl *>(Method->getParent());
   }
   CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
   // We substitute with empty arguments in order to rebuild the atomic
   // constraint in a constant-evaluated context.
   // FIXME: Should this be a dedicated TreeTransform?
-  return CheckConstraintSatisfaction(
-      FD, {RC}, /*TemplateArgs=*/{},
+  const Expr *RC = FD->getTrailingRequiresClause();
+  llvm::SmallVector<Expr *, 1> Converted;
+
+  if (CheckConstraintSatisfaction(
+          FD, {RC}, Converted, *MLTAL,
           SourceRange(UsageLoc.isValid() ? UsageLoc : FD->getLocation()),
-      Satisfaction);
+          Satisfaction))
+    return true;
+
+  // FIXME: we need to do this for the function constraints for
+  // comparison of constraints to work, but do we also need to do it for
+  // CheckInstantiatedFunctionConstraints?  That one is more difficult, but we
+  // seem to always just pick up the constraints from the primary template.
+  assert(Converted.size() <= 1 && "Got more expressions converted?");
+  if (!Converted.empty() && Converted[0] != nullptr)
+    const_cast<FunctionDecl *>(FD)->setTrailingRequiresClause(Converted[0]);
+  return false;
+}
+
+
+// Figure out the to-translation-unit depth for this function declaration for
+// the purpose of seeing if they differ by constraints. This isn't the same as
+// getTemplateDepth, because it includes already instantiated parents.
+static unsigned CalculateTemplateDepthForConstraints(Sema &S,
+                                                     const NamedDecl *ND) {
+  MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
+      ND, nullptr, /*RelativeToPrimary*/ true,
+      /*Pattern*/ nullptr,
+      /*LookBeyondLambda*/ true, /*IncludeContainingStruct*/ true);
+  return MLTAL.getNumSubstitutedLevels();
+}
+
+namespace {
+  class AdjustConstraintDepth : public TreeTransform<AdjustConstraintDepth> {
+  unsigned TemplateDepth = 0;
+  public:
+  using inherited = TreeTransform<AdjustConstraintDepth>;
+  AdjustConstraintDepth(Sema &SemaRef, unsigned TemplateDepth)
+      : inherited(SemaRef), TemplateDepth(TemplateDepth) {}
+  QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
+                                         TemplateTypeParmTypeLoc TL) {
+    const TemplateTypeParmType *T = TL.getTypePtr();
+
+    TemplateTypeParmDecl *NewTTPDecl = nullptr;
+    if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
+      NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
+          TransformDecl(TL.getNameLoc(), OldTTPDecl));
+
+    QualType Result = getSema().Context.getTemplateTypeParmType(
+        T->getDepth() + TemplateDepth, T->getIndex(), T->isParameterPack(),
+        NewTTPDecl);
+    TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
+    NewTL.setNameLoc(TL.getNameLoc());
+    return Result;
+  }
+  };
+} // namespace
+
+bool Sema::AreConstraintExpressionsEqual(const NamedDecl *Old,
+                                         const Expr *OldConstr,
+                                         const NamedDecl *New,
+                                         const Expr *NewConstr) {
+  if (Old && New && Old != New) {
+    unsigned Depth1 = CalculateTemplateDepthForConstraints(
+        *this, Old);
+    unsigned Depth2 = CalculateTemplateDepthForConstraints(
+        *this, New);
+
+    // Adjust the 'shallowest' verison of this to increase the depth to match
+    // the 'other'.
+    if (Depth2 > Depth1) {
+      OldConstr = AdjustConstraintDepth(*this, Depth2 - Depth1)
+                      .TransformExpr(const_cast<Expr *>(OldConstr))
+                      .get();
+    } else if (Depth1 > Depth2) {
+      NewConstr = AdjustConstraintDepth(*this, Depth1 - Depth2)
+                      .TransformExpr(const_cast<Expr *>(NewConstr))
+                      .get();
+    }
+  }
+
+  llvm::FoldingSetNodeID ID1, ID2;
+  OldConstr->Profile(ID1, Context, /*Canonical=*/true);
+  NewConstr->Profile(ID2, Context, /*Canonical=*/true);
+  return ID1 == ID2;
+}
+
+bool Sema::FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD) {
+  assert(FD->getFriendObjectKind() && "Must be a friend!");
+
+  // The logic for non-templates is handled in ASTContext::isSameEntity, so we
+  // don't have to bother checking 'DependsOnEnclosingTemplate' for a
+  // non-function-template.
+  assert(FD->getDescribedFunctionTemplate() &&
+         "Non-function templates don't need to be checked");
+
+  SmallVector<const Expr *, 3> ACs;
+  FD->getDescribedFunctionTemplate()->getAssociatedConstraints(ACs);
+
+  unsigned OldTemplateDepth = CalculateTemplateDepthForConstraints(*this, FD);
+  for (const Expr *Constraint : ACs)
+    if (ConstraintExpressionDependsOnEnclosingTemplate(OldTemplateDepth,
+                                                       Constraint))
+      return true;
+
+  return false;
 }
 
 bool Sema::EnsureTemplateArgumentListConstraints(
     TemplateDecl *TD, const MultiLevelTemplateArgumentList &TemplateArgsLists,
     SourceRange TemplateIDRange) {
   ConstraintSatisfaction Satisfaction;
   llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
   TD->getAssociatedConstraints(AssociatedConstraints);
if (TemplateAC.empty()) {
     Satisfaction.IsSatisfied = true;
     return false;
   }
 
   // Enter the scope of this instantiation. We don't use
   // PushDeclContext because we don't have a scope.
   Sema::ContextRAII savedContext(*this, Decl);
   LocalInstantiationScope Scope(*this);
-  MultiLevelTemplateArgumentList MLTAL;
-  // FIXME: This will be replaced with some logic to get all the template
-  // arguments when we switch to deferred template instantiation.
-  MLTAL.addOuterTemplateArguments(TemplateArgs);
 
-  // If this is not an explicit specialization - we need to get the instantiated
-  // version of the template arguments and add them to scope for the
-  // substitution.
-  if (Decl->isTemplateInstantiation()) {
-    InstantiatingTemplate Inst(*this, Decl->getPointOfInstantiation(),
-        InstantiatingTemplate::ConstraintsCheck{}, Decl->getPrimaryTemplate(),
-        TemplateArgs, SourceRange());
-    if (Inst.isInvalid())
-      return true;
-    MultiLevelTemplateArgumentList MLTAL(
-        *Decl->getTemplateSpecializationArgs());
-    if (addInstantiatedParametersToScope(
-            Decl, Decl->getPrimaryTemplate()->getTemplatedDecl(), Scope, MLTAL))
-      return true;
-  }
+  Optional<MultiLevelTemplateArgumentList> MLTAL =
+      SetupConstraintCheckingTemplateArgumentsAndScope(Decl, TemplateArgs,
+                                                       Scope);
+
+  if (!MLTAL)
+
   Qualifiers ThisQuals;
   CXXRecordDecl *Record = nullptr;
   if (auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
     ThisQuals = Method->getMethodQualifiers();
     Record = Method->getParent();
   }
   CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
-  return CheckConstraintSatisfaction(Template, TemplateAC, MLTAL,
+  llvm::SmallVector<Expr *, 1> Converted;
+  return CheckConstraintSatisfaction(Template, TemplateAC, Converted, *MLTAL,
                                      PointOfInstantiation, Satisfaction);
 }
 
 static void diagnoseUnsatisfiedRequirement(Sema &S,
                                            concepts::ExprRequirement *Req,
                                            bool First) {
   assert(!Req->isSatisfied()
          && "Diagnose() can only be used on an unsatisfied requirement");
CacheEntry =
                              ? new (Context) NormalizedConstraint(
                                  std::move(*Normalized))
                              : nullptr)
             .first;
   }
   return CacheEntry->second;
 }
 
-static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
-    ConceptDecl *Concept, ArrayRef<TemplateArgument> TemplateArgs,
+static bool
+substituteParameterMappings(Sema &S, NormalizedConstraint &N,
+                            ConceptDecl *Concept,
+                            const MultiLevelTemplateArgumentList &MLTAL,
                             const ASTTemplateArgumentListInfo *ArgsAsWritten) {
   if (!N.isAtomic()) {
-    if (substituteParameterMappings(S, N.getLHS(), Concept, TemplateArgs,
+    if (substituteParameterMappings(S, N.getLHS(), Concept, MLTAL,
                                     ArgsAsWritten))
       return true;
-    return substituteParameterMappings(S, N.getRHS(), Concept, TemplateArgs,
+    return substituteParameterMappings(S, N.getRHS(), Concept, MLTAL,
                                        ArgsAsWritten);
   }
   TemplateParameterList *TemplateParams = Concept->getTemplateParameters();
 
   AtomicConstraint &Atomic = *N.getAtomicConstraint();
   TemplateArgumentListInfo SubstArgs;
-  MultiLevelTemplateArgumentList MLTAL;
-  MLTAL.addOuterTemplateArguments(TemplateArgs);
   if (!Atomic.ParameterMapping) {
     llvm::SmallBitVector OccurringIndices(TemplateParams->size());
     S.MarkUsedTemplateParameters(Atomic.ConstraintExpr, /*OnlyDeduced=*/false,
                                  /*Depth=*/0, OccurringIndices);
     TemplateArgumentLoc *TempArgs =
         new (S.Context) TemplateArgumentLoc[OccurringIndices.count()];
     for (unsigned I = 0, J = 0, C = TemplateParams->size(); I != C; ++I)
       if (OccurringIndices[I])
substituteParameterMappings(Sema &S, NormalizedConstraint &N,
   TemplateArgumentLoc *TempArgs =
       new (S.Context) TemplateArgumentLoc[SubstArgs.size()];
   std::copy(SubstArgs.arguments().begin(), SubstArgs.arguments().end(),
             TempArgs);
   Atomic.ParameterMapping.emplace(TempArgs, SubstArgs.size());
   return false;
 }
 
+static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
+                                        const ConceptSpecializationExpr *CSE) {
+  TemplateArgumentList TAL{TemplateArgumentList::OnStack,
+                           CSE->getTemplateArguments()};
+  MultiLevelTemplateArgumentList MLTAL =
+      S.getTemplateInstantiationArgs(CSE->getNamedConcept(), &TAL,
+                                     /*RelativeToPrimary*/ true,
+                                     /*Pattern*/ nullptr,
+                                     /*LookBeyondLambda*/ true);
+
+  return substituteParameterMappings(S, N, CSE->getNamedConcept(), MLTAL,
+                                     CSE->getTemplateArgsAsWritten());
+}
+
 Optional<NormalizedConstraint>
 NormalizedConstraint::fromConstraintExprs(Sema &S, NamedDecl *D,
                                           ArrayRef<const Expr *> E) {
   assert(E.size() != 0);
   auto Conjunction = fromConstraintExpr(S, D, E[0]);
   if (!Conjunction)
     return None;
   for (unsigned I = 1; I < E.size(); ++I) {
const NormalizedConstraint *SubNF;
                                                    {CD->getConstraintExpr()});
       if (!SubNF)
         return None;
     }
 
     Optional<NormalizedConstraint> New;
     New.emplace(S.Context, *SubNF);
 
-    if (substituteParameterMappings(
-            S, *New, CSE->getNamedConcept(),
-            CSE->getTemplateArguments(), CSE->getTemplateArgsAsWritten()))
+    if (substituteParameterMappings(S, *New, CSE))
       return None;
 
     return New;
   }
   return NormalizedConstraint{new (S.Context) AtomicConstraint(S, E)};
 }
 
 using NormalForm =

clang/lib/Sema/SemaDecl.cpp

if (getLangOpts().OpenCLCPlusPlus) {
       if (FunctionTemplate) {
         Diag(D.getIdentifierLoc(), diag::err_template_kernel);
         D.setInvalidType();
       }
     }
   }
 
   if (getLangOpts().CPlusPlus) {
+    // Precalculate whether this is a friend function template with a constraint
+    // that depends on an enclosing template, per [temp.friend]p9.
+    if (isFriend && FunctionTemplate &&
+        FriendConstraintsDependOnEnclosingTemplate(NewFD))
+      NewFD->setFriendConstraintRefersToEnclosingTemplate(true);
+
     if (FunctionTemplate) {
       if (NewFD->isInvalidDecl())
         FunctionTemplate->setInvalidDecl();
       return FunctionTemplate;
     }
 
     if (isMemberSpecialization && !NewFD->isInvalidDecl())
       CompleteMemberSpecialization(NewFD, Previous);

clang/lib/Sema/SemaExpr.cpp

if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     //   trailing requires-clause whose constraint-expression is not satisfied,
     //   other than to declare it, is ill-formed. [...]
     //
     // See if this is a function with constraints that need to be satisfied.
     // Check this before deducing the return type, as it might instantiate the
     // definition.
     if (FD->getTrailingRequiresClause()) {
       ConstraintSatisfaction Satisfaction;
-      if (CheckFunctionConstraints(FD, Satisfaction, Loc))
+      if (CheckFunctionConstraints(FD, Satisfaction, Loc,
+                                   /*ForOverloadResolution*/ true))
         // A diagnostic will have already been generated (non-constant
         // constraint expression, for example)
         return true;
       if (!Satisfaction.IsSatisfied) {
         Diag(Loc,
              diag::err_reference_to_function_with_unsatisfied_constraints)
             << D;
         DiagnoseUnsatisfiedConstraint(Satisfaction);

clang/lib/Sema/SemaOverload.cpp

for (LookupResult::iterator I = Old.begin(), E = Old.end();
     NamedDecl *OldD = *I;
 
     bool OldIsUsingDecl = false;
     if (isa<UsingShadowDecl>(OldD)) {
       OldIsUsingDecl = true;
 
       // We can always introduce two using declarations into the same
       // context, even if they have identical signatures.
       if (NewIsUsingDecl) continue;
 
       OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
     }
 
     // A using-declaration does not conflict with another declaration
     // if one of them is hidden.
     if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
       continue;
if (FunctionDecl *OldF = OldD->getAsFunction()) {
           HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
           continue;
         }
 
         if (!isa<FunctionTemplateDecl>(OldD) &&
             !shouldLinkPossiblyHiddenDecl(*I, New))
           continue;
 
+        // C++20 [temp.friend] p9: A non-template friend declaration with a
+        // requires-clause shall be a definition.  A friend function template
+        // with a constraint that depends on a template parameter from an
+        // enclosing template shall be a definition.  Such a constrained friend
+        // function or function template declaration does not declare the same
+        // function or function template as a declaration in any other scope.
+        if (Context.FriendsDifferByConstraints(OldF, New))
+          continue;
+
         Match = *I;
         return Ovl_Match;
       }
 
       // Builtins that have custom typechecking or have a reference should
       // not be overloadable or redeclarable.
       if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
         Match = *I;
if (const FunctionDecl *Caller = getCurFunctionDecl(/*AllowLambda=*/true))
       if (!Caller->isImplicit() && !IsAllowedCUDACall(Caller, Function)) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_target;
         return;
       }
 
   if (Function->getTrailingRequiresClause()) {
     ConstraintSatisfaction Satisfaction;
-    if (CheckFunctionConstraints(Function, Satisfaction) ||
+    if (CheckFunctionConstraints(Function, Satisfaction, /*Loc*/ {},
+                                 /*ForOverloadResolution*/ true) ||
         !Satisfaction.IsSatisfied) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
       return;
     }
   }
 
   // Determine the implicit conversion sequences for each of the
if (const FunctionDecl *Caller = getCurFunctionDecl(/*AllowLambda=*/true))
       if (!IsAllowedCUDACall(Caller, Method)) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_target;
         return;
       }
 
   if (Method->getTrailingRequiresClause()) {
     ConstraintSatisfaction Satisfaction;
-    if (CheckFunctionConstraints(Method, Satisfaction) ||
+    if (CheckFunctionConstraints(Method, Satisfaction, /*Loc*/ {},
+                                 /*ForOverloadResolution*/ true) ||
         !Satisfaction.IsSatisfied) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
       return;
     }
   }
 
   // Determine the implicit conversion sequences for each of the

clang/lib/Sema/SemaTemplate.cpp

if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
       return Param;
 
     Param->setDefaultArgument(Context, DefaultArg);
   }
 
   return Param;
 }
 
+namespace {
+class ConstraintRefersToContainingTemplateChecker
+    : public TreeTransform<ConstraintRefersToContainingTemplateChecker> {
+  bool Result = false;
+  unsigned TemplateDepth = 0;
+
+public:
+  using inherited = TreeTransform<ConstraintRefersToContainingTemplateChecker>;
+
+  ConstraintRefersToContainingTemplateChecker(Sema &SemaRef,
+                                              unsigned TemplateDepth)
+      : inherited(SemaRef), TemplateDepth(TemplateDepth) {}
+  bool getResult() const { return Result; }
+
+  // This should be the only template parm type that we have to deal with.
+  // SubstTempalteTypeParmPack, SubstNonTypeTemplateParmPack, and
+  // FunctionParmPackExpr are all partially substituted, which cannot happen
+  // with concepts at this point in translation.
+  QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
+                                         TemplateTypeParmTypeLoc TL) {
+    assert(TL.getDecl()->getDepth() <= TemplateDepth &&
+           "Nothing should reference a value below the actual template depth, "
+           "depth is likely wrong");
+    if (TL.getDecl()->getDepth() != TemplateDepth)
+      Result = true;
+    return inherited::TransformTemplateTypeParmType(TLB, TL);
+  }
+
+  Decl *TransformDecl(SourceLocation Loc, Decl *D) {
+    // FIXME : This is possibly an incomplete list, but it is unclear what other
+    // Decl kinds could be used to refer to the template parameters.  This is a
+    // best guess so far based on examples currently available, but the
+    // unreachable should catch future instances/cases.
+    if (auto *TD = dyn_cast<TypedefNameDecl>(D))
+      TransformType(TD->getUnderlyingType());
+    else if (auto *VD = dyn_cast<ValueDecl>(D))
+      TransformType(VD->getType());
+    else if (auto *TD = dyn_cast<TemplateDecl>(D))
+      TransformTemplateParameterList(TD->getTemplateParameters());
+    else if (isa<NamedDecl>(D)) {
+      // No direct types to visit here I believe.
+    } else
+      llvm_unreachable("Don't know how to handle this declaration type yet");
+    return D;
+  }
+};
+} // namespace
+
+bool Sema::ConstraintExpressionDependsOnEnclosingTemplate(
+    unsigned TemplateDepth, const Expr *Constraint) {
+  ConstraintRefersToContainingTemplateChecker Checker(*this, TemplateDepth);
+  Checker.TransformExpr(const_cast<Expr *>(Constraint));
+  return Checker.getResult();
+}
+
 /// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
 /// constrained by RequiresClause, that contains the template parameters in
 /// Params.
 TemplateParameterList *
 Sema::ActOnTemplateParameterList(unsigned Depth,
                                  SourceLocation ExportLoc,
                                  SourceLocation TemplateLoc,
                                  SourceLocation LAngleLoc,
if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
       auto *NewTTP = TemplateTypeParmDecl::Create(
           SemaRef.Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
           /*Depth*/ 0, Depth1IndexAdjustment + TTP->getIndex(),
           TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
           TTP->isParameterPack(), TTP->hasTypeConstraint(),
           TTP->isExpandedParameterPack() ?
           llvm::Optional<unsigned>(TTP->getNumExpansionParameters()) : None);
       if (const auto *TC = TTP->getTypeConstraint())
-        SemaRef.SubstTypeConstraint(NewTTP, TC, Args);
+        SemaRef.SubstTypeConstraint(NewTTP, TC, Args,
+                                    /*EvaluateConstraint*/ true);
       if (TTP->hasDefaultArgument()) {
         TypeSourceInfo *InstantiatedDefaultArg =
             SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
                               TTP->getDefaultArgumentLoc(), TTP->getDeclName());
         if (InstantiatedDefaultArg)
           NewTTP->setDefaultArgument(InstantiatedDefaultArg);
       }
       SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
bool Sema::CheckTemplateArgumentList(
   }
 
   // No problems found with the new argument list, propagate changes back
   // to caller.
   if (UpdateArgsWithConversions)
     TemplateArgs = std::move(NewArgs);
 
   if (!PartialTemplateArgs) {
-    // FIXME: This will be changed a bit once deferred concept instantiation is
-    // implemented.
-    MultiLevelTemplateArgumentList MLTAL;
-    MLTAL.addOuterTemplateArguments(Converted);
+    TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
+                                           Converted);
+    // Setup the context/ThisScope for the case where we are needing to
+    // re-instantiate constraints outside of normal instantiation.
+    DeclContext *NewContext = Template->getDeclContext();
+
+    // If this template is in a template, make sure we extract the templated
+    // decl.
+    if (auto *TD = dyn_cast<TemplateDecl>(NewContext))
+      NewContext = Decl::castToDeclContext(TD->getTemplatedDecl());
+    auto *RD = dyn_cast<CXXRecordDecl>(NewContext);
+
+    Qualifiers ThisQuals;
+    if (const auto *Method =
+            dyn_cast_or_null<CXXMethodDecl>(Template->getTemplatedDecl()))
+      ThisQuals = Method->getMethodQualifiers();
+
+    ContextRAII Context(*this, NewContext);
+    CXXThisScopeRAII(*this, RD, ThisQuals, RD != nullptr);
+
+    MultiLevelTemplateArgumentList MLTAL = getTemplateInstantiationArgs(
+        Template, &StackTemplateArgs, /*RelativeToPrimary*/ true,
+        /*Pattern*/ nullptr,
+        /*LookBeyondLambda*/ true, /*IncludeContainingStruct*/ true);
     if (EnsureTemplateArgumentListConstraints(
             Template, MLTAL,
             SourceRange(TemplateLoc, TemplateArgs.getRAngleLoc()))) {
       if (ConstraintsNotSatisfied)
         *ConstraintsNotSatisfied = true;
       return true;
     }
   }
if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
       //   [temp.constr.order].
       SmallVector<const Expr *, 3> ParamsAC, TemplateAC;
       Params->getAssociatedConstraints(ParamsAC);
       // C++2a[temp.arg.template]p3
       //   [...] In this comparison, if P is unconstrained, the constraints on A
       //   are not considered.
       if (ParamsAC.empty())
         return false;
+
       Template->getAssociatedConstraints(TemplateAC);
+
       bool IsParamAtLeastAsConstrained;
       if (IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC,
                                  IsParamAtLeastAsConstrained))
         return true;
       if (!IsParamAtLeastAsConstrained) {
         Diag(Arg.getLocation(),
              diag::err_template_template_parameter_not_at_least_as_constrained)
             << Template << Param << Arg.getSourceRange();
E = CStyleCastExpr::Create(Context, OrigT, VK_PRValue, CK_IntegralCast, E,
                                Context.getTrivialTypeSourceInfo(OrigT, Loc),
                                Loc, Loc);
   }
 
   return E;
 }
 
 /// Match two template parameters within template parameter lists.
-static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
-                                       bool Complain,
-                                     Sema::TemplateParameterListEqualKind Kind,
-                                       SourceLocation TemplateArgLoc) {
+static bool MatchTemplateParameterKind(
+    Sema &S, NamedDecl *New, const NamedDecl *NewInstFrom, NamedDecl *Old,
+    const NamedDecl *OldInstFrom, bool Complain,
+    Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc) {
   // Check the actual kind (type, non-type, template).
   if (Old->getKind() != New->getKind()) {
     if (Complain) {
       unsigned NextDiag = diag::err_template_param_different_kind;
       if (TemplateArgLoc.isValid()) {
         S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
         NextDiag = diag::note_template_param_different_kind;
       }
if (Kind != Sema::TPL_TemplateTemplateArgumentMatch ||
       }
   }
   // For template template parameters, check the template parameter types.
   // The template parameter lists of template template
   // parameters must agree.
   else if (TemplateTemplateParmDecl *OldTTP
                                     = dyn_cast<TemplateTemplateParmDecl>(Old)) {
     TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
-    if (!S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
-                                          OldTTP->getTemplateParameters(),
-                                          Complain,
-                                        (Kind == Sema::TPL_TemplateMatch
-                                           ? Sema::TPL_TemplateTemplateParmMatch
-                                           : Kind),
-                                          TemplateArgLoc))
+    if (!S.TemplateParameterListsAreEqual(
+            NewInstFrom, NewTTP->getTemplateParameters(), OldInstFrom,
+            OldTTP->getTemplateParameters(), Complain,
       return false;
   } else if (Kind != Sema::TPL_TemplateTemplateArgumentMatch) {
     const Expr *NewC = nullptr, *OldC = nullptr;
     if (const auto *TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())
       NewC = TC->getImmediatelyDeclaredConstraint();
     if (const auto *TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())
       OldC = TC->getImmediatelyDeclaredConstraint();
 
     auto Diagnose = [&] {
       S.Diag(NewC ? NewC->getBeginLoc() : New->getBeginLoc(),
            diag::err_template_different_type_constraint);
       S.Diag(OldC ? OldC->getBeginLoc() : Old->getBeginLoc(),
            diag::note_template_prev_declaration) << /*declaration*/0;
     };
 
     if (!NewC != !OldC) {
       if (Complain)
         Diagnose();
       return false;
     }
 
     if (NewC) {
-      llvm::FoldingSetNodeID OldCID, NewCID;
-      OldC->Profile(OldCID, S.Context, /*Canonical=*/true);
-      NewC->Profile(NewCID, S.Context, /*Canonical=*/true);
-      if (OldCID != NewCID) {
+      if (!S.AreConstraintExpressionsEqual(OldInstFrom, OldC, NewInstFrom,
+                                           NewC)) {
         if (Complain)
           Diagnose();
         return false;
       }
     }
   }
 
   return true;

 /// \param TemplateArgLoc If this source location is valid, then we
 /// are actually checking the template parameter list of a template
 /// argument (New) against the template parameter list of its
 /// corresponding template template parameter (Old). We produce
 /// slightly different diagnostics in this scenario.
 ///
 /// \returns True if the template parameter lists are equal, false
 /// otherwise.
-bool
-Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
-                                     TemplateParameterList *Old,
-                                     bool Complain,
-                                     TemplateParameterListEqualKind Kind,
-                                     SourceLocation TemplateArgLoc) {
+bool Sema::TemplateParameterListsAreEqual(
+    const NamedDecl *NewInstFrom, TemplateParameterList *New,
+    const NamedDecl *OldInstFrom, TemplateParameterList *Old, bool Complain,
+    TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc) {
   if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
     if (Complain)
       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                                  TemplateArgLoc);
 
     return false;
   }
 
if (Kind != TPL_TemplateTemplateArgumentMatch ||
       if (NewParm == NewParmEnd) {
         if (Complain)
           DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                                      TemplateArgLoc);
 
         return false;
       }
 
-      if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
-                                      Kind, TemplateArgLoc))
+      if (!MatchTemplateParameterKind(*this, *NewParm, NewInstFrom, *OldParm,
+                                      OldInstFrom, Complain, Kind,
+                                      TemplateArgLoc))
         return false;
 
       ++NewParm;
       continue;
     }
 
     // C++0x [temp.arg.template]p3:
     //   [...] When P's template- parameter-list contains a template parameter
     //   pack (14.5.3), the template parameter pack will match zero or more
     //   template parameters or template parameter packs in the
     //   template-parameter-list of A with the same type and form as the
     //   template parameter pack in P (ignoring whether those template
     //   parameters are template parameter packs).
     for (; NewParm != NewParmEnd; ++NewParm) {
-      if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
-                                      Kind, TemplateArgLoc))
+      if (!MatchTemplateParameterKind(*this, *NewParm, NewInstFrom, *OldParm,
+                                      OldInstFrom, Complain, Kind,
+                                      TemplateArgLoc))
         return false;
     }
   }
 
   // Make sure we exhausted all of the arguments.
   if (NewParm != NewParmEnd) {
     if (Complain)
       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
if (Kind != TPL_TemplateTemplateArgumentMatch) {
 
     if (!NewRC != !OldRC) {
       if (Complain)
         Diagnose();
       return false;
     }
 
     if (NewRC) {
-      llvm::FoldingSetNodeID OldRCID, NewRCID;
-      OldRC->Profile(OldRCID, Context, /*Canonical=*/true);
-      NewRC->Profile(NewRCID, Context, /*Canonical=*/true);
-      if (OldRCID != NewRCID) {
+      if (!AreConstraintExpressionsEqual(OldInstFrom, OldRC, NewInstFrom,
+                                         NewRC)) {
         if (Complain)
           Diagnose();
         return false;
       }
     }
   }
 
   return true;

clang/lib/Sema/SemaTemplateDeduction.cpp

 template<>
 struct IsPartialSpecialization<ClassTemplatePartialSpecializationDecl> {
   static constexpr bool value = true;
 };
 template<>
 struct IsPartialSpecialization<VarTemplatePartialSpecializationDecl> {
   static constexpr bool value = true;
 };
+template <typename TemplateDeclT>
+static bool DeducedArgsNeedReplacement(TemplateDeclT *Template) {
+  return false;
+}
+template <>
+bool DeducedArgsNeedReplacement<VarTemplatePartialSpecializationDecl>(
+    VarTemplatePartialSpecializationDecl *Spec) {
+  return !Spec->isClassScopeExplicitSpecialization();
+}
+template <>
+bool DeducedArgsNeedReplacement<ClassTemplatePartialSpecializationDecl>(
+    ClassTemplatePartialSpecializationDecl *Spec) {
+  return !Spec->isClassScopeExplicitSpecialization();
+}
 
 template<typename TemplateDeclT>
 static Sema::TemplateDeductionResult
 CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
                                 ArrayRef<TemplateArgument> DeducedArgs,
                                 TemplateDeductionInfo& Info) {
   llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
   Template->getAssociatedConstraints(AssociatedConstraints);
-  // FIXME: This will change quite a bit once deferred concept instantiation is
-  // implemented.
   MultiLevelTemplateArgumentList MLTAL;
-  MLTAL.addOuterTemplateArguments(DeducedArgs);
 
-  if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints,
-                                    MLTAL, Info.getLocation(),
+  bool NeedsReplacement = DeducedArgsNeedReplacement(Template);
+  TemplateArgumentList DeducedTAL{TemplateArgumentList::OnStack, DeducedArgs};
+
+  MLTAL = S.getTemplateInstantiationArgs(
+      Template, /*InnerMost*/ NeedsReplacement ? nullptr : &DeducedTAL,
+      /*RelativeToPrimary*/ true, /*Pattern*/
+      nullptr, /*LookBeyondLambda*/ true);
+
+  // getTemplateInstantiationArgs picks up the non-deduced version of the
+  // template args when this is a variable template partial specialization and
+  // not class-scope explicit specialization, so replace with Deduced Args
+  // instead of adding to inner-most.
+  if (NeedsReplacement)
+    MLTAL.replaceInnermostTemplateArguments(DeducedArgs);
+
+  if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints, MLTAL,
+                                    Info.getLocation(),
                                     Info.AssociatedConstraintsSatisfaction) ||
       !Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
     Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
     return Sema::TDK_ConstraintsNotSatisfied;
   }
   return Sema::TDK_Success;
 }
 

clang/lib/Sema/SemaTemplateInstantiate.cpp

 /// arguments relative to the primary template, even when we're
 /// dealing with a specialization. This is only relevant for function
 /// template specializations.
 ///
 /// \param Pattern If non-NULL, indicates the pattern from which we will be
 /// instantiating the definition of the given declaration, \p D. This is
 /// used to determine the proper set of template instantiation arguments for
 /// friend function template specializations.
+///
+/// \param LookBeyondLambda Indicates that this collection of arguments should
+/// continue looking when it encounters a lambda generic call operator.
+///
+/// \param IncludeContainingStructArgs Indicates that this collection of
+/// arguments should include arguments for any class template that this
+/// declaration is included inside of.
+
 MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
     const NamedDecl *D, const TemplateArgumentList *Innermost,
-    bool RelativeToPrimary, const FunctionDecl *Pattern) {
+    bool RelativeToPrimary, const FunctionDecl *Pattern, bool LookBeyondLambda,
+    bool IncludeContainingStructArgs) {
   // Accumulate the set of template argument lists in this structure.
   MultiLevelTemplateArgumentList Result;
 
   if (Innermost)
     Result.addOuterTemplateArguments(Innermost);
 
   const auto *Ctx = dyn_cast<DeclContext>(D);
   if (!Ctx) {
else if (const auto *Function = dyn_cast<FunctionDecl>(Ctx)) {
 
         // If this function was instantiated from a specialized member that is
         // a function template, we're done.
         assert(Function->getPrimaryTemplate() && "No function template?");
         if (Function->getPrimaryTemplate()->isMemberSpecialization())
           break;
 
         // If this function is a generic lambda specialization, we are done.
-        if (isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
+        if (!LookBeyondLambda &&
+            isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
           break;
 
       } else if (Function->getDescribedFunctionTemplate()) {
-        assert(Result.getNumSubstitutedLevels() == 0 &&
+        assert((IncludeContainingStructArgs ||
+                Result.getNumSubstitutedLevels() == 0) &&
                "Outer template not instantiated?");
       }
 
       // If this is a friend declaration and it declares an entity at
       // namespace scope, take arguments from its lexical parent
       // instead of its semantic parent, unless of course the pattern we're
       // instantiating actually comes from the file's context!
       if (Function->getFriendObjectKind() &&
           Function->getNonTransparentDeclContext()->isFileContext() &&
           (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
         Ctx = Function->getLexicalDeclContext();
         RelativeToPrimary = false;
         continue;
       }
     } else if (const auto *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
       if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
-        assert(Result.getNumSubstitutedLevels() == 0 &&
+        assert((IncludeContainingStructArgs ||
+                Result.getNumSubstitutedLevels() == 0) &&
                "Outer template not instantiated?");
         if (ClassTemplate->isMemberSpecialization())
           break;
+        if (IncludeContainingStructArgs) {
+          QualType RecordType = Context.getTypeDeclType(Rec);
+          QualType Injected = cast<InjectedClassNameType>(RecordType)
+                                  ->getInjectedSpecializationType();
+          const auto *InjectedType = cast<TemplateSpecializationType>(Injected);
+          Result.addOuterTemplateArguments(InjectedType->template_arguments());
+        }
+      }
+      bool IsFriend = Rec->getFriendObjectKind() ||
+                      (Rec->getDescribedClassTemplate() &&
+                       Rec->getDescribedClassTemplate()->getFriendObjectKind());
+      if (IncludeContainingStructArgs && IsFriend &&
+          Rec->getNonTransparentDeclContext()->isFileContext() &&
+          (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
+        Ctx = Rec->getLexicalDeclContext();
+        RelativeToPrimary = false;
+        continue;
       }
     }
 
     Ctx = Ctx->getParent();
     RelativeToPrimary = false;
   }
 
   return Result;

 //===----------------------------------------------------------------------===/
 // Template Instantiation for Types
 //===----------------------------------------------------------------------===/
 namespace {
   class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
     const MultiLevelTemplateArgumentList &TemplateArgs;
     SourceLocation Loc;
     DeclarationName Entity;
+    bool EvaluateConstraints = true;
 
   public:
     typedef TreeTransform<TemplateInstantiator> inherited;
 
     TemplateInstantiator(Sema &SemaRef,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
-                         SourceLocation Loc,
-                         DeclarationName Entity)
+                         SourceLocation Loc, DeclarationName Entity)
         : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
-        Entity(Entity) { }
+          Entity(Entity) {}
 
+    void setEvaluateConstraints(bool B) {
+      EvaluateConstraints = B;
+    }
+    bool getEvaluateConstraints() {
+      return EvaluateConstraints;
+    }
+
     /// Determine whether the given type \p T has already been
     /// transformed.
     ///
     /// For the purposes of template instantiation, a type has already been
     /// transformed if it is NULL or if it is not dependent.
     bool AlreadyTransformed(QualType T);
 
     /// Returns the location of the entity being instantiated, if known.
public:
     /// Transforms an already-substituted template type parameter pack
     /// into either itself (if we aren't substituting into its pack expansion)
     /// or the appropriate substituted argument.
     QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                            SubstTemplateTypeParmPackTypeLoc TL);
 
     ExprResult TransformLambdaExpr(LambdaExpr *E) {
       LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
-      return inherited::TransformLambdaExpr(E);
+      Sema::ConstraintEvalRAII<TemplateInstantiator> RAII(*this);
+      ExprResult Res = inherited::TransformLambdaExpr(E);
+      return Res;
     }
 
     ExprResult TransformRequiresExpr(RequiresExpr *E) {
       LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
       return inherited::TransformRequiresExpr(E);
     }
 
     bool TransformRequiresExprRequirements(
public:
 
     TemplateParameterList *TransformTemplateParameterList(
                               TemplateParameterList *OrigTPL)  {
       if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
 
       DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
       TemplateDeclInstantiator  DeclInstantiator(getSema(),
                         /* DeclContext *Owner */ Owner, TemplateArgs);
+      DeclInstantiator.setEvaluateConstraints(EvaluateConstraints);
       return DeclInstantiator.SubstTemplateParams(OrigTPL);
     }
 
     concepts::TypeRequirement *
     TransformTypeRequirement(concepts::TypeRequirement *Req);
     concepts::ExprRequirement *
     TransformExprRequirement(concepts::ExprRequirement *Req);
     concepts::NestedRequirement *
return inherited::TransformFunctionProtoType(
       TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
 }
 
 ParmVarDecl *
 TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                                  int indexAdjustment,
                                                Optional<unsigned> NumExpansions,
                                                  bool ExpectParameterPack) {
-  auto NewParm =
-      SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
-                               NumExpansions, ExpectParameterPack);
+  auto NewParm = SemaRef.SubstParmVarDecl(
+      OldParm, TemplateArgs, indexAdjustment, NumExpansions,
+      ExpectParameterPack, EvaluateConstraints);
   if (NewParm && SemaRef.getLangOpts().OpenCL)
     SemaRef.deduceOpenCLAddressSpace(NewParm);
   return NewParm;
 }
 
 QualType
 TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                                 TemplateTypeParmTypeLoc TL) {
TemplateInstantiator::TransformExprRequirement(concepts::ExprRequirement *Req) {
   else if (RetReq.isTypeConstraint()) {
     TemplateParameterList *OrigTPL =
         RetReq.getTypeConstraintTemplateParameterList();
     TemplateDeductionInfo Info(OrigTPL->getTemplateLoc());
     Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
                                         Req, Info, OrigTPL->getSourceRange());
     if (TPLInst.isInvalid())
       return nullptr;
-    TemplateParameterList *TPL =
-        TransformTemplateParameterList(OrigTPL);
+    TemplateParameterList *TPL = TransformTemplateParameterList(OrigTPL);
     if (!TPL)
       TransRetReq.emplace(createSubstDiag(SemaRef, Info,
           [&] (llvm::raw_ostream& OS) {
               RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
                   ->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
           }));
     else {
       TPLInst.Clear();

 /// type of a FunctionDecl.  Its purpose is solely to force the
 /// instantiation of default-argument expressions and to avoid
 /// instantiating an exception-specification.
 TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
                                 const MultiLevelTemplateArgumentList &Args,
                                 SourceLocation Loc,
                                 DeclarationName Entity,
                                 CXXRecordDecl *ThisContext,
-                                Qualifiers ThisTypeQuals) {
+                                Qualifiers ThisTypeQuals,
+                                bool EvaluateConstraints) {
   assert(!CodeSynthesisContexts.empty() &&
          "Cannot perform an instantiation without some context on the "
          "instantiation stack");
 
   if (!NeedsInstantiationAsFunctionType(T))
     return T;
 
   TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
+  Instantiator.setEvaluateConstraints(EvaluateConstraints);
 
   TypeLocBuilder TLB;
 
   TypeLoc TL = T->getTypeLoc();
   TLB.reserve(TL.getFullDataSize());
 
   QualType Result;
 
TemplateTypeParmDecl *VisitPackExpansionType(const PackExpansionType *T) {
       return Visit(T->getPattern());
     }
   };
 
 } // namespace
 
 bool Sema::SubstTypeConstraint(
     TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
-    const MultiLevelTemplateArgumentList &TemplateArgs) {
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EvaluateConstraints) {
   const ASTTemplateArgumentListInfo *TemplArgInfo =
       TC->getTemplateArgsAsWritten();
+
+  if (!EvaluateConstraints) {
+    Inst->setTypeConstraint(TC->getNestedNameSpecifierLoc(),
+                            TC->getConceptNameInfo(), TC->getNamedConcept(),
+                            TC->getNamedConcept(), TemplArgInfo,
+                            TC->getImmediatelyDeclaredConstraint());
+    return false;
+  }
+
   TemplateArgumentListInfo InstArgs;
 
   if (TemplArgInfo) {
     InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
     InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
     if (SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
                                InstArgs))
       return true;
   }
   return AttachTypeConstraint(
       TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
       TC->getNamedConcept(), &InstArgs, Inst,
       Inst->isParameterPack()
           ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
                 ->getEllipsisLoc()
           : SourceLocation());
 }
 
-ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                                    int indexAdjustment,
-                                    Optional<unsigned> NumExpansions,
-                                    bool ExpectParameterPack) {
+ParmVarDecl *
+Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
+                       int indexAdjustment, Optional<unsigned> NumExpansions,
+                       bool ExpectParameterPack, bool EvaluateConstraint) {
   TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
   TypeSourceInfo *NewDI = nullptr;
 
   TypeLoc OldTL = OldDI->getTypeLoc();
   if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {
 
     // We have a function parameter pack. Substitute into the pattern of the
     // expansion.
if (TemplateTypeParmDecl *TTP =
           GetContainedInventedTypeParmVisitor().Visit(OldDI->getType())) {
     if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
       auto *Inst = cast_or_null<TemplateTypeParmDecl>(
           FindInstantiatedDecl(TTP->getLocation(), TTP, TemplateArgs));
       // We will first get here when instantiating the abbreviated function
       // template's described function, but we might also get here later.
       // Make sure we do not instantiate the TypeConstraint more than once.
       if (Inst && !Inst->getTypeConstraint()) {
-        // TODO: Concepts: do not instantiate the constraint (delayed constraint
-        // substitution)
-        if (SubstTypeConstraint(Inst, TC, TemplateArgs))
+        if (SubstTypeConstraint(Inst, TC, TemplateArgs, EvaluateConstraint))
           return nullptr;
       }
     }
   }
 
   ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
                                         OldParm->getInnerLocStart(),
                                         OldParm->getLocation(),
Sema::InstantiateClass(SourceLocation PointOfInstantiation,
   // FIXME: This loses the as-written tag kind for an explicit instantiation.
   Instantiation->setTagKind(Pattern->getTagKind());
 
   // Do substitution on the base class specifiers.
   if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
     Instantiation->setInvalidDecl();
 
   TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
+  Instantiator.setEvaluateConstraints(false);
   SmallVector<Decl*, 4> Fields;
   // Delay instantiation of late parsed attributes.
   LateInstantiatedAttrVec LateAttrs;
   Instantiator.enableLateAttributeInstantiation(&LateAttrs);
 
   bool MightHaveConstexprVirtualFunctions = false;
   for (auto *Member : Pattern->decls()) {
     // Don't instantiate members not belonging in this semantic context.
TemplateInstantiator Instantiator(*this, TemplateArgs,
                                     DeclarationName());
   return Instantiator.TransformStmt(S);
 }
 
 bool Sema::SubstTemplateArguments(
     ArrayRef<TemplateArgumentLoc> Args,
     const MultiLevelTemplateArgumentList &TemplateArgs,
     TemplateArgumentListInfo &Out) {
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                     DeclarationName());
-  return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(),
-                                                 Out);
+  return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
 }
 
 ExprResult
 Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
   if (!E)
     return E;
 
   TemplateInstantiator Instantiator(*this, TemplateArgs,
                                     SourceLocation(),
                                     DeclarationName());
   return Instantiator.TransformExpr(E);
 }
 
+ExprResult
+Sema::SubstConstraintExpr(Expr *E,
+                          const MultiLevelTemplateArgumentList &TemplateArgs) {
+  if (!E)
+    return E;
+
+  // This is where we need to make sure we 'know' constraint checking needs to
+  // happen.
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
+                                    DeclarationName());
+  return Instantiator.TransformExpr(E);
+}
+
 ExprResult Sema::SubstInitializer(Expr *Init,
                           const MultiLevelTemplateArgumentList &TemplateArgs,
                           bool CXXDirectInit) {
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
                                     DeclarationName());
   return Instantiator.TransformInitializer(Init, CXXDirectInit);
 }
 
 bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
                       SmallVectorImpl<Expr *> &Outputs) {
   if (Exprs.empty())

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (isFriend) {
     if (!PrevClassTemplate && QualifierLoc) {
       SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
         << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
         << QualifierLoc.getSourceRange();
       return nullptr;
     }
 
     if (PrevClassTemplate) {
-      TemplateParameterList *PrevParams
-        = PrevClassTemplate->getMostRecentDecl()->getTemplateParameters();
+      const ClassTemplateDecl *MostRecentPrevCT =
+          PrevClassTemplate->getMostRecentDecl();
+      TemplateParameterList *PrevParams =
+          MostRecentPrevCT->getTemplateParameters();
 
       // Make sure the parameter lists match.
-      if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams, true,
-                                                  Sema::TPL_TemplateMatch))
+      if (!SemaRef.TemplateParameterListsAreEqual(
+              D->getTemplatedDecl(), InstParams,
+              MostRecentPrevCT->getTemplatedDecl(), PrevParams, true,
         return nullptr;
 
       // Do some additional validation, then merge default arguments
       // from the existing declarations.
       if (SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
                                              Sema::TPC_ClassTemplate))
         return nullptr;
     }

 
 Decl *
 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   // Create a local instantiation scope for this function template, which
   // will contain the instantiations of the template parameters and then get
   // merged with the local instantiation scope for the function template
   // itself.
   LocalInstantiationScope Scope(SemaRef);
+  Sema::ConstraintEvalRAII<TemplateDeclInstantiator> RAII(*this);
 
   TemplateParameterList *TempParams = D->getTemplateParameters();
   TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
   if (!InstParams)
     return nullptr;
 
   FunctionDecl *Instantiated = nullptr;
   if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
Decl *TemplateDeclInstantiator::VisitFunctionDecl(
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                        TemplateArgs);
     if (!QualifierLoc)
       return nullptr;
   }
 
-  // FIXME: Concepts: Do not substitute into constraint expressions
   Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
-  if (TrailingRequiresClause) {
-    EnterExpressionEvaluationContext ConstantEvaluated(
-        SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
-    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
-                                           TemplateArgs);
-    if (SubstRC.isInvalid())
-      return nullptr;
-    TrailingRequiresClause = SubstRC.get();
-    if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
-      return nullptr;
-  }
 
   // If we're instantiating a local function declaration, put the result
   // in the enclosing namespace; otherwise we need to find the instantiated
   // context.
   DeclContext *DC;
   if (D->isLocalExternDecl()) {
     DC = Owner;
     SemaRef.adjustContextForLocalExternDecl(DC);
if (DGuide->isCopyDeductionCandidate())
       cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
     Function->setAccess(D->getAccess());
   } else {
     Function = FunctionDecl::Create(
         SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
         D->getCanonicalDecl()->getStorageClass(), D->UsesFPIntrin(),
         D->isInlineSpecified(), D->hasWrittenPrototype(), D->getConstexprKind(),
         TrailingRequiresClause);
+    Function->setFriendConstraintRefersToEnclosingTemplate(
+        D->FriendConstraintRefersToEnclosingTemplate());
     Function->setRangeEnd(D->getSourceRange().getEnd());
   }
 
   if (D->isInlined())
     Function->setImplicitlyInline();
 
   if (QualifierLoc)
     Function->setQualifierInfo(QualifierLoc);
Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
     QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
                                                  TemplateArgs);
     if (!QualifierLoc)
       return nullptr;
   }
 
-  // FIXME: Concepts: Do not substitute into constraint expressions
-  Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
-  if (TrailingRequiresClause) {
-    EnterExpressionEvaluationContext ConstantEvaluated(
-        SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
-    auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
-    Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext,
-                                     D->getMethodQualifiers(), ThisContext);
-    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
-                                           TemplateArgs);
-    if (SubstRC.isInvalid())
-      return nullptr;
-    TrailingRequiresClause = SubstRC.get();
-    if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
-      return nullptr;
-  }
-
   DeclContext *DC = Owner;
   if (isFriend) {
     if (QualifierLoc) {
       CXXScopeSpec SS;
       SS.Adopt(QualifierLoc);
       DC = SemaRef.computeDeclContext(SS);
 
       if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
         return nullptr;
     } else {
       DC = SemaRef.FindInstantiatedContext(D->getLocation(),
                                            D->getDeclContext(),
                                            TemplateArgs);
     }
     if (!DC) return nullptr;
   }
 
+  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
+  Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
+
   DeclarationNameInfo NameInfo
     = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
 
   if (FunctionRewriteKind != RewriteKind::None)
     adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);
 
   // Build the instantiated method declaration.
-  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
   CXXMethodDecl *Method = nullptr;
 
   SourceLocation StartLoc = D->getInnerLocStart();
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     Method = CXXConstructorDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         InstantiatedExplicitSpecifier, Constructor->UsesFPIntrin(),
         Constructor->isInlineSpecified(), false,
TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
       D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
       D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack(),
       D->hasTypeConstraint(), NumExpanded);
 
   Inst->setAccess(AS_public);
   Inst->setImplicit(D->isImplicit());
   if (auto *TC = D->getTypeConstraint()) {
     if (!D->isImplicit()) {
-      // Invented template parameter type constraints will be instantiated with
-      // the corresponding auto-typed parameter as it might reference other
-      // parameters.
-
-      // TODO: Concepts: do not instantiate the constraint (delayed constraint
-      // substitution)
-      if (SemaRef.SubstTypeConstraint(Inst, TC, TemplateArgs))
+      // Invented template parameter type constraints will be instantiated
+      // with the corresponding auto-typed parameter as it might reference
+      // other parameters.
+      if (SemaRef.SubstTypeConstraint(Inst, TC, TemplateArgs,
+                                      EvaluateConstraints))
         return nullptr;
     }
   }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     TypeSourceInfo *InstantiatedDefaultArg =
         SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
                           D->getDefaultArgumentLoc(), D->getDeclName());
     if (InstantiatedDefaultArg)
for (auto &P : *L) {
     Params.push_back(D);
     Invalid = Invalid || !D || D->isInvalidDecl();
   }
 
   // Clean up if we had an error.
   if (Invalid)
     return nullptr;
 
-  // FIXME: Concepts: Substitution into requires clause should only happen when
-  // checking satisfaction.
-  Expr *InstRequiresClause = nullptr;
-  if (Expr *E = L->getRequiresClause()) {
-    EnterExpressionEvaluationContext ConstantEvaluated(
-        SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
-    ExprResult Res = SemaRef.SubstExpr(E, TemplateArgs);
-    if (Res.isInvalid() || !Res.isUsable()) {
-      return nullptr;
-    }
-    InstRequiresClause = Res.get();
-  }
+  Expr *InstRequiresClause = L->getRequiresClause();
 
   TemplateParameterList *InstL
     = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
                                     L->getLAngleLoc(), Params,
                                     L->getRAngleLoc(), InstRequiresClause);
   return InstL;
 }
 
TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
 
   CXXRecordDecl *ThisContext = nullptr;
   Qualifiers ThisTypeQuals;
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
     ThisContext = cast<CXXRecordDecl>(Owner);
     ThisTypeQuals = Method->getMethodQualifiers();
   }
 
-  TypeSourceInfo *NewTInfo
-    = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
-                                    D->getTypeSpecStartLoc(),
-                                    D->getDeclName(),
-                                    ThisContext, ThisTypeQuals);
+  TypeSourceInfo *NewTInfo = SemaRef.SubstFunctionDeclType(
+      OldTInfo, TemplateArgs, D->getTypeSpecStartLoc(), D->getDeclName(),
+      ThisContext, ThisTypeQuals, EvaluateConstraints);
   if (!NewTInfo)
     return nullptr;
 
   TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
   if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
     if (NewTInfo != OldTInfo) {
       // Get parameters from the new type info.
       TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();

clang/lib/Sema/TreeTransform.h

QualType NewCallOpType = TransformFunctionProtoType(
                                               ExceptionStorage, Changed);
         });
     if (NewCallOpType.isNull())
       return ExprError();
     NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
                                                         NewCallOpType);
   }
 
-  // Transform the trailing requires clause
-  ExprResult NewTrailingRequiresClause;
-  if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause())
-    // FIXME: Concepts: Substitution into requires clause should only happen
-    //                  when checking satisfaction.
-    NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
-
   // Create the local class that will describe the lambda.
 
   // FIXME: DependencyKind below is wrong when substituting inside a templated
   // context that isn't a DeclContext (such as a variable template), or when
   // substituting an unevaluated lambda inside of a function's parameter's type
   // - as parameter types are not instantiated from within a function's DC. We
   // use isUnevaluatedContext() to distinguish the function parameter case.
   CXXRecordDecl::LambdaDependencyKind DependencyKind =
Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(),
                                OldClass->getLambdaContextDecl());
 
   // Build the call operator.
   CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
       Class, E->getIntroducerRange(), NewCallOpTSI,
       E->getCallOperator()->getEndLoc(),
       NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
       E->getCallOperator()->getConstexprKind(),
-      NewTrailingRequiresClause.get());
+      E->getCallOperator()->getTrailingRequiresClause());
 
   LSI->CallOperator = NewCallOperator;
 
   getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
   getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
 
   // Number the lambda for linkage purposes if necessary.
   getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling);

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->setDefaulted(Record.readInt());
   FD->setExplicitlyDefaulted(Record.readInt());
   FD->setHasImplicitReturnZero(Record.readInt());
   FD->setConstexprKind(static_cast<ConstexprSpecKind>(Record.readInt()));
   FD->setUsesSEHTry(Record.readInt());
   FD->setHasSkippedBody(Record.readInt());
   FD->setIsMultiVersion(Record.readInt());
   FD->setLateTemplateParsed(Record.readInt());
+  FD->setFriendConstraintRefersToEnclosingTemplate(Record.readInt());
 
   FD->setCachedLinkage(static_cast<Linkage>(Record.readInt()));
   FD->EndRangeLoc = readSourceLocation();
 
   FD->ODRHash = Record.readInt();
   FD->setHasODRHash(true);
 
   if (FD->isDefaulted()) {

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitConceptSpecializationExpr(
   E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
   E->TemplateKWLoc = Record.readSourceLocation();
   E->ConceptName = Record.readDeclarationNameInfo();
   E->NamedConcept = readDeclAs<ConceptDecl>();
   E->FoundDecl = Record.readDeclAs<NamedDecl>();
   E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
   llvm::SmallVector<TemplateArgument, 4> Args;
   for (unsigned I = 0; I < NumTemplateArgs; ++I)
-    Args.push_back(Record.readTemplateArgument());
+    Args.push_back(Record.readTemplateArgument(/*Canonicalize*/ true));
   E->setTemplateArguments(Args);
   E->Satisfaction = E->isValueDependent() ? nullptr :
       ASTConstraintSatisfaction::Create(Record.getContext(),
                                         readConstraintSatisfaction(Record));
 }
 
 static concepts::Requirement::SubstitutionDiagnostic *
 readSubstitutionDiagnostic(ASTRecordReader &Record) {

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.push_back(D->isDefaulted());
   Record.push_back(D->isExplicitlyDefaulted());
   Record.push_back(D->hasImplicitReturnZero());
   Record.push_back(static_cast<uint64_t>(D->getConstexprKind()));
   Record.push_back(D->usesSEHTry());
   Record.push_back(D->hasSkippedBody());
   Record.push_back(D->isMultiVersion());
   Record.push_back(D->isLateTemplateParsed());
+  Record.push_back(D->FriendConstraintRefersToEnclosingTemplate());
   Record.push_back(D->getLinkageInternal());
   Record.AddSourceLocation(D->getEndLoc());
 
   Record.push_back(D->getODRHash());
 
   if (D->isDefaulted()) {
     if (auto *FDI = D->getDefaultedFunctionInfo()) {
       Record.push_back(FDI->getUnqualifiedLookups().size());
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Constexpr
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FriendConstraintRefersToEnclosingTemplate
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LocEnd
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
   // This Array slurps the rest of the record. Fortunately we want to encode
   // (nearly) all the remaining (variable number of) fields in the same way.
   //
   // This is the function template information if any, then

clang/test/CXX/temp/temp.constr/temp.constr.constr/non-function-templates.cpp

template<typename T> requires B<T>::type // expected-note{{in instantiation of template class 'B<int>' requested here}}
                                          // expected-note@-1{{while substituting template arguments into constraint expression here}}
 struct C { };
 
 template<typename T> requires (T{}) // expected-error{{atomic constraint must be of type 'bool' (found 'int')}}
 struct D { };
 
 static_assert(C<int>{}); // expected-note{{while checking constraint satisfaction for template 'C<int>' required here}}
 static_assert(D<int>{}); // expected-note{{while checking constraint satisfaction for template 'D<int>' required here}}
+
+// Test the delayed instantiation, the 'foo' implementation shouldn't cause the
+// constraint failure(or crash!) until the use to create 'y'.
+namespace DelayedInst {
+template <unsigned I>
+struct AAA {
+  template <typename T>
+    requires(sizeof(T) == I) // expected-note {{because 'sizeof(int) == 5U' (4 == 5) evaluated to false}}
+  struct B {
+    static constexpr int a = 0;
+  };
+
+  static constexpr auto foo() {
+    return B<int>::a; // expected-error{{constraints not satisfied for class template 'B' [with T = int]}}
+  }
+};
+
+constexpr auto x = AAA<4>::foo();
+constexpr auto y = AAA<5>::foo(); // expected-note {{in instantiation of member function 'DelayedInst::AAA<5>::foo' requested here}}
+
+} // namespace DelayedInst

clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp

 
 template<typename T> requires C1<T> || C2<T>
 struct F<T>{ enum{ value = 3 }; };
 
 static_assert(F<unsigned>::value == 2);
 static_assert(F<char[10]>::value == 3);
 static_assert(F<char>::value == 1);
 
+template <unsigned I>
+struct S {
+  template <typename T>
+  struct F {
+    enum { value = 1 };
+  };
+
+  template <typename T>
+    requires C1<T> && C2<T>
+  struct F<T> {
+    enum { value = 2 };
+  };
+
+  template <typename T>
+    requires C1<T> || C2<T>
+  struct F<T> {
+    enum { value = 3 };
+  };
+};
+
+static_assert(S<1>::F<unsigned>::value == 2);
+static_assert(S<1>::F<char[10]>::value == 3);
+static_assert(S<1>::F<char>::value == 1);
+
 // Make sure atomic constraints subsume each other only if their parameter
 // mappings are identical.
 
 template<typename T, typename U> requires C2<T>
 struct I { }; // expected-note {{template is declared here}}
 
 template<typename T, typename U> requires C2<U>
 struct I<T, U> { }; // expected-error {{class template partial specialization is not more specialized than the primary template}}
 
 template<typename T, typename U> requires C2<T> && C2<U>
 struct I<T, U> { };

clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp

 
 template<typename T> requires C1<T> || C2<T>
 constexpr int f<T> = 3;
 
 static_assert(f<unsigned> == 2);
 static_assert(f<char[10]> == 3);
 static_assert(f<char> == 1);
 
+template <int I>
+struct S {
+  template <typename T>
+  static constexpr int f = 1;
+
+  template <typename T>
+    requires C1<T> && C2<T>
+  static constexpr int f<T> = 2;
 
+  template <typename T>
+    requires C1<T> || C2<T>
+  static constexpr int f<T> = 3;
+};
 
+static_assert(S<1>::f<unsigned> == 2);
+static_assert(S<1>::f<char[10]> == 3);
+static_assert(S<1>::f<char> == 1);

clang/test/Modules/concept_serialization.cpp

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -std=c++20 -fmodules-cache-path=%t -x c++ %s -verify
+// expected-no-diagnostics
+#pragma clang module build std
+module std [system] { module concepts [system] {} }
+#pragma clang module contents
+
+#pragma clang module begin std.concepts
+template <class T>
+T declval();
+template<class T, class U>
+concept common_reference_with = T::val;
+template<class T>
+concept input_or_output_iterator = true;
+template <class T>
+concept input_iterator = input_or_output_iterator<T> &&
+                         common_reference_with<decltype(declval<T&>)&&, T&>;
+#pragma clang module end /*std.concepts*/
+#pragma clang module endbuild /*std*/
+
+#pragma clang module import std.concepts
+template<input_or_output_iterator>
+struct iter_value_or_void{};
+// ensure that we don't assert on a subsumption check due to improper
+// deserialization.
+template<input_iterator I>
+struct iter_value_or_void<I>{};

clang/test/SemaCXX/constrained-special-member-functions.cpp

 static_assert(!__is_trivial(ComplexConstraints<AB>), "");
 static_assert(!__is_trivial(ComplexConstraints<AC>), "");
 static_assert(__is_trivial(ComplexConstraints<A>), "");
 static_assert(!__is_trivial(ComplexConstraints<int>), "");
 
 
 // This is evaluated at the completion of CRTPBase, while `T` is not yet completed.
 // This is probably correct behavior.
-// FIXME: We should not throw an error, instead SFINAE should make the constraint
-// silently unsatisfied. See [temp.constr.constr]p5
 template <class T>
 struct CRTPBase {
-  CRTPBase() requires (sizeof(T) > 0); // expected-error {{to an incomplete type}}
+  CRTPBase() requires (sizeof(T) > 0);
   CRTPBase() = default;
 };
 
 struct Child : CRTPBase<Child> { int x; };
-// expected-note@-1 {{definition of 'Child' is not complete until}}
-// expected-note@-2 {{in instantiation of template class 'CRTPBase<Child>' requested here}}
 static Child c;
 
 
 namespace GH57046 {
 template<unsigned N>
 struct Foo {
   Foo() requires (N==1) {} // expected-note {{declared here}}
   Foo() requires (N==2) = default;

clang/test/SemaTemplate/concepts-friends.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+
+template <typename T>
+concept constraint = false;
+namespace temp_friend_9 {
+// A non-template friend declaration with a requires-clause shall be a
+// definition. ...Such a constrained friend function ... does not declare the
+// same function or function template as a declaration in any other scope.
+template <typename T>
+struct NonTemplateFriend {
+  friend void foo()
+    requires true
+  {}
+};
+
+// A friend function template with a constraint that depends on a template
+// parameter from an enclosing template shall be a definition.  Such a ...
+// function template declaration does not declare the same function or
+// function template as a declaration in any other scope.
+template <typename T>
+struct TemplateFromEnclosing {
+  template <typename U>
+  friend void foo()
+    requires constraint<T>
+  {}
+
+  T variable;
+  template <typename U>
+  friend void foo2()
+    requires constraint<decltype(variable)>
+  {}
+
+  template <typename U>
+  friend void foo3(T parmvar)
+    requires constraint<decltype(parmvar)>
+  {}
+
+  template <typename U>
+  friend void foo4()
+    requires requires(T &req) { (void)req; }
+  {}
+
+  using Alias = T;
+  template <typename U>
+  friend void foo5()
+    requires constraint<Alias>
+  {}
+
+  // All of these refer to a parent, so these are not duplicate definitions.
+  struct ChildOfEnclosing {
+    template <typename U>
+    friend void foo6()
+      requires constraint<T>
+    {}
+    template <typename U>
+    friend void foo7()
+      requires constraint<decltype(variable)>
+    {}
+    template <typename U>
+    friend void foo8(T parmvar)
+      requires constraint<decltype(parmvar)>
+    {}
+    // This is NOT a duplicate since it itself is not a template.
+    friend void foo9()
+      requires true
+    {}
+  };
+  template <typename T2>
+  struct TemplChildOfEnclosing {
+    template <typename U>
+    friend void foo10()
+      requires constraint<T>
+    {}
+  };
+};
+
+// Doesn't meet either of the requirements in the above as they don't refer to
+// an enclosing scope.
+template <typename T>
+struct Redefinition {
+  template <typename U>
+  friend void foo() // #REDEF
+    requires constraint<U>
+  {}
+
+  struct ChildOfRedef {
+    template <typename U>
+    friend void foo2() // #REDEF2
+      requires constraint<U>
+    {}
+  };
+  template <typename T2>
+  struct ChildOfRedef2 {
+    template <typename U>
+    friend void foo3() // #REDEF3
+      requires constraint<U>
+    {}
+  };
+};
+
+void bar() {
+  NonTemplateFriend<int> S1;
+  NonTemplateFriend<float> S2;
+  TemplateFromEnclosing<int> S3;
+  TemplateFromEnclosing<int>::ChildOfEnclosing S3b;
+  TemplateFromEnclosing<float> S4;
+  TemplateFromEnclosing<float>::ChildOfEnclosing S4b;
+  Redefinition<int> S5;
+  Redefinition<float> S6;
+  // expected-error@#REDEF {{redefinition of 'foo'}}
+  // expected-note@-2{{in instantiation of template class }}
+  // expected-note@#REDEF {{previous definition is here}}
+  Redefinition<int>::ChildOfRedef S7;
+  Redefinition<float>::ChildOfRedef S8;
+  // expected-error@#REDEF2 {{redefinition of 'foo2'}}
+  // expected-note@-2{{in instantiation of member class }}
+  // expected-note@#REDEF2 {{previous definition is here}}
+
+  Redefinition<int>::ChildOfRedef2<int> S9;
+  Redefinition<float>::ChildOfRedef2<float> S10;
+  // expected-error@#REDEF3 {{redefinition of 'foo3'}}
+  // expected-note@-2{{in instantiation of template class }}
+  // expected-note@#REDEF3 {{previous definition is here}}
+}
+} // namespace temp_friend_9
+
+namespace SameScopeRedefs {
+template <typename T>
+struct NonTemplateFriend {
+  friend void foo() // #NTF1
+    requires true
+  {}
+  friend void foo() // #NTF2
+    requires true
+  {}
+};
+
+template <typename T>
+struct TemplateFromEnclosing {
+  template <typename U>
+  friend void foo() // #TFE1
+    requires constraint<T>
+  {}
+  template <typename U>
+  friend void foo() // #TFE2
+    requires constraint<T>
+  {}
+};
+// Same as above, but doesn't require an instantiation pair to cause.
+template <typename T>
+struct Redefinition {
+  template <typename U>
+  friend void foo() // #RD1
+    requires constraint<U>
+  {}
+  template <typename U>
+  friend void foo() // #RD2
+    requires constraint<U>
+  {}
+};
+void bar() {
+  NonTemplateFriend<int> S1;
+  // expected-error@#NTF2 {{redefinition of 'foo'}}
+  // expected-note@-2{{in instantiation of template class}}
+  // expected-note@#NTF1 {{previous definition is here}}
+
+  TemplateFromEnclosing<int> S2;
+  // expected-error@#TFE2 {{redefinition of 'foo'}}
+  // expected-note@-2{{in instantiation of template class}}
+  // expected-note@#TFE1 {{previous definition is here}}
+
+  Redefinition<int> S3;
+  // expected-error@#RD2 {{redefinition of 'foo'}}
+  // expected-note@-2{{in instantiation of template class}}
+  // expected-note@#RD1 {{previous definition is here}}
+}
+} // namespace SameScopeRedefs
+
+namespace LibCXXOperatorRedef {
+template <typename T, typename U> struct is_same {
+  static constexpr bool value = false;
+};
+template <typename T> struct is_same<T, T> {
+  static constexpr bool value = false;
+};
+
+template <typename T, typename U>
+concept same_as = is_same<T, U>::value;
+
+// An issue found from libcxx when trying to commit the deferred concepts patch.
+// This caused an error of 'redefinition of funcN'.
+template <class _Tp> struct __range_adaptor_closure {
+  template <typename _View, typename _Closure>
+    requires same_as<_Tp, _Closure>
+  friend constexpr decltype(auto) R1func1(_View &&__view,
+                                          _Closure &&__closure){};
+  template <typename _View, typename _Closure>
+  friend constexpr decltype(auto) R1func2(_View &&__view,
+                                          _Closure &&__closure)
+    requires same_as<_Tp, _Closure>
+  {};
+  template <same_as<_Tp> _View, typename _Closure>
+  friend constexpr decltype(auto) R1func3(_View &&__view,
+                                          _Closure &&__closure){};
+};
+
+struct A : __range_adaptor_closure<A> {};
+struct B : __range_adaptor_closure<B> {};
+
+// These three fail because after the 1st pass of instantiation, they are still
+// identical.
+template <class _Tp> struct __range_adaptor_closure2 {
+  template <typename _View, typename _Closure>
+    requires same_as<_View, _Closure>
+  friend constexpr decltype(auto) R2func1(_View &&__view, // #FUNC1
+                                          _Closure &&__closure){};
+  template <typename _View, typename _Closure>
+  friend constexpr decltype(auto) R2func2(_View &&__view, // #FUNC2
+                                          _Closure &&__closure)
+    requires same_as<_View, _Closure>
+  {};
+  template <typename _View, same_as<_View> _Closure>
+  friend constexpr decltype(auto) R2func3(_View &&__view, // #FUNC3
+                                          _Closure &&__closure){};
+};
+
+struct A2 : __range_adaptor_closure2<A2> {};
+struct B2 : __range_adaptor_closure2<B2> {};
+// expected-error@#FUNC1{{redefinition of 'R2func1'}}
+// expected-note@-2{{in instantiation of template class}}
+// expected-note@#FUNC1{{previous definition is here}}
+// expected-error@#FUNC2{{redefinition of 'R2func2'}}
+// expected-note@#FUNC2{{previous definition is here}}
+// expected-error@#FUNC3{{redefinition of 'R2func3'}}
+// expected-note@#FUNC3{{previous definition is here}}
+
+// These three are fine, they all depend on the parent template parameter, so
+// are different despite ::type not being valid.
+template <class _Tp> struct __range_adaptor_closure3 {
+  template <typename _View, typename _Closure>
+    requires same_as<typename _Tp::type, _Closure>
+  friend constexpr decltype(auto) R3func1(_View &&__view,
+                                          _Closure &&__closure){};
+  template <typename _View, typename _Closure>
+  friend constexpr decltype(auto) R3func2(_View &&__view,
+                                          _Closure &&__closure)
+    requires same_as<typename _Tp::type, _Closure>
+  {};
+  template <same_as<typename _Tp::type> _View, typename _Closure>
+  friend constexpr decltype(auto) R3func3(_View &&__view,
+                                          _Closure &&__closure){};
+};
+
+struct A3 : __range_adaptor_closure3<A3> {};
+struct B3 : __range_adaptor_closure3<B3> {};
+
+template <class _Tp> struct __range_adaptor_closure4 {
+  template <typename _View, typename _Closure>
+    requires same_as<_Tp, _View>
+  // expected-note@+1{{previous definition is here}}
+  void foo1(_View &&, _Closure &&) {}
+  template <typename _View, typename _Closure>
+    requires same_as<_Tp, _View>
+  // expected-error@+1{{class member cannot be redeclared}}
+  void foo1(_View &&, _Closure &&) {}
+
+  template <typename _View, typename _Closure>
+  // expected-note@+1{{previous definition is here}}
+  void foo2(_View &&, _Closure &&)
+    requires same_as<_Tp, _View>
+  {}
+  template <typename _View, typename _Closure>
+  // expected-error@+1{{class member cannot be redeclared}}
+  void foo2(_View &&, _Closure &&)
+    requires same_as<_Tp, _View>
+  {}
+
+  template <same_as<_Tp> _View, typename _Closure>
+  // expected-note@+1{{previous definition is here}}
+  void foo3(_View &&, _Closure &&) {}
+  template <same_as<_Tp> _View, typename _Closure>
+  // expected-error@+1{{class member cannot be redeclared}}
+  void foo3(_View &&, _Closure &&) {}
+};
+
+// Requires instantiation to fail, so no errors here.
+template <class _Tp> struct __range_adaptor_closure5 {
+  template <same_as<_Tp> U>
+  friend void foo() {}
+  template <same_as<_Tp> U>
+  friend void foo() {}
+};
+
+template <class _Tp> struct __range_adaptor_closure6 {
+  template <same_as<_Tp> U>
+  friend void foo() {} // #RAC6FOO1
+  template <same_as<_Tp> U>
+  friend void foo() {} // #RAC6FOO2
+};
+struct A6 : __range_adaptor_closure6<A6> {};
+// expected-error@#RAC6FOO2{{redefinition of 'foo'}}
+// expected-note@-2{{in instantiation of template class}}
+// expected-note@#RAC6FOO1{{previous definition is here}}
+
+template <class T> struct S1 {
+  template <typename U>
+  friend void dupe() {} // #S1DUPE
+
+  template <typename U>
+    requires same_as<U, U>
+  friend void dupe2() {} // #S1DUPE2
+};
+template <class T> struct S2 {
+  template <typename U>
+  friend void dupe() {} // #S2DUPE
+
+  template <typename U>
+    requires same_as<U, U>
+  friend void dupe2() {} // #S2DUPE2
+};
+
+template <class T> struct S3 {
+  template <typename U>
+    requires same_as<T, U>
+  friend void dupe() {}
+};
+template <class T> struct S4 {
+  template <typename U>
+    requires same_as<T, U>
+  friend void dupe() {}
+};
+
+// Same as S3 and S4, but aren't instantiated with the same T.
+template <class T> struct S5 {
+  template <typename U>
+    requires same_as<T, U>
+  friend void not_dupe() {}
+};
+template <class T> struct S6 {
+  template <typename U>
+    requires same_as<T, U>
+  friend void not_dupe() {}
+};
+
+template <class T> struct S7 {
+  void not_dupe()
+    requires same_as<T, T>
+  {}
+};
+
+void useS() {
+  S1<int> s1;
+  S2<double> s2;
+  // expected-error@#S2DUPE{{redefinition}}
+  // expected-note@-2{{in instantiation of template class}}
+  // expected-note@#S1DUPE{{previous definition is here}}
+  // expected-error@#S2DUPE2{{redefinition}}
+  // expected-note@#S1DUPE2{{previous definition is here}}
+
+  // OK, they have different 'scopes'.
+  S3<int> s3;
+  S4<int> s4;
+
+  // OK, because only instantiated with different T.
+  S5<int> s5;
+  S6<double> s6;
+
+  S7<int> s7;
+}
+
+} // namespace LibCXXOperatorRedef
+
+namespace NamedDeclRefs {
+  namespace my_std {
+    template<typename T, typename U>
+      concept Outer = true;
+    template<typename T>
+      using Inner = T;
+  }
+  template<typename T>
+    struct Proxy {
+      template<class U>
+        friend constexpr void RefOuter()
+        requires my_std::Outer<my_std::Inner<T>, my_std::Inner<U>>{}
+      template<class U>
+        friend constexpr void NoRefOuter() // #NOREFOUTER
+        requires my_std::Outer<my_std::Inner<U>, my_std::Inner<U>>{}
+    };
+  void use() {
+    Proxy<int> p;
+    Proxy<float> p2;
+    // expected-error@#NOREFOUTER {{redefinition of 'NoRefOuter'}}
+    // expected-note@-2{{in instantiation of template class}}
+    // expected-note@#NOREFOUTER{{previous definition is here}}
+  }
+} // namespace NamedDeclRefs

clang/test/SemaTemplate/concepts.cpp

 C auto **&&j3 = g(); // expected-error {{deduced type 'int' does not satisfy 'C'}}
 }
 
 namespace GH55567 {
 template<class, template <class> class> concept C = true;
 template <class> struct S {};
 void f(C<GH55567::S> auto);
 } // namespace GH55567
+
+namespace SubConstraintChecks {
+template <typename T>
+concept TrueConstraint = true;
+template <typename T>
+concept FalseConstraint = false;
+
+template <typename T, typename... Us>
+class ContainsConstrainedFuncTrue {
+public:
+  template <typename V, TrueConstraint Constrained>
+  static void func(V &&, Constrained &&C);
+};
+template <typename T, typename... Us>
+class ContainsConstrainedFuncFalse {
+public:
+  template <typename V, FalseConstraint Constrained>
+  static void func(V &&, Constrained &&C);
+};
+
+template <typename... Us>
+concept TrueConstraint2 =
+    requires(float &&t) {
+      ContainsConstrainedFuncTrue<float, Us...>::func(5, 0.0);
+    };
+template <typename... Us>
+concept FalseConstraint2 =
+    requires(float &&t) {
+      ContainsConstrainedFuncFalse<float, Us...>::func(5, 0.0); // #FC2_CONSTR
+    };
+
+template <typename T>
+void useTrue(int F)
+  requires TrueConstraint2<int>
+{}
+
+template <typename T>
+void useFalse(int F)             // #USE_FALSE
+  requires FalseConstraint2<int> // #USE_FALSE_CONSTR
+{}
+
+// Should only diagnose 'false' once instantiated.
+void UseUse() {
+  useTrue<int>(5);
+  useFalse<int>(5);
+  // expected-error@-1{{no matching function for call to 'useFalse'}}
+  // expected-note@#USE_FALSE{{constraints not satisfied}}
+  // expected-note@#USE_FALSE_CONSTR{{because 'int' does not satisfy 'FalseConstraint2'}}
+  // expected-note@#FC2_CONSTR {{would be invalid: no matching function for call to 'func'}}
+}
+} // namespace SubConstraintChecks
+
+namespace DeducedTemplateArgs {
+template <typename Itr> struct ItrTraits {
+  template <typename PtrItr> struct Ptr {
+  };
+  template <typename PtrItr>
+    requires requires { typename PtrItr::pointer; }
+  struct Ptr<PtrItr> {
+    using type = typename Itr::pointer;
+  };
+  using pointer = typename Ptr<Itr>::type; // #TRAITS_PTR
+};
+
+struct complete_itr {
+  using pointer = int;
+};
+
+template <typename T> class Complete {
+  using ItrType = ItrTraits<complete_itr>;
+  ItrType begin() noexcept { return ItrType(); }
+};
+
+// This version doesn't have 'pointer', so error confirms we are in the first
+// verison of 'Ptr'.
+struct not_complete_itr {
+};
+
+template <typename T> class NotComplete {
+  using ItrType = ItrTraits<not_complete_itr>;
+  ItrType begin() noexcept { return ItrType(); }
+  // expected-error@#TRAITS_PTR{{no type named 'type' in }}
+  // expected-note@-2{{in instantiation of template class }}
+};
+} // namespace DeducedTemplateArgs
+
+namespace DeferredInstantiationInstScope {
+template <typename T>
+struct remove_ref {
+  using type = T;
+};
+template <typename T>
+struct remove_ref<T &> {
+  using type = T;
+};
+template <typename T>
+struct remove_ref<T &&> {
+  using type = T;
+};
+
+template <typename T>
+constexpr bool IsInt = PR54443::is_same<typename remove_ref<T>::type,
+                                        int>::value;
+
+template <typename U>
+void SingleDepthReferencesTop(U &&u) {
+  struct lc {
+    void operator()()             // #SDRT_OP
+      requires IsInt<decltype(u)> // #SDRT_REQ
+    {}
+  };
+  lc lv;
+  lv(); // #SDRT_CALL
+}
+
+template <typename U>
+void SingleDepthReferencesTopNotCalled(U &&u) {
+  struct lc {
+    void operator()()
+      requires IsInt<typename decltype(u)::FOO>
+    {}
+  };
+  lc lv;
+}
+
+template <typename U>
+void SingleDepthReferencesTopCalled(U &&u) {
+  struct lc {
+    void operator()()                           // #CALLOP
+      requires IsInt<typename decltype(u)::FOO> // #CONSTR
+    {}
+  };
+  lc lv;
+  lv();
+  // expected-error@-1{{no matching function for call to object of type 'lc'}}
+  // expected-note@#SDRTC{{in instantiation of function template}}
+  // expected-note@#CALLOP{{constraints not satisfied}}
+  // expected-note@#CONSTR{{substituted constraint expression is ill-formed}}
+}
+
+template <typename U>
+void SingleDepthReferencesTopLambda(U &&u) {
+  []()
+    requires IsInt<decltype(u)>
+  {}();
+}
+
+template <typename U>
+void DoubleDepthReferencesTop(U &&u) {
+  struct lc { // #DDRT_STRCT
+    void operator()() {
+      struct lc2 {
+        void operator()()             // #DDRT_OP
+          requires IsInt<decltype(u)> // #DDRT_REQ
+        {}
+      };
+      lc2 lv2;
+      lv2(); // #DDRT_CALL
+    }
+  };
+  lc lv;
+  lv();
+}
+
+template <typename U>
+void DoubleDepthReferencesTopLambda(U &&u) {
+  []() { []()
+           requires IsInt<decltype(u)>
+         {}(); }();
+}
+
+template <typename U>
+void DoubleDepthReferencesAll(U &&u) {
+  struct lc { // #DDRA_STRCT
+    void operator()(U &&u2) {
+      struct lc2 {
+        void operator()(U &&u3)          // #DDRA_OP
+          requires IsInt<decltype(u)> && // #DDRA_REQ
+                   IsInt<decltype(u2)> && IsInt<decltype(u3)>
+        {}
+      };
+      lc2 lv2;
+      lv2(u2); // #DDRA_CALL
+    }
+  };
+  lc lv;
+  lv(u);
+}
+
+template <typename U>
+void DoubleDepthReferencesAllLambda(U &&u) {
+  [](U &&u2) {
+    [](U && u3)
+      requires IsInt<decltype(u)> &&
+               IsInt<decltype(u2)> && IsInt<decltype(u3)>
+    {}(u2);
+  }(u);
+}
+
+template <typename U>
+struct CausesFriendConstraint {
+  template <typename V>
+  friend void FriendFunc(CausesFriendConstraint, V) // #FF_DECL
+    requires IsInt<U> &&
+             IsInt<V> // #FF_REQ
+  {}
+};
+// FIXME: Re-enable this test when constraints are allowed to refer to captures.
+// template<typename T>
+// void ChecksCapture(T x) {
+//   [y = x]() requires(IsInt<decltype(y)>){}();
+// }
+
+template <typename T>
+void ChecksLocalVar(T x) {
+  T Local;
+  []()
+    requires(IsInt<decltype(Local)>)
+  {}();
+}
+
+template <typename T>
+void LocalStructMemberVar(T x) {
+  struct S {
+    T local;
+    void foo()
+      requires(IsInt<decltype(local)>) // #LSMV_REQ
+    {}
+  } s;
+  s.foo(); // #LSMV_CALL
+};
+
+template <typename T>
+struct ChecksMemberVar {
+  T t;
+  void foo()
+    requires(IsInt<decltype(t)>) // #CMV_FOO
+  {}
+  template <typename U>
+  void foo2()                    // #CMV_FOO2
+    requires(IsInt<decltype(t)>) // #CMV_FOO2_REQ
+  {}
+};
+
+void test_dependent() {
+  int v = 0;
+  float will_fail;
+  SingleDepthReferencesTop(v);
+  SingleDepthReferencesTop(will_fail);
+  // expected-error@#SDRT_CALL{{no matching function for call to object of type 'lc'}}
+  // expected-note@-2{{in instantiation of function template specialization}}
+  // expected-note@#SDRT_OP{{candidate function not viable}}
+  // expected-note@#SDRT_REQ{{'IsInt<decltype(u)>' evaluated to false}}
+
+  SingleDepthReferencesTopNotCalled(v);
+  // Won't error unless we try to call it.
+  SingleDepthReferencesTopNotCalled(will_fail);
+  SingleDepthReferencesTopCalled(v); // #SDRTC
+  SingleDepthReferencesTopLambda(v);
+  // FIXME: This should error on constraint failure! (Lambda!)
+  SingleDepthReferencesTopLambda(will_fail);
+  DoubleDepthReferencesTop(v);
+  DoubleDepthReferencesTop(will_fail);
+  // expected-error@#DDRT_CALL{{no matching function for call to object of type 'lc2'}}
+  // expected-note@-2{{in instantiation of function template specialization}}
+  // expected-note@#DDRT_STRCT{{in instantiation of member function}}
+  // expected-note@#DDRT_OP{{candidate function not viable}}
+  // expected-note@#DDRT_REQ{{'IsInt<decltype(u)>' evaluated to false}}
+
+  DoubleDepthReferencesTopLambda(v);
+  // FIXME: This should error on constraint failure! (Lambda!)
+  DoubleDepthReferencesTopLambda(will_fail);
+  DoubleDepthReferencesAll(v);
+  DoubleDepthReferencesAll(will_fail);
+  // expected-error@#DDRA_CALL{{no matching function for call to object of type 'lc2'}}
+  // expected-note@-2{{in instantiation of function template specialization}}
+  // expected-note@#DDRA_STRCT{{in instantiation of member function}}
+  // expected-note@#DDRA_OP{{candidate function not viable}}
+  // expected-note@#DDRA_REQ{{'IsInt<decltype(u)>' evaluated to false}}
+
+  DoubleDepthReferencesAllLambda(v);
+  // FIXME: This should error on constraint failure! (Lambda!)
+  DoubleDepthReferencesAllLambda(will_fail);
+
+  CausesFriendConstraint<int> CFC;
+  FriendFunc(CFC, 1);
+  FriendFunc(CFC, 1.0);
+  // expected-error@-1{{no matching function for call to 'FriendFunc'}}
+  // expected-note@#FF_DECL{{constraints not satisfied}}
+  // expected-note@#FF_REQ{{because 'IsInt<double>' evaluated to false}}
+
+  // FIXME: Re-enable this test when constraints are allowed to refer to captures.
+  // ChecksCapture(v);
+
+  ChecksLocalVar(v);
+  // FIXME: This should error on constraint failure! (Lambda!)
+  ChecksLocalVar(will_fail);
+
+  LocalStructMemberVar(v);
+  LocalStructMemberVar(will_fail);
+  // expected-error@#LSMV_CALL{{invalid reference to function 'foo'}}
+  // expected-note@-2{{in instantiation of function template specialization}}
+  // expected-note@#LSMV_REQ{{because 'IsInt<decltype(this->local)>' evaluated to false}}
+
+  ChecksMemberVar<int> CMV;
+  CMV.foo();
+  CMV.foo2<int>();
+
+  ChecksMemberVar<float> CMV2;
+  CMV2.foo();
+  // expected-error@-1{{invalid reference to function 'foo'}}
+  // expected-note@#CMV_FOO{{because 'IsInt<decltype(this->t)>' evaluated to false}}
+  CMV2.foo2<float>();
+  // expected-error@-1{{no matching member function for call to 'foo2'}}
+  // expected-note@#CMV_FOO2{{constraints not satisfied}}
+  // expected-note@#CMV_FOO2_REQ{{because 'IsInt<decltype(this->t)>' evaluated to false}}
+}
+} // namespace DeferredInstantiationInstScope
+
+// Ane example of evaluating a concept at two different depths in the same
+// evaluation.  No diagnostic is expected.
+namespace SameConceptDifferentDepth {
+template <class _Ip>
+concept sentinel_for =
+    requires(_Ip __i) {
+      __i++;
+    };
+
+template <class _Ip>
+concept bidirectional_iterator =
+    sentinel_for<_Ip>;
+
+template <class _Iter>
+class move_iterator {
+public:
+  auto operator++(int)
+    requires sentinel_for<_Iter>{}
+};
+
+static_assert(bidirectional_iterator<move_iterator<int>>);
+} // namespace SameConceptDifferentDepth
+
+namespace VarInit {
+template <class _Tp>
+concept __can_reference = true;
+
+template <class _Iter>
+class common_iterator {
+public:
+  common_iterator() {
+    constexpr auto x = requires(_Iter & __i) { { __i } -> __can_reference; };
+  }
+};
+
+void test() {
+  auto commonIter1 = common_iterator<int>();
+}
+} // namespace VarInit
+
+
+namespace InlineFriendOperator {
+template <typename T>
+concept C = true;
+template <class _Iter>
+class counted_iterator {
+  _Iter I;
+public:
+  constexpr counted_iterator() = default;
+  friend constexpr auto operator+( // expected-note {{candidate function not viable}}
+      int __n, const counted_iterator &__x)
+    requires C<decltype(I)>
+  {
+    return __x + __n; // expected-error{{invalid operands to binary expression}}
+  }
+};
+
+constexpr bool test() {
+  counted_iterator<int> iter;
+  auto x = 2 + iter; // expected-note{{in instantiation of member function 'InlineFriendOperator::operator+'}}
+
+  return true;
+}
+} // namespace InlineFriendOperator
+
+namespace ClassTemplateInstantiation {
+struct Type;
+template < typename A, typename B, typename C>
+  concept ConstraintF = false; // #ConstraintF
+template < typename A, typename B, typename C>
+  concept ConstraintT = true;
+
+template < typename T > struct Parent {
+  template < typename U, ConstraintT<T, U> > struct ChildT{};
+  ChildT<Type, Type> CauseInstT;
+  template < typename U, ConstraintF<T, U> > struct ChildF{};// #ChildF
+  ChildF<Type, Type> CauseInstF; //#CauseInstF
+};
+
+// expected-error@#CauseInstF{{constraints not satisfied for class template}}
+// expected-note@+3{{in instantiation of template class}}
+// expected-note@#ChildF{{evaluated to false}}
+// expected-note@#ConstraintF{{because 'false' evaluated to false}}
+Parent<int> Inst;
+} // namespace ClassTemplateInstantiation
+
+namespace SelfFriend {
+  template<class T>
+  concept Constraint = requires (T i) { (*i); };
+  template<class T>
+  concept Constraint2 = requires (T i) { (*i); };
+
+  template<Constraint T>
+  struct Iterator {
+    template <Constraint>
+    friend class Iterator;
+    void operator*();
+  };
+
+  template<Constraint T> // #ITER_BAD
+  struct IteratorBad {
+    template <Constraint2>//#ITER_BAD_FRIEND
+    friend class IteratorBad;
+    void operator*();
+  };
+
+  Iterator<int*> I;
+  Iterator<char*> I2;
+  IteratorBad<int*> I3; // expected-error@#ITER_BAD_FRIEND{{constraint differs}}
+                        // expected-note@-1{{in instantiation of template class}}
+                        // expected-note@#ITER_BAD{{previous template declaration}}
+} // namespace SelfFriend
+
+
+namespace ConstrainedMemberVarTemplate {
+template <long Size> struct Container {
+  static constexpr long arity = Size;
+  template <typename U>
+  requires(sizeof(U) == arity) // #CMVT_REQ
+  using var_templ = int;
+};
+Container<4>::var_templ<int> inst;
+Container<5>::var_templ<int> inst_fail;
+// expected-error@-1{{constraints not satisfied for alias template 'var_templ'}}
+// expected-note@#CMVT_REQ{{because 'sizeof(int) == arity' (4 == 5) evaluated to false}}
+} // namespace ConstrainedMemberVarTemplate 
+

clang/test/SemaTemplate/deferred-concept-inst.cpp

+// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify -fsyntax-only -Wno-unused-value
+// expected-no-diagnostics
+
+namespace GithubBug44178 {
+template <typename D>
+struct CRTP {
+  void call_foo()
+    requires requires(D &v) { v.foo(); }
+  {
+    static_cast<D *>(this)->foo();
+  }
+};
+
+struct Test : public CRTP<Test> {
+  void foo() {}
+};
+
+int main() {
+  Test t;
+  t.call_foo();
+  return 0;
+}
+} // namespace GithubBug44178

clang/test/SemaTemplate/instantiate-requires-clause.cpp

-// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify
+// RUN: %clang_cc1 -std=c++2a -x c++ %s -Wno-unused-value -verify
 
 template <typename... Args> requires ((sizeof(Args) == 1), ...)
 // expected-note@-1 {{because '(sizeof(int) == 1) , (sizeof(char) == 1) , (sizeof(int) == 1)' evaluated to false}}
 void f1(Args&&... args) { }
 // expected-note@-1 {{candidate template ignored: constraints not satisfied [with Args = <int, char, int>]}}
 
 using f11 = decltype(f1('a'));
 using f12 = decltype(f1(1, 'b'));
struct S {
   template<typename U>
   static constexpr auto f(U const index) requires(index, true) {
     return true;
   }
 };
 
 static_assert(S<void>::f(1));
 
+// Similar to the 'S' test, but tries to use 'U' in the requires clause.
+template <typename T2>
+struct S1 {
+  // expected-note@+3 {{candidate template ignored: constraints not satisfied [with U = int]}}
+  // expected-note@+3 {{because substituted constraint expression is ill-formed: type 'int' cannot be used prior to '::' because it has no members}}
+  template <typename U>
+  static constexpr auto f(U const index)
+    requires(U::foo)
+  { return true; }
+};
+
+// expected-error@+1 {{no matching function for call to 'f'}}
+static_assert(S1<void>::f(1));
+
 constexpr auto value = 0;
 
 template<typename T>
 struct S2 {
   template<typename = void> requires(value, true)
   static constexpr auto f() requires(value, true) {
   }
 };

clang/test/SemaTemplate/trailing-return-short-circuit.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+
+template <class T>
+  requires(sizeof(T) > 2) || T::value // #FOO_REQ
+void Foo(T){};                        // #FOO
+
+template <class T>
+void TrailingReturn(T)       // #TRAILING
+  requires(sizeof(T) > 2) || // #TRAILING_REQ
+          T::value           // #TRAILING_REQ_VAL
+{};
+template <bool B>
+struct HasValue {
+  static constexpr bool value = B;
+};
+static_assert(sizeof(HasValue<true>) <= 2);
+
+template <bool B>
+struct HasValueLarge {
+  static constexpr bool value = B;
+  int I;
+};
+static_assert(sizeof(HasValueLarge<true>) > 2);
+
+void usage() {
+  // Passes the 1st check, short-circuit so the 2nd ::value is not evaluated.
+  Foo(1.0);
+  TrailingReturn(1.0);
+
+  // Fails the 1st check, but has a ::value, so the check happens correctly.
+  Foo(HasValue<true>{});
+  TrailingReturn(HasValue<true>{});
+
+  // Passes the 1st check, but would have passed the 2nd one.
+  Foo(HasValueLarge<true>{});
+  TrailingReturn(HasValueLarge<true>{});
+
+  // Fails the 1st check, fails 2nd because there is no ::value.
+  Foo(true);
+  // expected-error@-1{{no matching function for call to 'Foo'}}
+  // expected-note@#FOO{{candidate template ignored: constraints not satisfied [with T = bool]}}
+  // expected-note@#FOO_REQ{{because 'sizeof(_Bool) > 2' (1 > 2) evaluated to false}}
+  // expected-note@#FOO_REQ{{because substituted constraint expression is ill-formed: type 'bool' cannot be used prior to '::' because it has no members}}
+
+  TrailingReturn(true);
+  // expected-error@-1{{no matching function for call to 'TrailingReturn'}}
+  // expected-note@#TRAILING{{candidate template ignored: constraints not satisfied [with T = bool]}}
+  // expected-note@#TRAILING_REQ{{because 'sizeof(_Bool) > 2' (1 > 2) evaluated to false}}
+  // expected-note@#TRAILING_REQ_VAL{{because substituted constraint expression is ill-formed: type 'bool' cannot be used prior to '::' because it has no members}}
+
+  // Fails the 1st check, fails 2nd because ::value is false.
+  Foo(HasValue<false>{});
+  // expected-error@-1 {{no matching function for call to 'Foo'}}
+  // expected-note@#FOO{{candidate template ignored: constraints not satisfied [with T = HasValue<false>]}}
+  // expected-note@#FOO_REQ{{because 'sizeof(HasValue<false>) > 2' (1 > 2) evaluated to false}}
+  // expected-note@#FOO_REQ{{and 'HasValue<false>::value' evaluated to false}}
+  TrailingReturn(HasValue<false>{});
+  // expected-error@-1 {{no matching function for call to 'TrailingReturn'}}
+  // expected-note@#TRAILING{{candidate template ignored: constraints not satisfied [with T = HasValue<false>]}}
+  // expected-note@#TRAILING_REQ{{because 'sizeof(HasValue<false>) > 2' (1 > 2) evaluated to false}}
+  // expected-note@#TRAILING_REQ_VAL{{and 'HasValue<false>::value' evaluated to false}}
+}