Do not evaluate dependent immediate invocations

[usaxena95]

Summary

We deferred the evaluation of dependent immediate invocations in https://reviews.llvm.org/D119375 until instantiation.
We should also not consider them referenced from a non-consteval context.

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

template<typename T>
class Bar {
  consteval static T x() { return 5; }
 public:
  Bar() : a(x()) {}

 private:
  int a;
};

Bar<int> g();

Is now accepted by clang. Previously it errored with: cannot take address of consteval function 'x' outside of an immediate invocation Bar() : a(x()) {}

[aaron.ballman]

Thank you, this LGTM, though I did have a testing question. Also, please be sure to add a release note for the fix.

clang/test/SemaCXX/cxx2a-consteval.cpp

664

Do you think it's worth it to add a test case like:

struct derp {
  derp(int); // Can't be used in a constant expression

  consteval operator int() const { return 5; }
};

Bar<derp> d; // Error

to demonstrate that we evaluated properly at instantiation time, or do you think existing coverage already demonstrates this well enough?

[usaxena95]

Addressed comments.

[usaxena95]

Addressed comments. Added release note.

clang/test/SemaCXX/cxx2a-consteval.cpp

664

Added the test.

[ilya-biryukov]

A few NITS for the release notes, otherwise LG

clang/docs/ReleaseNotes.rst

162

NIT: a small nit

163

NIT: to align with release notes above

[usaxena95]

Updated release notes.

clang/docs/ReleaseNotes.rst

- Support capturing structured bindings in lambdas
   This fixes issues `GH52720 <https://github.com/llvm/llvm-project/issues/52720>`_,
   `GH54300 <https://github.com/llvm/llvm-project/issues/54300>`_,
   `GH54301 <https://github.com/llvm/llvm-project/issues/54301>`_,
   and `GH49430 <https://github.com/llvm/llvm-project/issues/49430>`_.
 - Consider explicitly defaulted constexpr/consteval special member function
   template instantiation to be constexpr/consteval even though a call to such
   a function cannot appear in a constant expression.
   (C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358))
+- Correctly defer dependent immediate function invocations until template instantiation.
+  This fixes `GH55601 <https://github.com/llvm/llvm-project/issues/55601>`_.
 
 
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 CUDA/HIP Language Changes in Clang
 ----------------------------------

clang/lib/Sema/SemaExpr.cpp

void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) {
   bool OdrUse = true;
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
     if (Method->isVirtual() &&
         !Method->getDevirtualizedMethod(Base, getLangOpts().AppleKext))
       OdrUse = false;
 
   if (auto *FD = dyn_cast<FunctionDecl>(E->getDecl()))
     if (!isUnevaluatedContext() && !isConstantEvaluated() &&
-        FD->isConsteval() && !RebuildingImmediateInvocation)
+        FD->isConsteval() && !RebuildingImmediateInvocation &&
+        !FD->isDependentContext())
       ExprEvalContexts.back().ReferenceToConsteval.insert(E);
   MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse,
                      RefsMinusAssignments);
 }
 
 /// Perform reference-marking and odr-use handling for a MemberExpr.
 void Sema::MarkMemberReferenced(MemberExpr *E) {
   // C++11 [basic.def.odr]p2:

clang/test/SemaCXX/cxx2a-consteval.cpp

template <typename T> constexpr int baz() {
   // Previously this call was rejected as `t` is value-dependent and its value
   // is unknown until the function is instantiated. Now we show that we don't
   // reject such calls.
   return foo(t);
 }
 
 static_assert(bar<15>() == 15);
 static_assert(baz<int>() == sizeof(int));
-
 } // namespace value_dependent
 
+// https://github.com/llvm/llvm-project/issues/55601
+namespace issue_55601 {
+template<typename T>
+class Bar {
+  consteval static T x() { return 5; }  // expected-note {{non-constexpr constructor 'derp' cannot be used in a constant expression}}
+ public:
+  Bar() : a(x()) {} // expected-error {{call to consteval function 'issue_55601::Bar<issue_55601::derp>::x' is not a constant expression}}
+                    // expected-error@-1 {{call to consteval function 'issue_55601::derp::operator int' is not a constant expression}}
+                    // expected-note@-2 {{in call to 'x()'}}
+                    // expected-note@-3 {{non-literal type 'issue_55601::derp' cannot be used in a constant expression}}
+ private:
+  int a;
+};
+Bar<int> f;
+Bar<float> g;
+
+struct derp {
+  // Can't be used in a constant expression
+  derp(int); // expected-note {{declared here}}
+  consteval operator int() const { return 5; }
+};
+Bar<derp> a; // expected-note {{in instantiation of member function 'issue_55601::Bar<issue_55601::derp>::Bar' requested here}}
+
+struct constantDerp {
+  // Can be used in a constant expression.
+  consteval constantDerp(int) {} 
+  consteval operator int() const { return 5; }
+};
+Bar<constantDerp> b;
+
+} // namespace issue_55601
+
 namespace default_argument {
 
 // Previously calls of consteval functions in default arguments were rejected.
 // Now we show that we don't reject such calls.
 consteval int foo() { return 1; }
 consteval int bar(int i = foo()) { return i * i; }
 
 struct Test1 {