[Diagnostic] Clarify -Winfinite-recursion message

[aaron.ballman]

Thank you for the patch! However, I think this isn't an improvement to the diagnostic -- it's a cute phrase, but it doesn't help the programmer to understand what about their code needs to change.

[merrymeerkat]

In D137077#3896369, @aaron.ballman wrote:

Thank you for the patch! However, I think this isn't an improvement to the diagnostic -- it's a cute phrase, but it doesn't help the programmer to understand what about their code needs to change.

Hi Aaron! Agreed--thank you for the review! I was just following a tutorial on how to make changes to LLVM, so this was not a real code review :)
Cheers!

[aaron.ballman]

In D137077#3896561, @merrymeerkat wrote:

In D137077#3896369, @aaron.ballman wrote:

Thank you for the patch! However, I think this isn't an improvement to the diagnostic -- it's a cute phrase, but it doesn't help the programmer to understand what about their code needs to change.

Hi Aaron! Agreed--thank you for the review! I was just following a tutorial on how to make changes to LLVM, so this was not a real code review :)
Cheers!

Ahhh, that makes a lot more sense, thank for letting me know! (This is like the fourth time I've seen someone submit these same changes and I was confused as to why this was such a popular attempted modification, lol.)

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_max_unsigned_zero : Warning<
   "taking the max of "
   "%select{a value and unsigned zero|unsigned zero and a value}0 "
   "is always equal to the other value">,
   InGroup<MaxUnsignedZero>;
 def note_remove_max_call : Note<
   "remove call to max function and unsigned zero argument">;
 
 def warn_infinite_recursive_function : Warning<
-  "all paths through this function will call itself">,
+  "in order to understand recursion, you must first understand recursion">,
   InGroup<InfiniteRecursion>, DefaultIgnore;
 
 def warn_comma_operator : Warning<"possible misuse of comma operator here">,
   InGroup<DiagGroup<"comma">>, DefaultIgnore;
 def note_cast_to_void : Note<"cast expression to void to silence warning">;
 def note_cast_operand_to_int : Note<"cast one or both operands to int to silence this warning">;
 
 // Constant expressions

clang/test/SemaCXX/warn-infinite-recursion.cpp

 // RUN: %clang_cc1 %s -fsyntax-only -verify -Winfinite-recursion
 
-void a() {  // expected-warning{{call itself}}
+void a() {  // expected-warning{{to understand recursion}}
   a();
 }
 
-void b(int x) {  // expected-warning{{call itself}}
+void b(int x) {  // expected-warning{{to understand recursion}}
   if (x)
     b(x);
   else
     b(x+1);
 }
 
 void c(int x) {
   if (x)
     c(5);
 }
 
-void d(int x) {  // expected-warning{{call itself}}
+void d(int x) {  // expected-warning{{to understand recursion}}
   if (x)
     ++x;
   return d(x);
 }
 
 // Doesn't warn on mutually recursive functions
 void e();
 void f();
 
 void e() { f(); }
 void f() { e(); }
 
-void g() {  // expected-warning{{call itself}}
+void g() {  // expected-warning{{to understand recursion}}
   while (true)
     g();
 
   g();
 }
 
 void h(int x) {
   while (x < 5) {
     h(x+1);
   }
 }
 
-void i(int x) {  // expected-warning{{call itself}}
+void i(int x) {  // expected-warning{{to understand recursion}}
   while (x < 5) {
     --x;
   }
   i(0);
 }
 
-int j() {  // expected-warning{{call itself}}
+int j() {  // expected-warning{{to understand recursion}}
   return 5 + j();
 }
 
 // Don't warn on infinite loops
 void k() {
   while(true) {
     k();
   }
void m() {
   while (true) {}
 }
 
 class S {
   static void a();
   void b();
 };
 
-void S::a() {  // expected-warning{{call itself}}
+void S::a() {  // expected-warning{{to understand recursion}}
   return a();
 }
 
-void S::b() {  // expected-warning{{call itself}}
+void S::b() {  // expected-warning{{to understand recursion}}
   int i = 0;
   do {
     ++i;
     b();
   } while (i > 5);
 }
 
 template<class member>
 struct T {
   member m;
-  void a() { return a(); }  // expected-warning{{call itself}}
-  static void b() { return b(); }  // expected-warning{{call itself}}
+  void a() { return a(); }  // expected-warning{{to understand recursion}}
+  static void b() { return b(); }  // expected-warning{{to understand recursion}}
 };
 
 void test_T() {
   T<int> foo;
   foo.a();  // expected-note{{in instantiation}}
   foo.b();  // expected-note{{in instantiation}}
 }
 
 class U {
   U* u;
-  void Fun() {  // expected-warning{{call itself}}
+  void Fun() {  // expected-warning{{to understand recursion}}
     u->Fun();
   }
 };
 
 // No warnings on templated functions
-// sum<0>() is instantiated, does recursively call itself, but never runs.
+// sum<0>() is instantiated, does recursively to understand recursion, but never runs.
 template <int value>
 int sum() {
   return value + sum<value/2>();
 }
 
 template<>
 int sum<1>() { return 1; }
 

 template<int x>
 struct Wrapper {
   static int run() {
     // Similar to the above, Wrapper<0>::run() will discard the if statement.
     if (x == 1)
       return 0;
     return Wrapper<x/2>::run();
   }
-  static int run2() {  // expected-warning{{call itself}}
+  static int run2() {  // expected-warning{{to understand recursion}}
     return run2();
   }
 };
 
 template <int x>
 int test_wrapper() {
   if (x != 0)
     return Wrapper<x>::run() +
protected:
   const char *__name;
 };
 } // namespace std
 struct Q {
   virtual ~Q() = default;
 };
 
 Q q;
-Q &evaluated_recursive_function(int x) {         // expected-warning{{call itself}}
+Q &evaluated_recursive_function(int x) {         // expected-warning{{to understand recursion}}
   (void)typeid(evaluated_recursive_function(x)); // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
   return q;
 }
 
 int unevaluated_recursive_function() {
   (void)typeid(unevaluated_recursive_function());
   return 0;
 }