[Sema] Lambdas are not part of immediate context for deduction

[ilya-biryukov]

Summary

This commit implements [temp.deduct]p9.
Test updates include:

• New notes in cxx1y-init-captures.cpp, lambda-expressions.cpp and 'warn-unused-lambda-capture.cpp'. This seems to be caused by diagnosing errors earlier (during deduction) that were previously surfaced later (during instantiation).
• New error lambda-unevaluated.cpp is in line with [temp.deduct]p9.

[erichkeane]

My one concern is that this is going to expose our incorrect instantiation of lambdas further and more painfully (see https://github.com/llvm/llvm-project/issues/58872). Else, I don't see anything to be concerned about here.

I think the FIXME of adding a note diagnostic here should be fixed before committing however.

clang/lib/Sema/SemaTemplateInstantiate.cpp

965

Would really like this note here, it shouldn't be too difficult, right?

[ilya-biryukov]

clang/lib/Sema/SemaTemplateInstantiate.cpp

965

Ah, sorry, I added a comment here that I forgot to submit. The question is: could it be that we want to skip this note?

I wanted to double-check if folks find this note useful.
On one hand, this probably creates some noise as there will always be other notes that point into the location of a corresponding substitution location that contains the lambda.
On the other hand, since the lambda is not an immediate context, this may give hints to users on why SFINAE does not apply.

If you feel like the note is useful, I will follow up with an implementation.

[erichkeane]

clang/lib/Sema/SemaTemplateInstantiate.cpp

965

I think it is useful for exactly the reason you mentioned: this is going to be somewhat shocking behavior to most people, so explaining it better will be helpful.

[shafik]

clang/test/CXX/temp/temp.deduct/p9.cpp

3

Maybe helpful to quote p9?

37

I know the note in the standard does not explain why this is ok but a comment would be helpful to future readers.

40

I think the comment from the draft is helpful here "deduction fails on #1, calls #2"

clang/test/SemaCXX/warn-unused-lambda-capture.cpp

192

Why the 12 extra notes here, I feel I am missing something but not sure what. I see the increase in notes in other cases as well.

[ilya-biryukov]

• Add a note when substituting into a lambda
• Quote the standard and add explanation for the test

[ilya-biryukov]

In D148802#4283566, @erichkeane wrote:

My one concern is that this is going to expose our incorrect instantiation of lambdas further and more painfully (see https://github.com/llvm/llvm-project/issues/58872). Else, I don't see anything to be concerned about here.

That's true, but it seems that as a result of this patch, Clang will start rejecting some valid C++ programs when lambdas are used in unevaluated contexts, but will stop (incorrectly) accepting a class of programs that are invalid according to C++ standard.
I would err on the side of false negatives (correct program not compiled) instead of false positives (incorrect program complied). Otherwise, future changes that make Clang compliant can potentially require rewriting the code that relied on incorrect behavior.
It's still unfortunate that we don't accept valid programs, but at least existing code will not need to be changed after GH58872 is fixed.
My perspective is based on the need to support a large codebase, in which codebase-wide refactorings are expensive, other might have a different opinion here.

clang/lib/Sema/SemaTemplateInstantiate.cpp

965

Makes sense. Added a corresponding note.

clang/test/SemaCXX/warn-unused-lambda-capture.cpp

192

I'm not entirely sure, but it seems there is some deduplication of notes that's happening when the stacks of code-synthesis-contexts for subsequent errors are the same.
However, this patch introduces a different code synthesis context for lambda substitutions, forcing the notes to be added.
In the new version of the patch, the added context actually shows up in the notes as well.

[ilya-biryukov]

Friendly ping for another round of review.

[ilya-biryukov]

Another friendly ping for review.
@erichkeane let me know if you feel that exposing the incorrect lambda instantiation behavior is a blocker here.

[erichkeane]

In D148802#4326268, @ilya-biryukov wrote:

Another friendly ping for review.
@erichkeane let me know if you feel that exposing the incorrect lambda instantiation behavior is a blocker here.

I don't... we're up to ~4 active bugs on that, so its not like it is 'unexposed' now. I think this looks good enough to accept;

clang/test/SemaCXX/warn-unused-lambda-capture.cpp

192

Note that this test is organized poorly, and the 12 additions are likely the levels added above, and it is 1 per error, so its just 1 more level of 'in instantiation...' in each of those cases above.

[ilya-biryukov]

• Moved the relase note to 'C++20 feature support', fixed typos

[ilya-biryukov]

• Fix a typo (forgot to commit last time)

clang/docs/ReleaseNotes.rst

 - Clang now supports ``__builtin_assume_separate_storage`` that indicates that
   its arguments point to objects in separate storage allocations.
 - Clang now supports expressions in ``#pragma clang __debug dump``.
 - Clang now supports declaration of multi-dimensional arrays with
   ``__declspec(property)``.
 - A new builtin type trait ``__is_trivially_equaltiy_comparable`` has been added,
   which checks whether comparing two instances of a type is equivalent to
   ``memcmp(&lhs, &rhs, sizeof(T)) == 0``.
+- Clang now implements `[temp.deduct]p9`, subsitution failures inside lambdas from
+  unevaluated contexts will be surfaced as errors. They were previously handled as
+  SFINAE.
+
 
 New Compiler Flags
 ------------------
 
 Deprecated Compiler Flags
 -------------------------
 
 Modified Compiler Flags

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_checking_constraints_for_function_here : Note<
   "while checking constraint satisfaction for function '%0' required here">;
 def note_constraint_substitution_here : Note<
   "while substituting template arguments into constraint expression here">;
 def note_constraint_normalization_here : Note<
   "while calculating associated constraint of template '%0' here">;
 def note_parameter_mapping_substitution_here : Note<
   "while substituting into concept arguments here; substitution failures not "
   "allowed in concept arguments">;
+def note_lambda_substitution_here : Note<
+  "while substituting into a lambda expression here">;
 def note_instantiation_contexts_suppressed : Note<
   "(skipping %0 context%s0 in backtrace; use -ftemplate-backtrace-limit=0 to "
   "see all)">;
 
 def err_field_instantiates_to_function : Error<
   "data member instantiated with function type %0">;
 def err_variable_instantiates_to_function : Error<
   "%select{variable|static data member}0 instantiated with function type %1">;

clang/include/clang/Sema/Sema.h

enum SynthesisKind {
 
       /// We are substituting template argument determined as part of
       /// template argument deduction for either a class template
       /// partial specialization or a function template. The
       /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or
       /// a TemplateDecl.
       DeducedTemplateArgumentSubstitution,
 
+      /// We are substituting into a lambda expression.
+      LambdaExpressionSubstitution,
+
       /// We are substituting prior template arguments into a new
       /// template parameter. The template parameter itself is either a
       /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
       PriorTemplateArgumentSubstitution,
 
       /// We are checking the validity of a default template argument that
       /// has been used when naming a template-id.
       DefaultTemplateArgumentChecking,

clang/lib/Frontend/FrontendActions.cpp

static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
       return "DefaultTemplateArgumentInstantiation";
     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
       return "DefaultFunctionArgumentInstantiation";
     case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
       return "ExplicitTemplateArgumentSubstitution";
     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
       return "DeducedTemplateArgumentSubstitution";
+    case CodeSynthesisContext::LambdaExpressionSubstitution:
+      return "LambdaExpressionSubstitution";
     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
       return "PriorTemplateArgumentSubstitution";
     case CodeSynthesisContext::DefaultTemplateArgumentChecking:
       return "DefaultTemplateArgumentChecking";
     case CodeSynthesisContext::ExceptionSpecEvaluation:
       return "ExceptionSpecEvaluation";
     case CodeSynthesisContext::ExceptionSpecInstantiation:
       return "ExceptionSpecInstantiation";

clang/lib/Sema/SemaTemplateInstantiate.cpp

 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConcept.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/TemplateInstCallback.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TimeProfiler.h"
 #include <optional>
 
 using namespace clang;
 using namespace sema;
 
 //===----------------------------------------------------------------------===/
bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
   case ExceptionSpecEvaluation:
   case ConstraintSubstitution:
   case ParameterMappingSubstitution:
   case ConstraintNormalization:
   case RewritingOperatorAsSpaceship:
   case InitializingStructuredBinding:
   case MarkingClassDllexported:
   case BuildingBuiltinDumpStructCall:
+  case LambdaExpressionSubstitution:
     return false;
 
   // This function should never be called when Kind's value is Memoization.
   case Memoization:
     break;
   }
 
   llvm_unreachable("Invalid SynthesisKind!");
case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
       Diags.Report(Active->PointOfInstantiation,
                    diag::note_building_builtin_dump_struct_call)
           << convertCallArgsToString(
                  *this, llvm::ArrayRef(Active->CallArgs, Active->NumCallArgs));
       break;
 
     case CodeSynthesisContext::Memoization:
       break;
 
+    case CodeSynthesisContext::LambdaExpressionSubstitution:
+      Diags.Report(Active->PointOfInstantiation,
+                   diag::note_lambda_substitution_here);
+      break;
     case CodeSynthesisContext::ConstraintsCheck: {
       unsigned DiagID = 0;
       if (!Active->Entity) {
         Diags.Report(Active->PointOfInstantiation,
                      diag::note_nested_requirement_here)
           << Active->InstantiationRange;
         break;
       }
for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
     }
   }
 }
 
 std::optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
   if (InNonInstantiationSFINAEContext)
     return std::optional<TemplateDeductionInfo *>(nullptr);
 
