[clang][ExprConstant] Fix display of syntactically-invalid note for member function calls

[hazohelet]

Summary

This patch changes the display of member function calls in constexpr evaluator diagnostics from arrow operator to dot operator.
This avoids the syntactical invalidness in notes previously caused by the display of & operator
(lack of parentheses and reference of rvalue)

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

[erichkeane]

clang/test/SemaCXX/constant-expression-cxx11.cpp

994

So I think this is just trading 1 'wrong' for another. We should be looking to see if we can figure out whether this is called with an arrow or not. I don't have a good way of doing that unfortunately, but perhaps Aaron has an idea?

[hazohelet]

Thanks for the feedback.

clang/test/SemaCXX/constant-expression-cxx11.cpp

994

I believe there might be a slight misunderstanding.
The note generated for the sptr->f() will be sobj.f(), and not sptr.f(), so I think this patch does not introduce something wrong here.
Note: BEFORE this patch, invalid code &sobj->f() is generated for this line.
link: https://godbolt.org/z/vPWjdeqcK

That said, I think it would be ideal to distinguish sptr and sobj here, but I am unsure whether we can achieve it without incurring additional memory footprint.

[erichkeane]

clang/test/SemaCXX/constant-expression-cxx11.cpp

994

Ah, I see, less bad then I think. I'm on the fence here, this seems like it is still not great messaging. GCC manages to maintain the sptr here, which I wish we could do (though they have an odder way of printing it all the same: https://godbolt.org/z/Kn3Mn75rh).

I think I want to see what Aaron says when he gets back next week.

[tbaeder]

Can you show the output for an example where the -> notation is correct, e.h. https://godbolt.org/z/6a5oExjME ?

