[clang][ExprConstant] Print template arguments when describing stack frame

[hazohelet]

Summary

This patch adds additional printing of template argument list when the described function is a template specialization.
This can be useful when handling complex template functions in constexpr evaluator.

[cjdb]

Generally in favour of this, but I wonder if we ought to have a way of suppressing it when the specialisation is known and ends up being a gargantuan name (this is a discussion, not an action item). cc @dblaikie

[dblaikie]

Do we not already have some function name printing helper we could be reusing that might have some smarts about not printing deduced template arguments, using preferred names, whatever else?

[hazohelet]

FunctionDecll::getNameForDiagnostic yields almost the same result and I should use it here.
This function internal avoids printing template args that match the defaults, but it doesn't seem to have other techniques to reduce the size of printing.
Link: https://github.com/llvm/llvm-project/blob/03125e6894f82f9aa6f4e8d8036d0c833dd7d761/clang/lib/AST/TypePrinter.cpp#L2163-L2229

BTW, Line2171-2173 in the link seems to be dead code.

[hazohelet]

Uses FunctionDecl::getNameForDiagnostic

[tbaeder]

LGTM from my side, does anyone else still have a problem?

[dblaikie]

Sounds good to me

[shafik]

I think this looks fine, I just wonder if we should be adding more tests to make sure we cover the a fuller set of types and non-type template parameters. I feel like this is always what bites us when bugs come up, if we had just test more carefully we would have caught the problem earlier.

[cjdb]

If there aren't any concerns from others, then LGTM!

[dblaikie]

@hazohelet can you commit this yourself, or do you need someone to commit it on your behalf? (& if so, what name/email address would you like to be credited)

[hazohelet]

In D154366#4530536, @dblaikie wrote:

@hazohelet can you commit this yourself, or do you need someone to commit it on your behalf? (& if so, what name/email address would you like to be credited)

Thanks for the review.
I have commit access now, so I'll land this myself.
I'll add some missing tests on method function templates before landing this.

[hazohelet]

Added missing tests for method function templates before landing this

clang/docs/ReleaseNotes.rst

 Removed Compiler Flags
 -------------------------
 
 Attribute Changes in Clang
 --------------------------
 
 Improvements to Clang's diagnostics
 -----------------------------------
+- Clang constexpr evaluator now prints template arguments when displaying
+  template-specialization function calls.
 
 Bug Fixes in This Version
 -------------------------
 - Fixed an issue where a class template specialization whose declaration is
   instantiated in one module and whose definition is instantiated in another
   module may end up with members associated with the wrong declaration of the
   class, which can result in miscompiles in some cases.
 

clang/lib/AST/ExprConstant.cpp

 /// Produce a string describing the given constexpr call.
 void CallStackFrame::describe(raw_ostream &Out) const {
   unsigned ArgIndex = 0;
   bool IsMemberCall = isa<CXXMethodDecl>(Callee) &&
                       !isa<CXXConstructorDecl>(Callee) &&
                       cast<CXXMethodDecl>(Callee)->isInstance();
 
   if (!IsMemberCall)
-    Out << *Callee << '(';
+    Callee->getNameForDiagnostic(Out, Info.Ctx.getPrintingPolicy(),
+                                 /*Qualified=*/false);
 
   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,
           Info.Ctx.getLValueReferenceType(This->Designator.MostDerivedType));
       Out << ".";
     }
-    Out << *Callee << '(';
+    Callee->getNameForDiagnostic(Out, Info.Ctx.getPrintingPolicy(),
+                                 /*Qualified=*/false);
     IsMemberCall = false;
   }
 