+  bool SawLambdaSubstitution = false;
   for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
          Active = CodeSynthesisContexts.rbegin(),
          ActiveEnd = CodeSynthesisContexts.rend();
        Active != ActiveEnd;
        ++Active)
   {
     switch (Active->Kind) {
     case CodeSynthesisContext::TemplateInstantiation:
       // An instantiation of an alias template may or may not be a SFINAE
       // context, depending on what else is on the stack.
       if (isa<TypeAliasTemplateDecl>(Active->Entity))
         break;
       [[fallthrough]];
     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
     case CodeSynthesisContext::ExceptionSpecInstantiation:
     case CodeSynthesisContext::ConstraintsCheck:
     case CodeSynthesisContext::ParameterMappingSubstitution:
     case CodeSynthesisContext::ConstraintNormalization:
     case CodeSynthesisContext::NestedRequirementConstraintsCheck:
       // This is a template instantiation, so there is no SFINAE.
       return std::nullopt;
+    case CodeSynthesisContext::LambdaExpressionSubstitution:
+      // [temp.deduct]p9
+      // A lambda-expression appearing in a function type or a template
+      // parameter is not considered part of the immediate context for the
+      // purposes of template argument deduction.
+
+      // We need to check parents.
+      SawLambdaSubstitution = true;
+      break;
 
     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
     case CodeSynthesisContext::DefaultTemplateArgumentChecking:
     case CodeSynthesisContext::RewritingOperatorAsSpaceship:
       // A default template argument instantiation and substitution into
       // template parameters with arguments for prior parameters may or may
       // not be a SFINAE context; look further up the stack.
       break;
 
     case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
+      // We're either substituting explicitly-specified template arguments,
+      // deduced template arguments. SFINAE applies unless we are in a lambda
+      // expression, see [temp.deduct]p9.
+      if (SawLambdaSubstitution)
+        return std::nullopt;
+      [[fallthrough]];
     case CodeSynthesisContext::ConstraintSubstitution:
     case CodeSynthesisContext::RequirementInstantiation:
     case CodeSynthesisContext::RequirementParameterInstantiation:
-      // We're either substituting explicitly-specified template arguments,
-      // deduced template arguments, a constraint expression or a requirement
-      // in a requires expression, so SFINAE applies.
+      // SFINAE always applies in a constraint expression or a requirement
+      // in a requires expression.
       assert(Active->DeductionInfo && "Missing deduction info pointer");
       return Active->DeductionInfo;
 
     case CodeSynthesisContext::DeclaringSpecialMember:
     case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
     case CodeSynthesisContext::DefiningSynthesizedFunction:
     case CodeSynthesisContext::InitializingStructuredBinding:
     case CodeSynthesisContext::MarkingClassDllexported:
public:
     QualType
     TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                            SubstTemplateTypeParmPackTypeLoc TL,
                                            bool SuppressObjCLifetime);
 
     ExprResult TransformLambdaExpr(LambdaExpr *E) {
       LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
       Sema::ConstraintEvalRAII<TemplateInstantiator> RAII(*this);
+
+      Sema::CodeSynthesisContext C;
+      C.Kind = clang::Sema::CodeSynthesisContext::LambdaExpressionSubstitution;
+      C.PointOfInstantiation = E->getBeginLoc();
+      SemaRef.pushCodeSynthesisContext(C);
+      auto PopCtx =
+          llvm::make_scope_exit([this] { SemaRef.popCodeSynthesisContext(); });
+
       ExprResult Result = inherited::TransformLambdaExpr(E);
       if (Result.isInvalid())
         return Result;
 
       CXXMethodDecl *MD = Result.getAs<LambdaExpr>()->getCallOperator();
       for (ParmVarDecl *PVD : MD->parameters()) {
         assert(PVD && "null in a parameter list");
         if (!PVD->hasDefaultArg())

clang/test/CXX/expr/expr.prim/expr.prim.lambda/default-arguments.cpp

struct NoDefaultCtor {
   NoDefaultCtor(const NoDefaultCtor&); // expected-note{{candidate constructor}} \
                                        // expected-note{{candidate constructor not viable: requires 1 argument, but 0 were provided}}
   ~NoDefaultCtor();
 };
 
 template<typename T>
 void defargs_in_template_unused(T t) {
   auto l1 = [](const T& value = T()) { };  // expected-error{{no matching constructor for initialization of 'NoDefaultCtor'}} \
-                                           // expected-note {{in instantiation of default function argument expression for 'operator()<NoDefaultCtor>' required here}}
+                                           // expected-note {{in instantiation of default function argument expression for 'operator()<NoDefaultCtor>' required here}} \
+                                           // expected-note {{while substituting into a lambda expression here}}
   l1(t);
 }
 
 template void defargs_in_template_unused(NonPOD);
 template void defargs_in_template_unused(NoDefaultCtor);  // expected-note{{in instantiation of function template specialization 'defargs_in_template_unused<NoDefaultCtor>' requested here}}
 
 template<typename T>
 void defargs_in_template_used() {
   auto l1 = [](const T& value = T()) { }; // expected-error{{no matching constructor for initialization of 'NoDefaultCtor'}} \
-                                          // expected-note {{in instantiation of default function argument expression for 'operator()<NoDefaultCtor>' required here}}
+                                          // expected-note {{in instantiation of default function argument expression for 'operator()<NoDefaultCtor>' required here}} \
+                                          // expected-note {{while substituting into a lambda expression here}}
   l1();
 }
 
 template void defargs_in_template_used<NonPOD>();
 template void defargs_in_template_used<NoDefaultCtor>(); // expected-note{{in instantiation of function template specialization}}
 

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp

struct ExplicitCopy {
   explicit ExplicitCopy(const ExplicitCopy&); // expected-note 2{{not a candidate}}
 };
 auto init_kind_1 = [ec(ExplicitCopy())] {};
 auto init_kind_2 = [ec = ExplicitCopy()] {}; // expected-error {{no matching constructor}}
 
 template<typename T> void init_kind_template() {
   auto init_kind_1 = [ec(T())] {};
   auto init_kind_2 = [ec = T()] {}; // expected-error {{no matching constructor}}
+                                    // expected-note@-1 {{while substituting into a lambda expression here}}
 }
 template void init_kind_template<int>();
 template void init_kind_template<ExplicitCopy>(); // expected-note {{instantiation of}}
 
 void void_fn();
 int overload_fn();
 int overload_fn(int);
 
 auto bad_init_1 = [a()] {}; // expected-error {{expected expression}}
 auto bad_init_2 = [a(1, 2)] {}; // expected-error {{initializer for lambda capture 'a' contains multiple expressions}}
 auto bad_init_3 = [&a(void_fn())] {}; // expected-error {{cannot form a reference to 'void'}}
 auto bad_init_4 = [a(void_fn())] {}; // expected-error {{has incomplete type 'void'}}
 auto bad_init_5 = [a(overload_fn)] {}; // expected-error {{cannot deduce type for lambda capture 'a' from initializer of type '<overloaded function}}
 auto bad_init_6 = [a{overload_fn}] {}; // expected-error {{cannot deduce type for lambda capture 'a' from initializer list}}
 auto bad_init_7 = [a{{1}}] {}; // expected-error {{cannot deduce type for lambda capture 'a' from nested initializer list}}
 
 template<typename...T> void pack_1(T...t) { (void)[a(t...)] {}; } // expected-error {{initializer missing for lambda capture 'a'}}
+                                                                  // expected-note@-1 {{while substituting into a lambda expression here}}
 template void pack_1<>(); // expected-note {{instantiation of}}
 
 // No lifetime-extension of the temporary here.
 auto a_copy = [&c = static_cast<const int&&>(0)] {}; // expected-warning {{temporary whose address is used as value of local variable 'a_copy' will be destroyed at the end of the full-expression}} expected-note {{via initialization of lambda capture 'c'}}
 
 // But there is lifetime extension here.
 auto &&a = [a(4), b = 5, &c = static_cast<const int&&>(0)] {
   static_assert(sizeof(a) == sizeof(int), "");
   static_assert(sizeof(b) == sizeof(int), "");
   using T = decltype(c);
   using T = const int &;
 };
 auto b = [a{0}] {}; // OK, per N3922
 
 struct S { S(); S(S&&); };
 template<typename T> struct remove_reference { typedef T type; };
 template<typename T> struct remove_reference<T&> { typedef T type; };
 template<typename T> decltype(auto) move(T &&t) { return static_cast<typename remove_reference<T>::type&&>(t); }
 auto s = [s(move(S()))] {};
 
 template<typename T> T instantiate_test(T t) {
   [x(&t)]() { *x = 1; } (); // expected-error {{assigning to 'const char *'}}
+                            // expected-note@-1 {{while substituting into a lambda expression here}}
   return t;
 }
 int instantiate_test_1 = instantiate_test(0);
 const char *instantiate_test_2 = instantiate_test("foo"); // expected-note {{here}}

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p23.cpp

void init_capture_pack_err(Args ...args) {
   [&args...] {} ();
   [...&args] {} (); // expected-error {{ellipsis in pack capture must appear after the name of the capture}}
   [&...args] {} (); // expected-error {{ellipsis in pack capture must appear after the name of the capture}}
 }
 
 template<typename ...Args>
 void init_capture_pack_multi(Args ...args) {
   [as(args...)] {} (); // expected-error {{initializer missing for lambda capture 'as'}} expected-error {{multiple}}
+                       // expected-note@-1 2{{while substituting into a lambda expression}}
 }
 template void init_capture_pack_multi(); // expected-note {{instantiation}}
 template void init_capture_pack_multi(int);
 template void init_capture_pack_multi(int, int); // expected-note {{instantiation}}
 
 template<typename ...Args>
 void init_capture_pack_outer(Args ...args) {
   print([as(args)] { return sizeof(as); } () ...);
 }
 template void init_capture_pack_outer();
 template void init_capture_pack_outer(int);
 template void init_capture_pack_outer(int, int);

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4.cpp

void test_result_type(int N) {
 
   typedef int vla[N];
   auto l2 = [] () -> vla { }; // expected-error{{function cannot return array type 'vla' (aka 'int[N]')}}
 }
 
 template <typename T>
 void test_result_type_tpl(int N) {
   auto l1 = []() -> T {}; // expected-error{{incomplete result type 'Incomplete' in lambda expression}}
+                          // expected-note@-1{{while substituting into a lambda expression here}}
   typedef int vla[N];
   auto l2 = []() -> vla {}; // expected-error{{function cannot return array type 'vla' (aka 'int[N]')}}
 }
 
 void test_result_type_call() {
   test_result_type_tpl<Incomplete>(10); // expected-note {{requested here}}
 }

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p2.cpp

 
 namespace generic_lambda {
   // Substituting for T produces a hard error here, even if substituting for
   // the type of x would remove the error.
   template<typename T> void f() {
     [](auto x) {
       if constexpr (sizeof(T) == 1 && sizeof(x) == 1)
         T::error(); // expected-error 2{{'::'}}
+                    // expected-note@-3 2{{while substituting into a lambda expression here}}
     } (0);
   }
 
   template<typename T> void g() {
     [](auto x) {
       if constexpr (sizeof(T) == 1)
         if constexpr (sizeof(x) == 1)
           T::error(); // expected-error {{'::'}}
+                      // expected-note@-4 {{while substituting into a lambda expression here}}
     } (0);
   }
 
   void use() {
     f<int>(); // expected-note {{instantiation of}}
     f<char>(); // expected-note {{instantiation of}}
     g<int>(); // ok
     g<char>(); // expected-note {{instantiation of}}

clang/test/CXX/temp/temp.deduct/p9.cpp

+// RUN:  %clang_cc1 -std=c++20 -verify %s
+// [temp.deduct.p9]
+// A lambda-expression appearing in a function type or a template parameter is
+// not considered part of the immediate context for the purposes of template
+// argument deduction.
+// [Note: The intent is to avoid requiring implementations to deal with
+// substitution failure involving arbitrary statements.]
+template <class T>
+auto f(T) -> decltype([]() { T::invalid; } ());
+void f(...);
+void test_f() {
+  f(0); // expected-error@-3 {{type 'int' cannot be used prior to '::'}}
+        // expected-note@-1 {{while substituting deduced template arguments}}
+        // expected-note@-5 {{while substituting into a lambda expression here}}
+}
+
+template <class T, unsigned = sizeof([]() { T::invalid; })>
+void g(T);
+void g(...);
+void test_g() {
+  g(0); // expected-error@-4 {{type 'int' cannot be used prior to '::'}}
+        // expected-note@-4 {{in instantiation of default argument}}
+        // expected-note@-2 {{while substituting deduced template arguments}}
+        // expected-note@-7 {{while substituting into a lambda expression here}}
+}
+
+template <class T>
+auto h(T) -> decltype([x = T::invalid]() { });
+void h(...);
+void test_h() {
+  h(0); // expected-error@-3 {{type 'int' cannot be used prior to '::'}}
+        // expected-note@-1 {{while substituting deduced template arguments}}
+        // expected-note@-5 {{while substituting into a lambda expression here}}
+}
+
+template <class T>
+auto i(T) -> decltype([]() -> typename T::invalid { });
+void i(...);
+void test_i() {
+  i(0); // expected-error@-3 {{type 'int' cannot be used prior to '::'}}
+        // expected-note@-1 {{while substituting deduced template arguments}}
+        // expected-note@-5 {{while substituting into a lambda expression here}}
+}
+
+
+// In this example, the lambda itself is not part of an immediate context, but
+// substitution to the lambda expression succeeds, producing dependent
+// `decltype(x.invalid)`. The call to the lambda, however, is in the immediate context
+// and it produces a SFINAE failure. Hence, we pick the second overload
+// and don't produce any errors.
+template <class T>
+auto j(T t) -> decltype([](auto x) -> decltype(x.invalid) { } (t));   // #1
+void j(...);                                                          // #2
+void test_j() {
+  j(0); // deduction fails on #1, calls #2.
+}

clang/test/CXX/temp/temp.param/p15-cxx0x.cpp

 // This case should not produce an error, because in A's instantiation, Cs is
 // not a parameter pack.
 template<typename...Ts> void consume(Ts...);
 template<typename...Ts> struct A {
   template<template<typename, Ts = 0> class ...Cs, Cs<Ts> ...Vs> struct B { // ok
     B() {
       consume([]{
         int arr[Vs]; // expected-error {{negative size}}
+                     // expected-note@-2 {{while substituting into a lambda expression here}}
       }...);
     }
   };
 };
 template<typename, int> using Int = int;
 template<typename, short> using Char = char;
 A<int, short>::B<Int, Char, -1, 'x'> b; // expected-note {{here}}
 

clang/test/PCH/cxx1y-init-captures.cpp

 
 #else
 
 int y = counter();
 
 void g() {
   f(0); // ok
   // expected-error@18 {{lvalue of type 'const char *const'}}
+  // expected-note@18 {{substituting into a lambda}}
   f("foo"); // expected-note {{here}}
 }
 
 #endif

clang/test/SemaCXX/cxx1y-generic-lambdas-capturing.cpp

 }
 namespace more_this_capture_1_1 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) {
-      return [](int i) { // expected-note {{explicitly capture 'this'}}
-        return [=](auto b) {
+      return [](int i) { // expected-note {{explicitly capture 'this'}} expected-note {{while substituting into a lambda}}
+        return [=](auto b) { // expected-note {{while substituting into a lambda}}
           f(decltype(a){}); //expected-error{{this}}
           int x = i;
         };
       };
     };
     auto M = L(0.0);  
     auto N = M(3);
     N(5.32); // OK 
     L(3); // expected-note{{instantiation}}
     return 0;
   }
 };
 int run = X{}.g();
 }
 
 namespace more_this_capture_1_1_1 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) {
-      return [](auto b) { // expected-note {{explicitly capture 'this'}}
-        return [=](int i) {
+      return [](auto b) { // expected-note {{explicitly capture 'this'}} expected-note {{while substituting into a lambda}}
+        return [=](int i) { // expected-note {{while substituting into a lambda}}
           f(b); 
           f(decltype(a){}); //expected-error{{this}}
         };
       };
     };
     auto M = L(0.0);  // OK
     auto N = M(3.3); //OK
     auto M_int = L(0); //expected-note{{instantiation}}
     return 0;
   }
 };
 int run = X{}.g();
 }
 
 
 namespace more_this_capture_1_1_1_1 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) {
       return [](auto b) { // expected-note {{explicitly capture 'this'}}
-        return [=](int i) {
+        return [=](int i) { // expected-note {{while substituting into a lambda}}
           f(b); //expected-error{{this}}
           f(decltype(a){}); 
         };
       };
     };
     auto M_double = L(0.0);  // OK
     auto N = M_double(3); //expected-note{{instantiation}}
     

clang/test/SemaCXX/cxx1y-generic-lambdas.cpp

auto L = [](auto a) {
     };
   };
   auto M = L(3);
   M(4.15);
  }
 {
   int i = 10; //expected-note 3{{declared here}}
   auto L = [](auto a) {
-    return [](auto b) { //expected-note 3{{begins here}} expected-note 6 {{capture 'i' by}} expected-note 6 {{default capture by}}
+    return [](auto b) { //expected-note 3{{begins here}} expected-note 6 {{capture 'i' by}} expected-note 6 {{default capture by}} expected-note {{while substituting into a lambda}}
       i = b;  //expected-error 3{{cannot be implicitly captured}}
       return b;
     };
   };
   auto M = L(3); //expected-note{{instantiation}}
   M(4.15); //expected-note{{instantiation}}
  }
  {

clang/test/SemaCXX/cxx1y-init-captures.cpp

auto M = [x = y,
                 &z = y](T& ... t) { }; 
     auto N = [x = y, 
                 &z = y, n = f(t...), 
                 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...), t...](T& ... s) { 
                   fv([&a(t)]()->decltype(auto) { 
                     return a;
                   }() ...);
                 };                 
-    auto N2 = [x = y, //expected-note3{{begins here}} expected-note 6 {{default capture by}}
+    auto N2 = [x = y, //expected-note3{{begins here}} expected-note 6 {{default capture by}} expected-note 2 {{substituting into a lambda}}
                 &z = y, n = f(t...), 
                 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) { // expected-note 6 {{capture 't' by}}
-                fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}}
+                fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}} expected-note 2{{substituting into a lambda}}
                     return a;
                   }() ...);
                 };                 
 
   }
 