I suppose the patch doesn't change this much, but the current way that's displayed (&{*new Foo#0}->zomg()) is... questionable.

[hazohelet]

In D151720#4383098, @tbaeder wrote:

Can you show the output for an example where the -> notation is correct, e.h. https://godbolt.org/z/6a5oExjME ?

I suppose the patch doesn't change this much, but the current way that's displayed (&{*new Foo#0}->zomg()) is... questionable.

The output for that code becomes

source.cpp:20:12: note: in call to '{*new Foo#0}.zomg()'
        F->zomg();
           ^
source.cpp:28:17: note: in call to 's.heh()'
static_assert(s.heh());
                ^

, which I think is still not good.
But, at least (*new Foo).zomg() would be syntactically valid. I'll check the reason for the use of curly bracket and #number notations.

[hazohelet]

I think the proper message here can be obtained by letting the stack frame keep the syntactical structure of the function call, although it introduces additional memory footprint.

• Add const Expr * new field to CallStackFrame in order to save the syntactical structure of the member function call
• Generate proper message using that new field
• Fallback to the conventional value-based printing when handling destructors because it is not explicitly written by the user

[tbaeder]

clang/lib/AST/ExprConstant.cpp

1927–1949

1935

[hazohelet]

Address comments from @tbaeder

• Change dyn_cast_or_null to dyn_cast_if_present

[hazohelet]

clang/lib/AST/ExprConstant.cpp

1935

Thank you. I fixed them.

[tbaeder]

The only additional test I could come up with is one where the -> is in the middle of an lvalue designator, like:

struct A {
  constexpr int foo() { (void)(1/0); return 1;}
};

struct B {
  A aa;
  A *a = &aa;
};

struct C {
  B b;
};

struct D {
  C cc;
  C *c = &cc;
};

constexpr D d{};
static_assert(d.c->b.a->foo() == 1);

but this is printed correctly. The rest of the output LGTM but I'll wait for some of the others to maybe chime in.

clang/lib/AST/ExprConstant.cpp

1933

Did you clang-format these changes? The two if/else body here seems indented 4 spaces instead of 2.

clang/test/SemaCXX/constant-expression-cxx11.cpp

995

996

clang/test/SemaCXX/constexpr-frame-describe.cpp

6

12

[hazohelet]

Address comments from @tbaeder

• Add new suggested test case
• NFC stylistic changes in test cases

[hazohelet]

clang/lib/AST/ExprConstant.cpp

1933

Yes, I did run git clang-format before uploading. clang-format forces 4 spaces here even when I write 2 spaces.
Precommit CI's clang-format also seems to say nothing about the indentation here.
(Link: https://buildkite.com/llvm-project/premerge-checks/builds/155642#018875b6-df57-4c32-8f54-203e79d4a428)
So I think this might be an internal bug of clang-format.

[hazohelet]

@aaron.ballman I would like to hear what's your take on this approach.

[cjdb]

This patch seems like a win to me.

clang/docs/ReleaseNotes.rst

356

I like that we're referencing bugs in our release notes now :)

[shafik]

clang/lib/AST/ExprConstant.cpp

984–986

Let's fix the missing one while here.

1929

1936–1937

16312–16313

[hazohelet]

Address review comment NFC

• make some arguments conform to bugprone-argument-comments
• edit release note text

[hazohelet]

clang/lib/AST/ExprConstant.cpp

984–986

Thanks for all the fix.

clang/docs/ReleaseNotes.rst

 - Clang will now show a margin with line numbers to the left of each line
   of code it prints for diagnostics. This can be disabled using
   ``-fno-diagnostics-show-line-numbers``. At the same time, the maximum
   number of code lines it prints has been increased from 1 to 16. This
   can be controlled using ``-fcaret-diagnostics-max-lines=``.
 - Clang no longer emits ``-Wunused-variable`` warnings for variables declared
   with ``__attribute__((cleanup(...)))`` to match GCC's behavior.
 - Clang now issues expected warnings for situations of comparing with NULL pointers.
   (`#42992: <https://github.com/llvm/llvm-project/issues/42992>`_)
 - Clang now diagnoses unused const-qualified variable template as
   "unused variable template" rather than "unused variable".
 - When diagnosing a constant expression where an enum without a fixed underlying
   type is set to a value outside the range of the enum's values, clang will now
   print the name of the enum in question.
 - Clang no longer diagnoses a read of an empty structure as use of an
   uninitialized variable.
   (`#26842: <https://github.com/llvm/llvm-project/issues/26842>`_)
 - The Fix-It emitted for unused labels used to expand to the next line, which caused
   visual oddities now that Clang shows more than one line of code snippet. This has
   been fixed and the Fix-It now only spans to the end of the ``:``.
 - Clang now underlines the parameter list of function declaration when emitting
   a note about the mismatch in the number of arguments.
 - Clang now diagnoses unexpected tokens after a
   ``#pragma clang|GCC diagnostic push|pop`` directive.
   (`#13920: <https://github.com/llvm/llvm-project/issues/13920>`_)
 - Clang now does not try to analyze cast validity on variables with dependent alignment (`#63007: <https://github.com/llvm/llvm-project/issues/63007>`_).
+- Clang constexpr evaluator now displays member function calls more precisely
+  by making use of the syntactical structure of function calls. This avoids display
+  of syntactically invalid codes in diagnostics.
+  (`#57081: <https://github.com/llvm/llvm-project/issues/57081>`_)
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.

clang/lib/AST/ExprConstant.cpp

public:
     CallStackFrame *Caller;
 
     /// Callee - The function which was called.
     const FunctionDecl *Callee;
 
     /// This - The binding for the this pointer in this call, if any.
     const LValue *This;
 
+    /// CallExpr - The syntactical structure of member function calls
+    const Expr *CallExpr;
+
     /// Information on how to find the arguments to this call. Our arguments
     /// are stored in our parent's CallStackFrame, using the ParmVarDecl* as a
     /// key and this value as the version.
     CallRef Arguments;
 
     /// Source location information about the default argument or default
     /// initializer expression we're evaluating, if any.
     CurrentSourceLocExprScope CurSourceLocExprScope;
public:
 
     /// LambdaCaptureFields - Mapping from captured variables/this to
     /// corresponding data members in the closure class.
     llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
     FieldDecl *LambdaThisCaptureField;
 
     CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
                    const FunctionDecl *Callee, const LValue *This,
-                   CallRef Arguments);
+                   const Expr *CallExpr, CallRef Arguments);
     ~CallStackFrame();
 
     // Return the temporary for Key whose version number is Version.
     APValue *getTemporary(const void *Key, unsigned Version) {
       MapKeyTy KV(Key, Version);
       auto LB = Temporaries.lower_bound(KV);
       if (LB != Temporaries.end() && LB->first == KV)
         return &LB->second;
bool checkingForUndefinedBehavior() const override {
       return CheckingForUndefinedBehavior;
     }
 
     EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
         : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
           CallStackDepth(0), NextCallIndex(1),
           StepsLeft(C.getLangOpts().ConstexprStepLimit),
           EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
-          BottomFrame(*this, SourceLocation(), nullptr, nullptr, CallRef()),
+          BottomFrame(*this, SourceLocation(), /*Callee=*/nullptr,
+                      /*This=*/nullptr,
+                      /*CallExpr=*/nullptr, CallRef()),
           EvaluatingDecl((const ValueDecl *)nullptr),
           EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
           HasFoldFailureDiagnostic(false), EvalMode(Mode) {}
 
     ~EvalInfo() {
       discardCleanups();
     }
 
void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
   else
     Info.CCEDiag(E, diag::note_constexpr_array_index)
       << N << /*non-array*/ 1;
   setInvalid();
 }
 
 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
                                const FunctionDecl *Callee, const LValue *This,
-                               CallRef Call)
+                               const Expr *CallExpr, CallRef Call)
     : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
-      Arguments(Call), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
+      CallExpr(CallExpr), Arguments(Call), CallLoc(CallLoc),
+      Index(Info.NextCallIndex++) {
   Info.CurrentCall = this;
   ++Info.CallStackDepth;
 }
 
 CallStackFrame::~CallStackFrame() {
   assert(Info.CurrentCall == this && "calls retired out of order");
   --Info.CallStackDepth;
   Info.CurrentCall = Caller;
void CallStackFrame::describe(raw_ostream &Out) {
   bool IsMemberCall = isa<CXXMethodDecl>(Callee) &&
                       !isa<CXXConstructorDecl>(Callee) &&
                       cast<CXXMethodDecl>(Callee)->isInstance();
 
   if (!IsMemberCall)
     Out << *Callee << '(';
 
   if (This && IsMemberCall) {
+    if (const auto *MCE = dyn_cast_if_present<CXXMemberCallExpr>(CallExpr)) {
+      const Expr *Object = MCE->getImplicitObjectArgument();
+      Object->printPretty(Out, /*Helper=*/nullptr, Info.Ctx.getPrintingPolicy(),
+                          /*Indentation=*/0);
+      if (Object->getType()->isPointerType())
+          Out << "->";
+      else
+          Out << ".";
+    } else if (const auto *OCE =
+                   dyn_cast_if_present<CXXOperatorCallExpr>(CallExpr)) {
+      OCE->getArg(0)->printPretty(Out, /*Helper=*/nullptr,
+                                  Info.Ctx.getPrintingPolicy(),
+                                  /*Indentation=*/0);
+      Out << ".";
+    } else {
       APValue Val;
       This->moveInto(Val);
-    Val.printPretty(Out, Info.Ctx,
-                    This->Designator.MostDerivedType);
-    // FIXME: Add parens around Val if needed.
-    Out << "->" << *Callee << '(';
+      Val.printPretty(
+          Out, Info.Ctx,
+          Info.Ctx.getLValueReferenceType(This->Designator.MostDerivedType));
+      Out << ".";
+    }
+    Out << *Callee << '(';
     IsMemberCall = false;
   }
 
   for (FunctionDecl::param_const_iterator I = Callee->param_begin(),
        E = Callee->param_end(); I != E; ++I, ++ArgIndex) {
     if (ArgIndex > (unsigned)IsMemberCall)
       Out << ", ";
 
static bool handleTrivialCopy(EvalInfo &Info, const ParmVarDecl *Param,
   return handleLValueToRValueConversion(
       Info, E, Param->getType().getNonReferenceType(), RefLValue, Result,
       CopyObjectRepresentation);
 }
 
 /// Evaluate a function call.
 static bool HandleFunctionCall(SourceLocation CallLoc,
                                const FunctionDecl *Callee, const LValue *This,
-                               ArrayRef<const Expr *> Args, CallRef Call,
-                               const Stmt *Body, EvalInfo &Info,
+                               const Expr *E, ArrayRef<const Expr *> Args,
+                               CallRef Call, const Stmt *Body, EvalInfo &Info,
                                APValue &Result, const LValue *ResultSlot) {
   if (!Info.CheckCallLimit(CallLoc))
     return false;
 
-  CallStackFrame Frame(Info, CallLoc, Callee, This, Call);
+  CallStackFrame Frame(Info, CallLoc, Callee, This, E, Call);
 
   // For a trivial copy or move assignment, perform an APValue copy. This is
   // essential for unions, where the operations performed by the assignment
   // operator cannot be represented as statements.
   //
   // Skip this for non-union classes with no fields; in that case, the defaulted
   // copy/move does not actually read the object.
   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
if (RD->getNumVBases()) {
     Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
     return false;
   }
 
   EvalInfo::EvaluatingConstructorRAII EvalObj(
       Info,
       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
       RD->getNumBases());
-  CallStackFrame Frame(Info, CallLoc, Definition, &This, Call);
+  CallStackFrame Frame(Info, CallLoc, Definition, &This, E, Call);
 
   // FIXME: Creating an APValue just to hold a nonexistent return value is
   // wasteful.
   APValue RetVal;
   StmtResult Ret = {RetVal, nullptr};
 
   // If it's a delegating constructor, delegate.
   if (Definition->isDelegatingConstructor()) {
if (!Info.CheckCallLimit(CallLoc))
     return false;
 
   const FunctionDecl *Definition = nullptr;
   const Stmt *Body = DD->getBody(Definition);
 
   if (!CheckConstexprFunction(Info, CallLoc, DD, Definition, Body))
     return false;
 
-  CallStackFrame Frame(Info, CallLoc, Definition, &This, CallRef());
+  CallStackFrame Frame(Info, CallLoc, Definition, &This, /*CallExpr=*/nullptr,
+                       CallRef());
 
   // We're now in the period of destruction of this object.
   unsigned BasesLeft = RD->getNumBases();
   EvalInfo::EvaluatingDestructorRAII EvalObj(
       Info,
       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries});
   if (!EvalObj.DidInsert) {
     // C++2a [class.dtor]p19:
if (auto *DD = dyn_cast<CXXDestructorDecl>(FD)) {
                                Info.Ctx.getRecordType(DD->getParent())) &&
              CallScope.destroy();
     }
 
     const FunctionDecl *Definition = nullptr;
     Stmt *Body = FD->getBody(Definition);
 
     if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) ||
-        !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Call,
+        !HandleFunctionCall(E->getExprLoc(), Definition, This, E, Args, Call,
                             Body, Info, Result, ResultSlot))
       return false;
 
     if (!CovariantAdjustmentPath.empty() &&
         !HandleCovariantReturnAdjustment(Info, E, Result,
                                          CovariantAdjustmentPath))
       return false;
 
#endif
   }
 
   // Parameter cleanups happen in the caller and are not part of this
   // evaluation.
   Info.discardCleanups();
   Info.EvalStatus.HasSideEffects = false;
 
   // Build fake call to Callee.
-  CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr, Call);
+  CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr, This,
+                       Call);
   // FIXME: Missing ExprWithCleanups in enable_if conditions?
   FullExpressionRAII Scope(Info);
   return Evaluate(Value, Info, this) && Scope.destroy() &&
          !Info.EvalStatus.HasSideEffects;
 }
 
 bool Expr::isPotentialConstantExpr(const FunctionDecl *FD,
                                    SmallVectorImpl<
bool Expr::isPotentialConstantExpr(const FunctionDecl *FD,
   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
     // Evaluate the call as a constant initializer, to allow the construction
     // of objects of non-literal types.
     Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
     HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch);
   } else {
     SourceLocation Loc = FD->getLocation();
     HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : nullptr,
-                       Args, CallRef(), FD->getBody(), Info, Scratch, nullptr);
+                       &VIE, Args, CallRef(), FD->getBody(), Info, Scratch,
+                       /*ResultSlot=*/nullptr);
   }
 
   return Diags.empty();
 }
 
 bool Expr::isPotentialConstantExprUnevaluated(Expr *E,
                                               const FunctionDecl *FD,
                                               SmallVectorImpl<
                                                 PartialDiagnosticAt> &Diags) {
   assert(!E->isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
   Expr::EvalStatus Status;
   Status.Diag = &Diags;
 
   EvalInfo Info(FD->getASTContext(), Status,
                 EvalInfo::EM_ConstantExpressionUnevaluated);
   Info.InConstantContext = true;
   Info.CheckingPotentialConstantExpression = true;
 
   // Fabricate a call stack frame to give the arguments a plausible cover story.
-  CallStackFrame Frame(Info, SourceLocation(), FD, /*This*/ nullptr, CallRef());
+  CallStackFrame Frame(Info, SourceLocation(), FD, /*This=*/nullptr,
+                       /*CallExpr=*/nullptr, CallRef());
 
   APValue ResultScratch;
   Evaluate(ResultScratch, Info, E);
   return Diags.empty();
 }
 
 bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
                                  unsigned Type) const {

clang/test/AST/Interp/constexpr-nqueens.cpp

 constexpr Board buildBoardScan(int N, int Col, int Row, const Board &B);
 constexpr Board tryBoard(const Board &Try,
                          int N, int Col, int Row, const Board &B) {
   return Try.Failed ? buildBoardScan(N, Col, Row, B) : Try;
 }
 constexpr Board buildBoardScan(int N, int Col, int Row, const Board &B) {
   return Row == N ? Board(0, true) :
          B.ok(Row, Col) ?
-         tryBoard(buildBoardRecurse(N, Col + 1, B.addQueen(Row, Col)), // ref-note {{in call to '&Board()->addQueen(0, 0)}} \
+         tryBoard(buildBoardRecurse(N, Col + 1, B.addQueen(Row, Col)), // ref-note {{in call to 'B.addQueen(0, 0)}} \
                                                                        // expected-note {{in call to '&Board()->addQueen(0, 0)}}
                   N, Col, Row+1, B) :
          buildBoardScan(N, Col, Row + 1, B);
 }
 constexpr Board buildBoardRecurse(int N, int Col, const Board &B) {
   return Col == N ? B : buildBoardScan(N, Col, 0, B); // ref-note {{in call to 'buildBoardScan(8, 0, 0, Board())'}} \
                                                       // expected-note {{in call to 'buildBoardScan(8, 0, 0, Board())'}}
 

clang/test/AST/Interp/lambda.cpp

 
 constexpr int div(int a, int b) {
   auto f = [=]() {
     return a / b; // expected-note {{division by zero}} \
                   // ref-note {{division by zero}}
   };
 
   return f(); // expected-note {{in call to '&f->operator()()'}} \
-              // ref-note {{in call to '&f->operator()()'}}
+              // ref-note {{in call to 'f.operator()()'}}
 }
 static_assert(div(8, 2) == 4);
 static_assert(div(8, 0) == 4); // expected-error {{not an integral constant expression}} \
                                // expected-note {{in call to 'div(8, 0)'}} \
                                // ref-error {{not an integral constant expression}} \
                                // ref-note {{in call to 'div(8, 0)'}}
 
 

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p9.cpp

 constexpr pixel origin;              // expected-error {{default initialization of an object of const type 'const pixel' without a user-provided default constructor}}
 
 #if __cplusplus > 201702L
 // A constexpr variable shall have constant destruction.
 struct A {
   bool ok;
   constexpr A(bool ok) : ok(ok) {}
   constexpr ~A() noexcept(false) {
-    void oops(); // expected-note 2{{declared here}}
-    if (!ok) oops(); // expected-note 2{{non-constexpr function}}
+    void oops(); // expected-note 6{{declared here}}
+    if (!ok) oops(); // expected-note 6{{non-constexpr function}}
   }
 };
 
+struct B {
+  A a[2];
+  constexpr B(bool ok) : a{A(!ok), A(ok)}{}
+};
+
+struct Cons {
+  bool val[2];
+  constexpr Cons() : val{true, false} {}
+};
+
 constexpr A const_dtor(true);
+static_assert(B(false).a[1].ok); // expected-error {{static assertion expression is not an integral constant expression}} \
+                                    expected-note {{in call to 'B(false).a[1].~A()'}} expected-note {{in call to 'B(false).~B()'}}
+static_assert(B(true).a[1].ok); // expected-error {{static assertion expression is not an integral constant expression}} \
+                                   expected-note {{in call to 'B(true).a[0].~A()'}} expected-note {{in call to 'B(true).~B()'}}
+static_assert(B(Cons().val[1]).a[1].ok); // expected-error {{static assertion expression is not an integral constant expression}} \
+                                            expected-note {{in call to 'B(Cons().val[1]).a[1].~A()'}} expected-note {{in call to 'B(Cons().val[1]).~B()'}}
+static_assert(B((new Cons)->val[0]).a[1].ok); // expected-error {{static assertion expression is not an integral constant expression}} \
+                                                 expected-note {{in call to 'B((new Cons)->val[0]).a[0].~A()'}} expected-note {{in call to 'B((new Cons)->val[0]).~B()'}}
 constexpr A non_const_dtor(false); // expected-error {{must have constant destruction}} expected-note {{in call}}
-constexpr A arr_dtor[5] = {true, true, true, false, true}; // expected-error {{must have constant destruction}} expected-note {{in call to '&arr_dtor[3]->~A()'}}
+constexpr A arr_dtor[5] = {true, true, true, false, true}; // expected-error {{must have constant destruction}} expected-note {{in call to 'arr_dtor[3].~A()'}}
 #endif

clang/test/CXX/temp/temp.param/p8-cxx20.cpp

void i() {
     // Ensure we don't cache an invalid template argument after we've already
     // seen it in a SFINAE context.
     f<D{1, false}>(); // expected-error {{no matching function}}
     f<D{1, true}>();
   }
 
   template<D d> struct Z {};
   Z<D{2, true}> z1;
-  Z<D{2, false}> z2; // expected-error {{non-type template argument is not a constant expression}} expected-note-re {{in call to '{{.*}}->~D()'}}
+  Z<D{2, false}> z2; // expected-error {{non-type template argument is not a constant expression}} expected-note-re {{in call to '{{.*}}.~D()'}}
 }

clang/test/SemaCXX/constant-expression-cxx11.cpp

struct S {
   constexpr int f() const;
   constexpr int g() const;
 };
 struct T : S {
   constexpr T(int n) : S(), n(n) {}
   int n;
 };
 constexpr int S::f() const {
-  return static_cast<const T*>(this)->n; // expected-note {{cannot cast}}
+  return static_cast<const T*>(this)->n; // expected-note 5{{cannot cast}}
 }
 constexpr int S::g() const {
   // FIXME: Better diagnostic for this.
   return this->*(int(S::*))&T::n; // expected-note {{subexpression}}
 }
 // The T temporary is implicitly cast to an S subobject, but we can recover the
 // T full-object via a base-to-derived cast, or a derived-to-base-casted member
 // pointer.
-static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to '&S()->f()'}}
-static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to '&S()->g()'}}
+static_assert(S().f(), ""); // expected-error {{constant expression}} expected-note {{in call to 'S().f()'}}
+static_assert(S().g(), ""); // expected-error {{constant expression}} expected-note {{in call to 'S().g()'}}
+constexpr S sobj;
+constexpr const S& slref = sobj;
+constexpr const S&& srref = S();
+constexpr const S *sptr = &sobj;
+static_assert(sobj.f(), ""); // expected-error {{constant expression}} \
+                                expected-note {{in call to 'sobj.f()'}}
+static_assert(sptr->f(), ""); // expected-error {{constant expression}} \
+                                 expected-note {{in call to 'sptr->f()'}}
+static_assert(slref.f(), ""); // expected-error {{constant expression}} \
+                                 expected-note {{in call to 'slref.f()'}}
+static_assert(srref.f(), ""); // expected-error {{constant expression}} \
+                                 expected-note {{in call to 'srref.f()'}}
 static_assert(T(3).f() == 3, "");
 static_assert(T(4).g() == 4, "");
 
 constexpr int f(const S &s) {
   return static_cast<const T&>(s).n;
 }
 constexpr int n = f(T(5));
 static_assert(f(T(5)) == 5, "");

