fix the message

[goncharov]

Summary

please ignore

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">,
+  "oh my, 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">;
 
 // Constant expressions
 def err_expr_not_ice : Error<

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{{recursion!}}
   a();
 }
 
-void b(int x) {  // expected-warning{{call itself}}
+void b(int x) {  // expected-warning{{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{{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{{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{{recursion!}}
   while (x < 5) {
     --x;
   }
   i(0);
 }
 
-int j() {  // expected-warning{{call itself}}
+int j() {  // expected-warning{{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{{recursion!}}
   return a();
 }
 
-void S::b() {  // expected-warning{{call itself}}
+void S::b() {  // expected-warning{{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{{recursion!}}
+  static void b() { return b(); }  // expected-warning{{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{{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 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{{recursion!}}
     return run2();
   }
 };
 
 template <int x>
 int test_wrapper() {
   if (x != 0)
     return Wrapper<x>::run() +
            Wrapper<x>::run2();  // expected-note{{instantiation}}
   return 0;
 }
 
 int wrapper_sum = test_wrapper<2>();  // expected-note{{instantiation}}