+  Out << '(';
+
   for (FunctionDecl::param_const_iterator I = Callee->param_begin(),
        E = Callee->param_end(); I != E; ++I, ++ArgIndex) {
     if (ArgIndex > (unsigned)IsMemberCall)
       Out << ", ";
 
     const ParmVarDecl *Param = *I;
     APValue *V = Info.getParamSlot(Arguments, Param);
     if (V)

clang/test/AST/Interp/literals.cpp

if constexpr (Inc)
       ++a; // ref-note 2{{increment of uninitialized}} \
            // expected-note 2{{increment of uninitialized}}
     else
       --a; // ref-note 2{{decrement of uninitialized}} \
            // expected-note 2{{decrement of uninitialized}}
     return 1;
   }
   static_assert(uninit<int, true>(), ""); // ref-error {{not an integral constant expression}} \
-                                          // ref-note {{in call to 'uninit()'}} \
+                                          // ref-note {{in call to 'uninit<int, true>()'}} \
                                           // expected-error {{not an integral constant expression}} \
                                           // expected-note {{in call to 'uninit()'}}
 
   static_assert(uninit<int, false>(), ""); // ref-error {{not an integral constant expression}} \
-                                           // ref-note {{in call to 'uninit()'}} \
+                                           // ref-note {{in call to 'uninit<int, false>()'}} \
                                            // expected-error {{not an integral constant expression}} \
                                            // expected-note {{in call to 'uninit()'}}
 
   static_assert(uninit<float, true>(), ""); // ref-error {{not an integral constant expression}} \
-                                            // ref-note {{in call to 'uninit()'}} \
+                                            // ref-note {{in call to 'uninit<float, true>()'}} \
                                             // expected-error {{not an integral constant expression}} \
                                             // expected-note {{in call to 'uninit()'}}
 
   static_assert(uninit<float, false>(), ""); // ref-error {{not an integral constant expression}} \