-  void h(int i, char c) { g(i, c); } //expected-note{{in instantiation}}
+  void h(int i, char c) { g(i, c); } //expected-note 2{{in instantiation}}
 }
 
 namespace odr_use_within_init_capture {
 
 int test() {
   
   { // no captures
     const int x = 10;
int test(T t = T{}) {
     const T x = 10;
     auto L = [&z = x](T a) {
       return a;;
     };
         
   }
   { // will need to capture x in outer lambda
     const T x = 10; //expected-note {{declared}}
-    auto L = [z = x](char a) { //expected-note {{begins}} expected-note 2 {{capture 'x' by}} expected-note 2 {{default capture by}}
+    auto L = [z = x](char a) { //expected-note {{begins}} expected-note 2 {{capture 'x' by}} expected-note 2 {{default capture by}} expected-note {{substituting into a lambda}}
       auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}
         return y;
       };
       return M;
     };
   }
   { // will need to capture x in outer lambda
     const T x = 10; 
auto L = [x, z = x](char a) {
       auto M = [&y = x](T b) { 
         return y;
       };
       return M;
     };
   }
   { // will need to capture x in outer lambda
     const int x = 10; //expected-note {{declared}}
-    auto L = [z = x](char a) { //expected-note {{begins}} expected-note 2 {{capture 'x' by}} expected-note 2 {{default capture by}}
+    auto L = [z = x](char a) { //expected-note {{begins}} expected-note 2 {{capture 'x' by}} expected-note 2 {{default capture by}} expected-note {{substituting into a lambda}}
       auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}
         return y;
       };
       return M;
     };
   }
   {
     // no captures
     const T x = 10;
     auto L = [z = 
                   [z = x, &y = x](char a) { return z + y; }('a')](char a) 
       { return z; };
   
   }
   
   return 0;
 }
 