clang/test/SemaCXX/constexpr-frame-describe.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+
+
+struct Foo {
+    constexpr void zomg() const { (void)(1 / 0); } // expected-error {{constant expression}} \
+                                                      expected-warning {{division by zero}} \
+                                                      expected-note 2{{division by zero}}
+};
+
+struct S {
+    constexpr S() {}
+    constexpr bool operator==(const S&) const { // expected-error {{never produces a constant expression}}
+      return 1 / 0; // expected-warning {{division by zero}} \
+                       expected-note 3{{division by zero}}
+    }
+
+    constexpr bool heh() const {
+        auto F = new Foo();
+        F->zomg(); // expected-note {{in call to 'F->zomg()'}}
+        delete F;
+        return false;
+    }
+};
+
+constexpr S s;
+
+static_assert(s.heh()); // expected-error {{constant expression}} \
+                           expected-note {{in call to 's.heh()'}}
+
+constexpr S s2;
+constexpr const S *sptr = &s;
+constexpr const S *sptr2 = &s2;
+static_assert(s == s2); // expected-error {{constant expression}} \
+                           expected-note {{in call to 's.operator==(s2)'}}
+static_assert(*sptr == *sptr2); // expected-error {{constant expression}} \
+                                   expected-note {{in call to '*sptr.operator==(s2)'}}
+
+struct A {
+  constexpr int foo() { (void)(1/0); return 1;} // expected-error {{never produces a constant expression}} \
+                                                   expected-warning {{division by zero}} \
+                                                   expected-note 2{{division by zero}}
+};
+
+struct B {
+  A aa;
+  A *a = &aa;
+};
+
+struct C {
+  B b;
+};
+
+struct D {
+  C cc;
+  C *c = &cc;
+};
+
+constexpr D d{};
+static_assert(d.c->b.a->foo() == 1); // expected-error {{constant expression}} \
+                                        expected-note {{in call to 'd.c->b.a->foo()'}}