-                                             // ref-note {{in call to 'uninit()'}} \
+                                             // ref-note {{in call to 'uninit<float, false>()'}} \
                                              // expected-error {{not an integral constant expression}} \
                                              // expected-note {{in call to 'uninit()'}}
 
   constexpr int OverFlow() { // ref-error {{never produces a constant expression}} \
                              // expected-error {{never produces a constant expression}}
     int a = INT_MAX;
     ++a; // ref-note 2{{is outside the range}} \
          // expected-note 2{{is outside the range}}

clang/test/SemaCXX/builtin-align-cxx.cpp

 static_assert(!a3, "");
 static_assert(wrap_align_down(wrap_align_up(22, 16), 32) == 32, "");
 static_assert(wrap_is_aligned(wrap_align_down(wrap_align_up(22, 16), 32), 32), "");
 static_assert(!wrap_is_aligned(wrap_align_down(wrap_align_up(22, 16), 32), 64), "");
 
 constexpr long const_value(long l) { return l; }
 // Check some invalid values during constant-evaluation
 static_assert(wrap_align_down(1, const_value(-1)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_align_down(1, -1)'}}
+// expected-note@-1{{in call to 'wrap_align_down<int>(1, -1)'}}
 static_assert(wrap_align_up(1, const_value(-2)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_align_up(1, -2)'}}
+// expected-note@-1{{in call to 'wrap_align_up<int>(1, -2)'}}
 static_assert(wrap_is_aligned(1, const_value(-3)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_is_aligned(1, -3)'}}
+// expected-note@-1{{in call to 'wrap_is_aligned<int>(1, -3)'}}
 static_assert(wrap_align_down(1, const_value(17)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_align_down(1, 17)'}}
+// expected-note@-1{{in call to 'wrap_align_down<int>(1, 17)'}}
 static_assert(wrap_align_up(1, const_value(18)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_align_up(1, 18)'}}
+// expected-note@-1{{in call to 'wrap_align_up<int>(1, 18)'}}
 static_assert(wrap_is_aligned(1, const_value(19)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_is_aligned(1, 19)'}}
+// expected-note@-1{{in call to 'wrap_is_aligned<int>(1, 19)'}}
 
 // Check invalid values for smaller types:
 static_assert(wrap_align_down(static_cast<short>(1), const_value(1 << 20)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_align_down(1, 1048576)'}}
+// expected-note@-1{{in call to 'wrap_align_down<short>(1, 1048576)'}}
 // Check invalid boolean type
 static_assert(wrap_align_up(static_cast<int>(1), const_value(1ull << 33)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_align_up(1, 8589934592)'}}
+// expected-note@-1{{in call to 'wrap_align_up<int>(1, 8589934592)'}}
 static_assert(wrap_is_aligned(static_cast<char>(1), const_value(1 << 22)), ""); // expected-error{{not an integral constant expression}}
-// expected-note@-1{{in call to 'wrap_is_aligned(1, 4194304)'}}
+// expected-note@-1{{in call to 'wrap_is_aligned<char>(1, 4194304)'}}
 
 // Check invalid boolean type
 static_assert(wrap_align_up(static_cast<bool>(1), const_value(1 << 21)), ""); // expected-error{{not an integral constant expression}}
 // expected-note@-1{{in instantiation of function template specialization 'wrap_align_up<bool>' requested here}}
 
 // Check constant evaluation for pointers:
 _Alignas(32) char align32array[128];
 static_assert(&align32array[0] == &align32array[0], "");

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

constexpr T get(T (&a)[S], size_t k) {
     return ASSERT(k > 0 && k < S), a[k]; // expected-note{{non-constexpr function 'assert_failed'}}
   }
 #undef ASSERT
   template int get(int (&a)[4], size_t);
   constexpr int arr[] = { 4, 1, 2, 3, 4 };
   static_assert(get(arr, 1) == 1, "");
   static_assert(get(arr, 4) == 4, "");
   static_assert(get(arr, 0) == 4, ""); // expected-error{{not an integral constant expression}} \
-  // expected-note{{in call to 'get(arr, 0)'}}
+  // expected-note{{in call to 'get<const int, 5UL>(arr, 0)'}}
 }
 
 namespace std { struct type_info; }
 
 namespace TypeId {
   struct A { virtual ~A(); };
   A f();
   A &g(); // cxx20_23-note {{declared here}}

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

 
 // As an extension, we support evaluating some things that are `const` as though
 // they were `constexpr` when folding, but it should not be allowed in normal
 // constexpr evaluation.
 const char Cs[] = {'a', 'b'}; // expected-note 2{{declared here}}
 void foo() __attribute__((enable_if(sum(Cs) == 'a' + 'b', "")));
 void run() { foo(); }
 
-static_assert(sum(Cs) == 'a' + 'b', ""); // expected-error{{not an integral constant expression}} expected-note{{in call to 'sum(Cs)'}}
+static_assert(sum(Cs) == 'a' + 'b', ""); // expected-error{{not an integral constant expression}} expected-note{{in call to 'sum<2>(Cs)'}}
 constexpr int S = sum(Cs); // expected-error{{must be initialized by a constant expression}} expected-note{{in call}}
 }
 
 constexpr void PR28739(int n) { // expected-error {{never produces a constant}}
   int *p = &n;                  // expected-note {{array 'p' declared here}}
   p += (__int128)(unsigned long)-1; // expected-note {{cannot refer to element 18446744073709551615 of non-array object in a constant expression}}
   // expected-warning@-1 {{the pointer incremented by 18446744073709551615 refers past the last possible element for an array in 64-bit address space containing 32-bit (4-byte) elements (max possible 4611686018427387904 elements)}}
 }

clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp

struct no_pad {
     signed char p1, p2, p3;
     int y;
   };
 
   static_assert(sizeof(pad) == sizeof(no_pad));
 
   constexpr pad pir{4, 4};
   // expected-error@+2 {{constexpr variable 'piw' must be initialized by a constant expression}}
-  // expected-note@+1 {{in call to 'bit_cast(pir)'}}
+  // expected-note@+1 {{in call to 'bit_cast<no_pad, pad>(pir)'}}
   constexpr int piw = bit_cast<no_pad>(pir).x;
 
   // expected-error@+2 {{constexpr variable 'bad' must be initialized by a constant expression}}
-  // expected-note@+1 {{in call to 'bit_cast(pir)'}}
+  // expected-note@+1 {{in call to 'bit_cast<no_pad, pad>(pir)'}}
   constexpr no_pad bad = bit_cast<no_pad>(pir);
 
   constexpr pad fine = bit_cast<pad>(no_pad{1, 2, 3, 4, 5});
   static_assert(fine.x == 1 && fine.y == 5);
 }
 
 void no_bitfields() {
   // FIXME!

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

 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()'}}
+
+template <typename T>
+struct Bar {
+  template <typename U>
+  constexpr int fail1() const { return 1 / 0; } // expected-warning {{division by zero}} \
+                                                // expected-note {{division by zero}}
+  template <typename U, int num>
+  constexpr int fail2() const { return 1 / 0; } // expected-warning {{division by zero}} \
+                                                // expected-note {{division by zero}}
+  template <typename ...Args>
+  constexpr int fail3(Args... args) const { return 1 / 0; } // expected-warning {{division by zero}} \
+                                                // expected-note {{division by zero}}
+};
+
+constexpr Bar<int> bar;
+static_assert(bar.fail1<int>()); // expected-error {{constant expression}} \
+                                 // expected-note {{in call to 'bar.fail1<int>()'}}
+static_assert(bar.fail2<int*, 42>()); // expected-error {{constant expression}} \
+                                      // expected-note {{in call to 'bar.fail2<int *, 42>()'}}
+static_assert(bar.fail3(3, 4UL, bar, &bar)); // expected-error {{constant expression}} \
+                                             // expected-note {{in call to 'bar.fail3<int, unsigned long, Bar<int>, const Bar<int> *>(3, 4, {}, &bar)'}}

clang/test/SemaCXX/cxx2a-constexpr-dynalloc-limits.cpp

 int c = stack_array<1024>();
 int d = stack_array<1025>();
 constexpr int e = stack_array<1024>();
 constexpr int f = stack_array<1025>(); // expected-error {{constexpr variable 'f' must be initialized by a constant expression}} \
                                        //  expected-note {{in call}}
 void ohno() {
   int bar[stack_array<1024>()];
   int foo[stack_array<1025>()]; // expected-warning {{variable length arrays are a C99 feature}} \
-                                // expected-note {{in call to 'stack_array()'}}
+                                // expected-note {{in call to 'stack_array<1025>()'}}
 
   constexpr int foo[stack_array<1025>()]; // expected-warning {{variable length arrays are a C99 feature}} \
                                           // expected-error {{constexpr variable cannot have non-literal type 'const int[stack_array<1025>()]'}} \
-                                          // expected-note {{in call to 'stack_array()'}}
+                                          // expected-note {{in call to 'stack_array<1025>()'}}
 }
 
 }

clang/test/SemaCXX/cxx2b-consteval-propagate.cpp

 
 template <typename T>
 constexpr T hh() {           // hh<int> is an immediate function
     [[maybe_unused]] auto x = h<T>();
     return h<T>();
 }
 
 int i = hh<int>(); // expected-error {{call to immediate function 'examples::hh<int>' is not a constant expression}} \
-                   // expected-note {{in call to 'hh()'}}
+                   // expected-note {{in call to 'hh<int>()'}}
 
 struct A {
   int x;
   int y = id(x);
 };
 
 template <typename T>
 constexpr int k(int) {

 };
 
 constexpr S immediate(auto) {
     return S{};
 }
 
 void test_runtime() {
     (void)immediate(0); // expected-error {{call to immediate function 'Aggregate::immediate<int>' is not a constant expression}} \
-                        // expected-note {{in call to 'immediate(0)'}}
+                        // expected-note {{in call to 'immediate<int>(0)'}}
 }
 consteval int f(int i) {
     return i;
 }
 consteval void test() {
     constexpr S s = immediate(0);
     static_assert(s.x == 42);
 }