-int run = test(); //expected-note {{instantiation}}
+int run = test(); //expected-note 2 {{instantiation}}
 
 }
 
 namespace classification_of_captures_of_init_captures {
 
 template <typename T>
 void f() {
   [a = 24] () mutable {

clang/test/SemaCXX/cxx1z-lambda-star-this.cpp

class B {
   B(const B &) = delete; //expected-note2{{deleted here}}
 
   int *x = (int *)456;
 
 public:
   template <class T = int>
   void foo() {
     (void)[this] { return x; };
-    (void)[*this] { return x; }; //expected-error2{{call to deleted}}
+    (void)[*this] { return x; }; //expected-error2{{call to deleted}} expected-note {{while substituting into a lambda}}
   }
 
   B() = default;
 } b;
 B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
 } // namespace ns3
 
 namespace ns4 {
 template <class U>
 class B {
   B(const B &) = delete; //expected-note{{deleted here}}
   double d = 3.14;
 
 public:
   template <class T = int>
   auto foo() {
-    const auto &L = [*this](auto a) mutable { //expected-error{{call to deleted}}
+    const auto &L = [*this](auto a) mutable { //expected-error{{call to deleted}} expected-note {{while substituting into a lambda}}
       d += a;
       return [this](auto b) { return d += b; };
     };
   }
 
   B() = default;
 };
 void main() {

clang/test/SemaCXX/cxx20-decomposition.cpp

void GH57826() {
     (void)[&a](auto c) { return b + [&a](auto) { // expected-error 2{{variable 'b' cannot be implicitly captured}} \
                                                  // expected-note 2{{lambda expression begins here}} \
                                                  // expected-note 4{{capture 'b'}}
         return a;
     }(0); }(0); // expected-note {{in instantiation}}
     (void)[&b](auto c) { return b + [](auto) {   // expected-note 3{{lambda expression begins here}} \
                                                  // expected-note 6{{capture 'a'}} \
                                                  // expected-note 6{{default capture}} \
-                                                 // expected-note {{in instantiation}}
+                                                 // expected-note {{in instantiation}} \
+                                                 // expected-note {{while substituting into a lambda}}
         return a;  // expected-error 3{{variable 'a' cannot be implicitly captured}}
     }(0); }(0); // expected-note 2{{in instantiation}}
   }
 }

clang/test/SemaCXX/lambda-expressions.cpp

template<typename...Ts> void nested2(Ts ...ts) { // expected-note 2{{here}}
     //
     // FIXME: This diagnostic does not explain what's happening. We should
     // specify which 'ts' we're referring to in its diagnostic name. We should
     // also say which slice of the pack expansion is being performed in the
     // instantiation backtrace.
     f([&ts] { return (int)f(ts...); } ()...); // \
     // expected-error 2{{'ts' cannot be implicitly captured}} \
     // expected-note 2{{lambda expression begins here}} \
-    // expected-note 4 {{capture 'ts' by}}
+    // expected-note 4 {{capture 'ts' by}} \
+    // expected-note 2 {{while substituting into a lambda}}
   }
   template void nested2(int); // ok
-  template void nested2(int, int); // expected-note {{in instantiation of}}
+  template void nested2(int, int); // expected-note 2 {{in instantiation of}}
 }
 
 namespace PR13860 {
   void foo() {
     auto x = PR13860UndeclaredIdentifier(); // expected-error {{use of undeclared identifier 'PR13860UndeclaredIdentifier'}}
     auto y = [x]() { };
     static_assert(sizeof(y), "");
   }
struct S {
     int c = []{ int k = 0; return [=]{ return k; }(); }(); // ok
     int d = [] { return [=] { return n; }(); }();          // expected-error {{'this' cannot be implicitly captured in this context}} expected-note {{explicitly capture 'this'}}
   };
 }
 
 namespace PR18473 {
   template<typename T> void f() {
     T t(0);
-    (void) [=]{ int n = t; }; // expected-error {{deleted}}
+    (void) [=]{ int n = t; }; // expected-error {{deleted}} expected-note {{while substituting into a lambda}}
   }
 
   template void f<int>();
   struct NoCopy {
     NoCopy(int);
     NoCopy(const NoCopy &) = delete; // expected-note {{deleted}}
     operator int() const;
   };
namespace lambda_in_default_mem_init {
   template void g<int>();
 }
 
 namespace error_in_transform_prototype {
   template<class T>
   void f(T t) {
     // expected-error@+2 {{type 'int' cannot be used prior to '::' because it has no members}}
     // expected-error@+1 {{no member named 'ns' in 'error_in_transform_prototype::S'}}
-    auto x = [](typename T::ns::type &k) {};
+    auto x = [](typename T::ns::type &k) {}; // expected-note 2 {{while substituting into a lambda}}
   }
   class S {};
   void foo() {
     f(5); // expected-note {{requested here}}
     f(S()); // expected-note {{requested here}}
   }
 }
 

clang/test/SemaCXX/lambda-pack-expansion.cpp

 // RUN: %clang_cc1 -std=c++20 -Wno-unused-value -fsyntax-only -verify %s
 
 namespace GH49266 {
 struct X {
   X() = default;
   X(X const&) = delete; // expected-note {{'X' has been explicitly marked deleted here}}
 };
 
 void take_by_copy(auto &...args) {
   [...args = args] {}(); // expected-error {{call to deleted constructor}}
+                         // expected-note@-1 {{substituting into a lambda}}
 }
 
 void take_by_ref(auto &...args) {
   [&...args = args] {}(); // args is passed by reference and not copied.
 }
 
 void foo() {
   X x;
   take_by_copy(x); // expected-note {{in instantiation of function template specialization}}
   take_by_ref(x);
 }
 }

clang/test/SemaCXX/lambda-unevaluated.cpp

 using d = decltype(sizeof([] { return 0; }));
 
 template <auto T>
 int unique_test1();
 static_assert(&unique_test1<[](){}> != &unique_test1<[](){}>);
 
 template <class T>
 auto g(T) -> decltype([]() { T::invalid; } ());
-auto e = g(0); // expected-error{{no matching function for call}}
-// expected-note@-2 {{substitution failure}}
+auto e = g(0); // expected-error@-1{{type 'int' cannot be used prior to '::'}}
+               // expected-note@-1{{while substituting deduced template}}
+               // expected-note@-3{{while substituting into a lambda}}
+               // expected-error@-3 {{no matching function for call to 'g'}}
+               // expected-note@-5 {{substitution failure}}
 
 template <typename T>
 auto foo(decltype([] {
   return [] { return T(); }();
 })) {}
 
 void test() {
   foo<int>({});

 using c = decltype([]() static noexcept(noexcept([] { return 0; }())) { return 0; });
 using d = decltype(sizeof([] static { return 0; }));
 
 }
 
 namespace lambda_in_trailing_decltype {
 auto x = ([](auto) -> decltype([] {}()) {}(0), 2);
 }
+
+namespace lambda_in_constraints {
+struct WithFoo { static void foo(); };
+
+template <class T>
+concept lambda_works = requires {
+    []() { T::foo(); };
+};
+
+static_assert(!lambda_works<int>);
+static_assert(lambda_works<WithFoo>);
+
+template <class T>
+int* func(T) requires requires { []() { T::foo(); }; };
+double* func(...);
+
+static_assert(__is_same(decltype(func(0)), double*));
+static_assert(__is_same(decltype(func(WithFoo())), int*));
+
+template <class T>
+auto direct_lambda(T) -> decltype([] { T::foo(); }) {}
+void direct_lambda(...) {}
+
+void recursive() {
+    direct_lambda(0); // expected-error@-4 {{type 'int' cannot be used prior to '::'}}
+                      // expected-note@-1 {{while substituting deduced template arguments}}
+                      // expected-note@-6 {{while substituting into a lambda}}
+    bool x = requires { direct_lambda(0); }; // expected-error@-7 {{type 'int' cannot be used prior to '::'}}
+                                             // expected-note@-1 {{while substituting deduced template arguments}}
+                                             // expected-note@-9 {{while substituting into a lambda}}
+
+}
+}

clang/test/SemaCXX/vartemplate-lambda.cpp

 // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
 
 template <class> auto fn0 = [] {};
 template <typename> void foo0() { fn0<char>(); }
 
 template<typename T> auto fn1 = [](auto a) { return a + T(1); };
 template<typename T> auto v1 = [](int a = T()) { return a; }();
 // expected-error@-1{{cannot initialize a parameter of type 'int' with an rvalue of type 'int *'}}
 // expected-note@-2{{in instantiation of default function argument expression for 'operator()<int *>' required here}}
 // expected-note@-3{{passing argument to parameter 'a' here}}
+// expected-note@-4{{substituting into a lambda}}
 
 struct S {
   template<class T>
   static constexpr T t = [](int f = T(7)){return f;}(); // expected-error{{constexpr variable 't<int>' must be initialized by a constant expression}} expected-note{{cannot be used in a constant expression}}
 };
 
 template <typename X>
 int foo2() {

clang/test/SemaCXX/warn-unused-lambda-capture.cpp

void test_templated() {
 
   auto implicit_by_value = [=]() mutable { i++; };
   auto implicit_by_reference = [&] { i++; };
 
   auto explicit_by_value_used = [i] { return i + 1; };
   auto explicit_by_value_used_generic = [i](auto c) { return i + 1; };
   auto explicit_by_value_used_void = [i] { (void)i; };
 
-  auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}}
-  auto explicit_by_value_unused_sizeof = [i] { return sizeof(i); }; // expected-warning{{lambda capture 'i' is not required to be captured for this use}}
-  auto explicit_by_value_unused_decltype = [i] { decltype(i) j = 0; }; // expected-warning{{lambda capture 'i' is not used}}
-  auto explicit_by_value_unused_const = [k] { return k + 1; };         // expected-warning{{lambda capture 'k' is not required to be captured for this use}}
-  auto explicit_by_value_unused_const_generic = [k](auto c) { return k + 1; }; // expected-warning{{lambda capture 'k' is not required to be captured for this use}}
+  auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}} expected-note {{substituting into a lambda}}
+  auto explicit_by_value_unused_sizeof = [i] { return sizeof(i); }; // expected-warning{{lambda capture 'i' is not required to be captured for this use}} expected-note {{substituting into a lambda}}
+  auto explicit_by_value_unused_decltype = [i] { decltype(i) j = 0; }; // expected-warning{{lambda capture 'i' is not used}} expected-note {{substituting into a lambda}}
+  auto explicit_by_value_unused_const = [k] { return k + 1; };         // expected-warning{{lambda capture 'k' is not required to be captured for this use}} expected-note {{substituting into a lambda}}
+  auto explicit_by_value_unused_const_generic = [k](auto c) { return k + 1; }; // expected-warning{{lambda capture 'k' is not required to be captured for this use}} expected-note {{substituting into a lambda}}
 
   auto explicit_by_reference_used = [&i] { i++; };
-  auto explicit_by_reference_unused = [&i] {}; // expected-warning{{lambda capture 'i' is not used}}
+  auto explicit_by_reference_unused = [&i] {}; // expected-warning{{lambda capture 'i' is not used}} expected-note {{substituting into a lambda}}
 
   auto explicit_initialized_reference_used = [&j = i] { return j + 1; };
-  auto explicit_initialized_reference_unused = [&j = i]{}; // expected-warning{{lambda capture 'j' is not used}}
+  auto explicit_initialized_reference_unused = [&j = i]{}; // expected-warning{{lambda capture 'j' is not used}} expected-note {{substituting into a lambda}}
 
   auto explicit_initialized_value_used = [j = 1] { return j + 1; };
-  auto explicit_initialized_value_unused = [j = 1] {}; // expected-warning{{lambda capture 'j' is not used}}
+  auto explicit_initialized_value_unused = [j = 1] {}; // expected-warning{{lambda capture 'j' is not used}} expected-note {{substituting into a lambda}}
   auto explicit_initialized_value_non_trivial_constructor = [j = NonTrivialConstructor()]{};
   auto explicit_initialized_value_non_trivial_destructor = [j = NonTrivialDestructor()]{};
-  auto explicit_initialized_value_trivial_init = [j = Trivial()]{}; // expected-warning{{lambda capture 'j' is not used}}
+  auto explicit_initialized_value_trivial_init = [j = Trivial()]{}; // expected-warning{{lambda capture 'j' is not used}} expected-note {{substituting into a lambda}}
   auto explicit_initialized_value_non_trivial_init = [j = Trivial(42)]{};
   auto explicit_initialized_value_with_side_effect = [j = side_effect()]{};
   auto explicit_initialized_value_generic_used = [i = 1](auto c) mutable { i++; };
-  auto explicit_initialized_value_generic_unused = [i = 1](auto c) mutable {}; // expected-warning{{lambda capture 'i' is not used}}
+  auto explicit_initialized_value_generic_unused = [i = 1](auto c) mutable {}; // expected-warning{{lambda capture 'i' is not used}} expected-note {{substituting into a lambda}}
 
-  auto nested = [&i] {
+  auto nested = [&i] { // expected-note {{substituting into a lambda}}
     auto explicit_by_value_used = [i] { return i + 1; };
-    auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}}
+    auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}} expected-note {{substituting into a lambda}}
   };
 
   Trivial trivial;