clang/test/SemaCXX/cxx2a-consteval.cpp

 void func() {
   default_ctor<foo> fail0; // expected-error {{call to consteval function 'defaulted_special_member_template::default_ctor<defaulted_special_member_template::foo>::default_ctor' is not a constant expression}} \
                               expected-note {{in call to 'default_ctor()'}}
 
   copy<foo> good0;
   copy<foo> fail1{good0}; // expected-error {{call to consteval function 'defaulted_special_member_template::copy<defaulted_special_member_template::foo>::copy' is not a constant expression}} \
                              expected-note {{in call to 'copy(good0)'}}
   fail1 = good0;          // expected-error {{call to consteval function 'defaulted_special_member_template::copy<defaulted_special_member_template::foo>::operator=' is not a constant expression}} \
-                             expected-note {{in call to '&fail1->operator=(good0)'}}
+                             expected-note {{in call to 'fail1.operator=(good0)'}}
 
   move<foo> good1;
   move<foo> fail2{static_cast<move<foo>&&>(good1)}; // expected-error {{call to consteval function 'defaulted_special_member_template::move<defaulted_special_member_template::foo>::move' is not a constant expression}} \
                                                        expected-note {{in call to 'move(good1)'}}
   fail2 = static_cast<move<foo>&&>(good1);          // expected-error {{call to consteval function 'defaulted_special_member_template::move<defaulted_special_member_template::foo>::operator=' is not a constant expression}} \
-                                                       expected-note {{in call to '&fail2->operator=(good1)'}}
+                                                       expected-note {{in call to 'fail2.operator=(good1)'}}
 }
 } // namespace defaulted_special_member_template
 
 namespace multiple_default_constructors {
 struct Foo {
   Foo() {} // expected-note {{declared here}}
 };
 struct Bar {

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

 
 namespace Constexpr {
   constexpr auto f1(int n) { return n; }
   template<typename T> struct X { constexpr auto f() {} }; // PR18746
   template<typename T> struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}}
   void f() {
     X<int>().f();
     Y<void>().f();
-    constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y<int>()->f()'}}
+    constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'Y<int>().f()'}}
   }
   struct NonLiteral { ~NonLiteral(); } nl; // cxx14-note {{user-provided destructor}}
   // cxx20_23-note@-1 {{'NonLiteral' is not literal because its destructor is not constexpr}}
   constexpr auto f2(int n) { return nl; } // expected-error {{return type 'struct NonLiteral' is not a literal type}}
 }
 
 // It's not really clear whether these are valid, but this matches g++.
 using size_t = decltype(sizeof(0));