[C++20] Determine the dependency of unevaluated lambdas more accurately

[lime]

Summary

During template instantiation, the instantiator will enter constant evaluated
context before instantiate a template argument originated from an expression,
and this impedes the instantiator from creating lambdas with independent types.

This patch solves the problem via widening the condition that the instantiator
marks lambdas as never dependent, and fixes the issue #57960

[shafik]

I am not sure if this is moving in the right direction or not, I will wait for @cor3ntin to chime in.

[cor3ntin]

@shafik I'm not sure either it's the right direction but I don't think it makes the situation any worse.
And given I still don't really know what a proper fix would look like (except that it would probably be pretty involved), I think we might has well do that as an improvement of the pre existing workaround.

@lime Can you add a release note indicating the issue has been fixed? Thanks!

[erichkeane]

I agree with Corentin here, I've got no idea what the RIGHT solution looks like here, but this looks to be at least an improvement. 1 nit, plus need a release note. Otherwise LGTM.

clang/test/CodeGenCXX/cxx20-unevaluated-lambda-crash.cpp

5

Nit: need a space after the name and before the {.

[lime]

Added release notes.

[lime]

Just rebased, and the check-profile target passed on my local machine.

[cor3ntin]

Thanks. I think this looks good!

[lime]

Could you please help to commit this? My name and email are Liming Liu <[e-mail]>

[erichkeane]

Done, though I think it is more than time for you to ask for commit permissions.

clang/docs/ReleaseNotes.rst

- Fix an issue that triggers a crash if we instantiate a hidden friend functions.
   This fixes `Issue 54457 <https://github.com/llvm/llvm-project/issues/54457>`_
 - Fix an issue where -frewrite-includes generated line control directives with
   incorrect line numbers in some cases when a header file used an end of line
   character sequence that differed from the primary source file.
   `Issue 59736 <https://github.com/llvm/llvm-project/issues/59736>`_
 - In C mode, when ``e1`` has ``__attribute__((noreturn))`` but ``e2`` doesn't,
   ``(c ? e1 : e2)`` is no longer considered noreturn.
   `Issue 59792 <https://github.com/llvm/llvm-project/issues/59792>`_
+- Fix an issue that makes Clang crash on lambda template parameters. This fixes
+  `Issue 57960 <https://github.com/llvm/llvm-project/issues/57960>`_
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Clang will now check compile-time determinable string literals as format strings.
   Fixes `Issue 55805: <https://github.com/llvm/llvm-project/issues/55805>`_.
 - ``-Wformat`` now recognizes ``%b`` for the ``printf``/``scanf`` family of
   functions and ``%B`` for the ``printf`` family of functions. Fixes
   `Issue 56885: <https://github.com/llvm/llvm-project/issues/56885>`_.

clang/include/clang/Sema/Sema.h

   /// Determines whether we are currently in a context that
   /// is not evaluated as per C++ [expr] p5.
   bool isUnevaluatedContext() const {
     assert(!ExprEvalContexts.empty() &&
            "Must be in an expression evaluation context");
     return ExprEvalContexts.back().isUnevaluated();
   }
 
+  bool isConstantEvaluatedContext() const {
+    assert(!ExprEvalContexts.empty() &&
+           "Must be in an expression evaluation context");
+    return ExprEvalContexts.back().isConstantEvaluated();
+  }
+
   bool isImmediateFunctionContext() const {
     assert(!ExprEvalContexts.empty() &&
            "Must be in an expression evaluation context");
     return ExprEvalContexts.back().isImmediateFunctionContext();
   }
 
   /// RAII class used to determine whether SFINAE has
   /// trapped any errors that occur during template argument

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
   }
 
   // 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.
+  // use evaluation contexts to distinguish the function parameter case.
   CXXRecordDecl::LambdaDependencyKind DependencyKind =
       CXXRecordDecl::LDK_Unknown;
-  if (getSema().isUnevaluatedContext() &&
+  if ((getSema().isUnevaluatedContext() ||
+       getSema().isConstantEvaluatedContext()) &&
       (getSema().CurContext->isFileContext() ||
        !getSema().CurContext->getParent()->isDependentContext()))
     DependencyKind = CXXRecordDecl::LDK_NeverDependent;
 
   CXXRecordDecl *OldClass = E->getLambdaClass();
   CXXRecordDecl *Class =
       getSema().createLambdaClosureType(E->getIntroducerRange(), NewCallOpTSI,
                                         DependencyKind, E->getCaptureDefault());

clang/test/CodeGenCXX/cxx20-unevaluated-lambda-crash.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK-LABEL: define linkonce_odr void @"_ZN10Issue579601EIiEENS_1FILNS_3$_0EEEEv"()
+namespace Issue57960 {
+template<auto>
+class F {};
+
+template<typename D>
+F<[]{}> E() {
+    return {};
+}
+
+static auto f = E<int>();
+}

clang/test/SemaCXX/lambda-unevaluated.cpp

 // OK, these are distinct functions not redefinitions.
 template<typename> void f(decltype([]{})) {} // expected-note {{candidate}}
 template<typename> void f(decltype([]{})) {} // expected-note {{candidate}}
 void use_f() { f<int>({}); } // expected-error {{ambiguous}}
 
 // Same.
 template<int N> void g(const char (*)[([]{ return N; })()]) {} // expected-note {{candidate}}
 template<int N> void g(const char (*)[([]{ return N; })()]) {} // expected-note {{candidate}}
-// FIXME: We instantiate the lambdas into the context of the function template,
-//  so we think they're dependent and can't evaluate a call to them.
-void use_g() { g<6>(&"hello"); } // expected-error {{no matching function}}
+void use_g() { g<6>(&"hello"); } // expected-error {{ambiguous}}
 }
 
 namespace GH51416 {
 
 template <class T>
 struct A {
   void spam(decltype([] {}));
 };