-  auto explicit_by_value_trivial = [trivial] {}; // expected-warning{{lambda capture 'trivial' is not used}}
+  auto explicit_by_value_trivial = [trivial] {}; // expected-warning{{lambda capture 'trivial' is not used}} expected-note {{substituting into a lambda}}
 
   NonTrivialConstructor cons;
-  auto explicit_by_value_non_trivial_constructor = [cons] {}; // expected-warning{{lambda capture 'cons' is not used}}
+  auto explicit_by_value_non_trivial_constructor = [cons] {}; // expected-warning{{lambda capture 'cons' is not used}} expected-note {{substituting into a lambda}}
 
   NonTrivialCopyConstructor copy_cons;
   auto explicit_by_value_non_trivial_copy_constructor = [copy_cons] {};
 
   NonTrivialDestructor dest;
   auto explicit_by_value_non_trivial_destructor = [dest] {};
 
   volatile int v;
   auto explicit_by_value_volatile = [v] {};
 }
 
 void test_use_template() {
-  test_templated<int>(); // expected-note{{in instantiation of function template specialization 'test_templated<int>' requested here}}
+  test_templated<int>(); // expected-note 13{{in instantiation of function template specialization 'test_templated<int>' requested here}}
 }
 
 namespace pr35555 {
 int a;
 void b() {
   int c[a];
   auto vla_used = [&c] { return c[0]; };
   auto vla_unused = [&c] {}; // expected-warning{{lambda capture 'c' is not used}}
 }
 } // namespace pr35555

