[clang] Error on substitution failure within lambda body inside a requires-expression

[Fznamznon]

Summary

Per CWG 2672 substitution failure within the body of a lambda inside a
requires-expression should be a hard error.

Fixes https://github.com/llvm/llvm-project/issues/64138

[cor3ntin]

Thanks for the PR!

Can you add a test in dr26xx ?

Also, i think the intent is that only the body is in the immediate context.

maybe we need a test like

requires {   
   decltype([] -> T {})::foo();
}

Because I think the intent is for that to work (@rsmith?)

clang/lib/Sema/SemaTemplateInstantiate.cpp

1100–1103

Can you also add
// CWG2672: A lambda-expression body is never in the immediate context ?

[cor3ntin]

Oups, I did not meant to accept that, sorry!

[Fznamznon]

Rebase, apply feedback

[Fznamznon]

Can you add a test in dr26xx ?

Sure, done. Hope I updated cxx_dr_status in the right way. The script wasn't happy until I added "open" to the test comment.

maybe we need a test like Because I think the intent is for that to work

Seems to be working if I got it right.

[cor3ntin]

LGTM, thanks!

clang/docs/ReleaseNotes.rst

- Fix a crash caused by some named unicode escape sequences designating
   (`Fixes #64161 <https://github.com/llvm/llvm-project/issues/64161>_`)
 
 - Fix cases where we ignore ambiguous name lookup when looking up memebers.
   (`#22413 <https://github.com/llvm/llvm-project/issues/22413>_`),
   (`#29942 <https://github.com/llvm/llvm-project/issues/29942>_`),
   (`#35574 <https://github.com/llvm/llvm-project/issues/35574>_`) and
   (`#27224 <https://github.com/llvm/llvm-project/issues/27224>_`).
 
+- Clang emits an error on substitution failure within lambda body inside a
+  requires-expression. This fixes:
+  (`#64138 <https://github.com/llvm/llvm-project/issues/64138>_`).
+
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed an import failure of recursive friend class template.
   `Issue 64169 <https://github.com/llvm/llvm-project/issues/64169>`_
 - Remove unnecessary RecordLayout computation when importing UnaryOperator. The
   computed RecordLayout is incorrect if fields are not completely imported and
   should not be cached.
   `Issue 64170 <https://github.com/llvm/llvm-project/issues/64170>`_

clang/lib/Sema/SemaTemplateInstantiate.cpp

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;
+      // CWG2672: A lambda-expression body is never in the immediate context.
+      return std::nullopt;
 
     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:
       // SFINAE always applies in a constraint expression or a requirement
       // in a requires expression.
       assert(Active->DeductionInfo && "Missing deduction info pointer");
       return Active->DeductionInfo;

clang/test/CXX/drs/dr26xx.cpp

 
 H h = { "abc" };
 I i = { "def" };
 static_assert(__is_same(decltype(h), H<char, 4>));  // Not H<const char, 4>
 static_assert(__is_same(decltype(i), I<char, 4>));
 
 J j = { "ghi" };  // expected-error {{no viable constructor or deduction guide}}
 }
+
+namespace dr2672 { // dr2672: 18 open
+template <class T>
+void f(T) requires requires { []() { T::invalid; } (); }; // expected-error{{type 'int' cannot be used prior to '::'}}
+                                                          // expected-note@-1{{while substituting into a lambda expression here}}
+                                                          // expected-note@-2{{in instantiation of requirement here}}
+                                                          // expected-note@-3{{while substituting template arguments into constraint expression here}}
+void f(...);
+
+template <class T>
+void bar(T) requires requires {
+   decltype([]() -> T {})::foo();
+};
+void bar(...);
+
+void m() {
+  f(0); // expected-note {{while checking constraint satisfaction for template 'f<int>' required here}}
+        // expected-note@-1 {{in instantiation of function template specialization}}
+  bar(0);
+}
+}

clang/test/SemaCXX/lambda-unevaluated.cpp

 auto x = ([](auto) -> decltype([] {}()) {}(0), 2);
 }
 
 namespace lambda_in_constraints {
 struct WithFoo { static void foo(); };
 
 template <class T>
 concept lambda_works = requires {
-    []() { T::foo(); };
+    []() { T::foo(); }; // expected-error{{type 'int' cannot be used prior to '::'}}
+                        // expected-note@-1{{while substituting into a lambda expression here}}
+                        // expected-note@-2{{in instantiation of requirement here}}
+                        // expected-note@-4{{while substituting template arguments into constraint expression here}}
 };
 
-static_assert(!lambda_works<int>);
+static_assert(!lambda_works<int>); // expected-note {{while checking the satisfaction of concept 'lambda_works<int>' requested here}}
 static_assert(lambda_works<WithFoo>);
 
 template <class T>
-int* func(T) requires requires { []() { T::foo(); }; };
+int* func(T) requires requires { []() { T::foo(); }; }; // expected-error{{type 'int' cannot be used prior to '::'}}
+                                                        // expected-note@-1{{while substituting into a lambda expression here}}
+                                                        // expected-note@-2{{in instantiation of requirement here}}
+                                                        // expected-note@-3{{while substituting template arguments into constraint expression here}}
 double* func(...);
 
-static_assert(__is_same(decltype(func(0)), double*));
+static_assert(__is_same(decltype(func(0)), double*)); // expected-note {{while checking constraint satisfaction for template 'func<int>' required here}}
+                                                      // expected-note@-1 {{in instantiation of function template specialization 'lambda_in_constraints::func<int>'}}
 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/www/cxx_dr_status.html

<tr class="open" id="2671">
     <td>open</td>
     <td>friend named by a <I>template-id</I></td>
     <td align="center">Not resolved</td>
   </tr>
   <tr class="open" id="2672">
     <td><a href="https://cplusplus.github.io/CWG/issues/2672.html">2672</a></td>
     <td>open</td>
     <td>Lambda body SFINAE is still required, contrary to intent and note</td>
-    <td align="center">Not resolved</td>
+    <td class="unreleased" align="center">Clang 18</td>
   </tr>
   <tr id="2673">
     <td><a href="https://cplusplus.github.io/CWG/issues/2673.html">2673</a></td>
     <td>DR</td>
     <td>User-declared spaceship vs. built-in operators</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2674">