clang/test/SemaTemplate/concepts.cpp

void g3() {
     ([]<typename ...T>(C<T> auto){}(1), // expected-error {{type constraint contains unexpanded parameter pack 'T'}}
      ...); // expected-error {{does not contain any unexpanded}}
   }
 
   template<typename ...T> void g4() {
     []() -> C<T> auto{ return T(); }(); // expected-error {{expression contains unexpanded parameter pack 'T'}}
   }
   template<typename ...T> void g5() {
-    ([]() -> C<T> auto{ // expected-error-re {{deduced type {{.*}} does not satisfy}}
+    ([]() -> C<T> auto{ // expected-error-re {{deduced type {{.*}} does not satisfy}} expected-note {{while substituting into a lambda}}
      return T();
      }(), ...);
   }
   template void g5<int, int, int>(); // OK
   template void g5<int, char, double>(); // expected-note {{in instantiation of}}
   void g6() {
     ([]<typename ...T>() -> C<T> auto{ // expected-error {{declaration type contains unexpanded parameter pack 'T'}}
      return T(); // expected-error {{expression contains unexpanded parameter pack 'T'}}

clang/test/SemaTemplate/cxx1z-using-declaration.cpp

template<typename ...T> void fn2() {
   // This cannot ever be valid: in order for T::type to be a type, T must be a
   // class, and a class member cannot be named by a block-scope using declaration.
   using typename T::type ...; // expected-error {{class member}}
   type x; // expected-error {{unknown type name 'type'}}
 }
 
 // Test partial substitution into class-scope pack.
 template<typename ...T> auto lambda1() {
-  return [](auto x) {
+  return [](auto x) { // expected-note 1+{{substituting into a lambda}}
     struct A : T::template X<decltype(x)>... { // expected-note 1+{{instantiation of}}
       using T::template X<decltype(x)>::f ...;
       using typename T::template X<decltype(x)>::type ...;
       void g(int n) { f(n); } // expected-error {{empty pack}} expected-error {{expected 2, have 1}} expected-error {{ambiguous}}
       void h() { type value; } // expected-error {{empty pack}}
     };
     return A();
   };

clang/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp

template<bool ...B> void g(void (*...p)() noexcept (B)) {
     consume((p(),0)...);
     check<noexcept(p()) == B ...>();
   }
   template<typename ...T> void i() {
     consume([]() throw(T) {} ...);
     consume([]() noexcept(sizeof(T) == 4) {} ...);
   }
   template<bool ...B> void j() {
-    consume([](void (*p)() noexcept(B)) {
+    consume([](void (*p)() noexcept(B)) { // expected-note {{substituting into a lambda}}
       void (*q)() noexcept = p; // expected-error {{not superset of source}}
     } ...);
   }
 
   void z() {
     f<int, char, double>(nullptr, nullptr, nullptr);
     g<true, false, true>(nullptr, nullptr, nullptr);
     i<int, long, short>();

clang/test/SemaTemplate/instantiate-local-class.cpp

template <typename T> void foo() {
     };
     Inner()();
   }
   template void foo<A>(); // expected-note {{in instantiation}}
 
   template <typename T> void bar() {
     auto lambda = [](T a = "") {}; // expected-error {{conversion function from 'const char[1]' to 'rdar23721638::A' invokes a deleted function}} \
                                    // expected-note  {{in instantiation of default function argument expression for 'operator()<rdar23721638::A>' required here}} \
-                                   // expected-note  {{passing argument to parameter 'a' here}}
+                                   // expected-note  {{passing argument to parameter 'a' here}} \
+                                   // expected-note {{while substituting into a lambda}}
     lambda();
   }
   template void bar<A>(); // expected-note {{in instantiation}}
 }
 
 namespace anon_union_default_member_init {
   template<typename T> void f() {
     struct S {
       union {
         int i = 0;
       };
     };
   }
   void g() { f<int>(); }
 }
 
 namespace PR45000 {
   template <typename T>
   void f(int x = [](T x = nullptr) -> int { return x; }());
   // expected-error@-1 {{cannot initialize a parameter of type 'int' with an rvalue of type 'std::nullptr_t'}}
   // expected-note@-2  {{in instantiation of default function argument expression for 'operator()<int>' required here}}
   // expected-note@-3  {{passing argument to parameter 'x' here}}
+  // expected-note@-4  {{while substituting into a lambda}}
 
   void g() { f<int>(); }
   // expected-note@-1 {{in instantiation of default function argument expression for 'f<int>' required here}}
 }
 
 namespace LambdaInDefaultMemberInitializer {
   template<typename T> void f() {
     struct S {
       void *p = [this] { return &p; }();
     };
   }
   template void f<int>();
 }

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Default constructible and assignable stateless lambdas</td>
       <td><a href="https://wg21.link/p0624r2">P0624R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <tr>
       <td>Lambdas in unevaluated contexts</td>
       <td><a href="https://wg21.link/p0315r4">P0315R4</a></td>
-      <td class="partial" align="center">
-        <details><summary>Partial</summary>
-          temp.deduct/9 is not implemented yet.
-        </details>
-      </td>
+      <td class="full" align="center">Clang 17</td>
     </tr>
     <!-- Jacksonville papers -->
     <tr>
       <td><tt>[[no_unique_address]]</tt> attribute</td>
       <td><a href="https://wg21.link/p0840r2">P0840R2</a></td>
       <td class="full" align="center">Clang 9</td>
     </tr>
     <tr>