[Failing one test] Reword [-Wreturn-type] messages to "non-void x does not return a value"

[easyaspi314]

Summary

Replace [-Wreturn-type] messages, "control reaches/may reach end of non-void x", to "non-void x does/might not return a value".

That warning is a very cryptic error copied from GCC, and I had to memorize the real meaning of the message in order to make sense of it.

If you were to merge this, 'Clang :: Misc/serialized-diags-stable.c' will fail.

I need some help on this one, as clang/test/Misc/Inputs/serialized-diags-stable.dia is a binary which needs to be regenerated, and I don't exactly know how to do that.

[rsmith]

bindings/python/tests/cindex/test_diagnostics.py

18

It seems like part of the problem here is that "non-void function" is sort-of nonsense due to a few missing words. How about:

"control can reach end of function with non-void return type"

or similar?

I think we still need the mention of control flow, because we're *not* saying the function contains no return statements, we're saying there's a control flow path that reaches the end of the function.

docs/DiagnosticsReference.rst

9097

This is a generated file; please don't manually update it. (Though we should regenerate it, it's probably quite stale...)

[• Quuxplusone]

bindings/python/tests/cindex/test_diagnostics.py

18

I think OP's issue here is that the current message about "control" is intrinsically confusing. Of course "control can reach end of function"; if control never reaches the end of the function, you must have an infinite loop somewhere! The important missing piece of the current message is that control reaches the end of the function without encountering any return statement.

we're *not* saying the function contains no return statements

Not sure, but I think in this case we are saying that. There's a different message, "non-void function might not return a value," for those other cases.

However, if I'm wrong about that, then another wording option close to OP's suggestion would be "non-void function does not always return a value" / "non-void function might not always return a value."

include/clang/Basic/DiagnosticASTKinds.td

33

I think this should remain past-tense, since it's describing a situation that actually did happen during constexpr evaluation. That is, "constexpr function did not return a value" or "control fell off the end of this function" or some such.

[easyaspi314]

docs/DiagnosticsReference.rst

9097

Serious question though, why in the world do we have generated files in an open source repo?

Isn't is as stupid as putting the precompiled binaries in the source tree? I'd rather wait a few minutes to generate some files than spend 4 hours trying to figure out how to deal with serialized-diags-stable.dia.

[easyaspi314]

bindings/python/tests/cindex/test_diagnostics.py

18

I think we still need the mention of control flow.

I see where you are going.

However, I have another idea, but I can't implement it myself.

What if we give the user a note like this:

int someCondition;

int a() {
    if (someCondition) {
        return 3;
    }
}

foo.c:3:1: warning: non-void function might not return a value [-Wreturn-type]
int a() {
^
foo.c:4:5: note: assuming 'someCondition' is false
    if (someCondition) {
    ^
foo.c:7:1: note: control flow reaches end of function without a return value
}
^
1 warning generated.

bindings/python/tests/cindex/test_diagnostics.py

         self.assertEqual(tu.diagnostics[0].location.line, 1)
         self.assertEqual(tu.diagnostics[0].location.column, 11)
         self.assertEqual(tu.diagnostics[0].spelling,
-                'control reaches end of non-void function')
+                'non-void function does not return a value')
 
     def test_diagnostic_note(self):
         # FIXME: We aren't getting notes here for some reason.

docs/DiagnosticsReference.rst

 |                                                   |+--------------------+|                                                                 |
 +---------------------------------------------------+----------------------+-----------------------------------------------------------------+
 
-+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-|:warning:`warning:` |nbsp| :diagtext:`control reaches end of coroutine; which is undefined behavior because the promise type` |nbsp| :placeholder:`A` |nbsp| :diagtext:`does not declare 'return\_void()'`|
-+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|:warning:`warning:` |nbsp| :diagtext:`coroutine does not return a value; which is undefined behavior because the promise type` |nbsp| :placeholder:`A` |nbsp| :diagtext:`does not declare 'return\_void()'`|
++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
-+-------------------------------------------------------------------------------+
-|:warning:`warning:` |nbsp| :diagtext:`control reaches end of non-void function`|
-+-------------------------------------------------------------------------------+
++--------------------------------------------------------------------------------+
+|:warning:`warning:` |nbsp| :diagtext:`non-void function does not return a value`|
++--------------------------------------------------------------------------------+
 
-+-----------------------------------------------------------------------------+
-|:warning:`warning:` |nbsp| :diagtext:`control reaches end of non-void lambda`|
-+-----------------------------------------------------------------------------+
++------------------------------------------------------------------------------+
+|:warning:`warning:` |nbsp| :diagtext:`non-void lambda does not return a value`|
++------------------------------------------------------------------------------+
 
 +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-|:warning:`warning:` |nbsp| :diagtext:`control may reach end of coroutine; which is undefined behavior because the promise type` |nbsp| :placeholder:`A` |nbsp| :diagtext:`does not declare 'return\_void()'`|
+|:warning:`warning:` |nbsp| :diagtext:`coroutine might not return a value; which is undefined behavior because the promise type` |nbsp| :placeholder:`A` |nbsp| :diagtext:`does not declare 'return\_void()'`|
 +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
 +---------------------------------------------------------------------------------+
-|:warning:`warning:` |nbsp| :diagtext:`control may reach end of non-void function`|
+|:warning:`warning:` |nbsp| :diagtext:`non-void function might not return a value`|
 +---------------------------------------------------------------------------------+
 
 +-------------------------------------------------------------------------------+
-|:warning:`warning:` |nbsp| :diagtext:`control may reach end of non-void lambda`|
+|:warning:`warning:` |nbsp| :diagtext:`non-void lambda might not return a value`|
 +-------------------------------------------------------------------------------+
 
 +---------------------------------------------------+----------------------+-----------------------------------------------------------------+

include/clang/Basic/DiagnosticASTKinds.td

   "constructor inherited from base class %0 cannot be used in a "
   "constant expression; derived class cannot be implicitly initialized">;
 def note_constexpr_no_return : Note<
-  "control reached end of constexpr function">;
+  "constexpr function does not return a value">;
 def note_constexpr_virtual_call : Note<
   "cannot evaluate virtual function call in a constant expression">;
 def note_constexpr_virtual_base : Note<

include/clang/Basic/DiagnosticSemaKinds.td

   "thread-local storage is not supported for the current target">;
 
 def warn_maybe_falloff_nonvoid_function : Warning<
-  "control may reach end of non-void function">,
+  "non-void function might not return a value">,
   InGroup<ReturnType>;
 def warn_falloff_nonvoid_function : Warning<
-  "control reaches end of non-void function">,
+  "non-void function does not return a value">,
   InGroup<ReturnType>;
 def err_maybe_falloff_nonvoid_block : Error<
-  "control may reach end of non-void block">;
+  "non-void block might not return a value">;
 def err_falloff_nonvoid_block : Error<
-  "control reaches end of non-void block">;
+  "non-void block does not return a value">;
 def warn_maybe_falloff_nonvoid_coroutine : Warning<
-  "control may reach end of coroutine; which is undefined behavior because the promise type %0 does not declare 'return_void()'">,
+  "coroutine might not return a value; which is undefined behavior because the promise type %0 does not declare 'return_void()'">,
   InGroup<ReturnType>;
 def warn_falloff_nonvoid_coroutine : Warning<
-  "control reaches end of coroutine; which is undefined behavior because the promise type %0 does not declare 'return_void()'">,
+  "coroutine does not return a value; which is undefined behavior because the promise type %0 does not declare 'return_void()'">,
   InGroup<ReturnType>;
 def warn_suggest_noreturn_function : Warning<
   "%select{function|method}0 %1 could be declared with attribute 'noreturn'">,

   def err_noreturn_lambda_has_return_expr : Error<
     "lambda declared 'noreturn' should not return">;
   def warn_maybe_falloff_nonvoid_lambda : Warning<
-    "control may reach end of non-void lambda">,
+    "non-void lambda might not return a value">,
     InGroup<ReturnType>;
   def warn_falloff_nonvoid_lambda : Warning<
-    "control reaches end of non-void lambda">,
+    "non-void lambda does not return a value">,
     InGroup<ReturnType>;
   def err_access_lambda_capture : Error<
     // The ERRORs represent other special members that aren't constructors, in

test/Analysis/const-method-call.cpp

   void constMemberFunction() const;
 };
 
-HasConstMemberFunction hasNoReturn() { } // expected-warning {{control reaches end of non-void function}}
+HasConstMemberFunction hasNoReturn() { } // expected-warning {{non-void function does not return a value}}
 
 void testUnknownWithConstMemberFunction() {
   hasNoReturn().constMemberFunction();

test/Analysis/logical-ops.c

   return x >= start && x < end;
 }
 
-int undef(void) {} // expected-warning{{control reaches end of non-void function}}
+int undef(void) {} // expected-warning{{non-void function does not return a value}}
 void useUndef(void) { 0 || undef(); }
 
 void testPointer(void) { (void) (1 && testPointer && 0); }

test/Analysis/nil-receiver-undefined-larger-than-voidptr-ret.m

   return [obj voidM], 0;
 }
 
-int marker(void) { // control reaches end of non-void function
+int marker(void) { // non-void function does not return a value
 }
 
 // CHECK-darwin8: warning: The receiver of message 'longDoubleM' is nil and returns a value of type 'long double' that will be garbage

test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp

 // An attribute-specifier-seq in a lambda-declarator appertains to the
 // type of the corresponding function call operator.
 void test_attributes() {
-  auto nrl = [](int x) -> int { if (x > 0) return x; }; // expected-warning{{control may reach end of non-void lambda}}
+  auto nrl = [](int x) -> int { if (x > 0) return x; }; // expected-warning{{non-void lambda might not return a value}}
 
   // FIXME: GCC accepts the [[gnu::noreturn]] attribute here.
   auto nrl2 = []() [[gnu::noreturn]] { return; }; // expected-warning{{attribute 'noreturn' ignored}}

test/CXX/expr/expr.prim/expr.prim.lambda/p7.cpp

 
 // Check that analysis-based warnings work in lambda bodies.
 void analysis_based_warnings() {
-  (void)[]() -> int { }; // expected-warning{{control reaches end of non-void lambda}}
+  (void)[]() -> int { }; // expected-warning{{non-void lambda does not return a value}}
 }
 
 // Check that we get the right types of captured variables (the

test/CodeGenObjCXX/property-dot-reference.mm

 // CHECK: call dereferenceable({{[0-9]+}}) %struct.TFENode* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 // CHECK-NEXT: call void @_ZNK7TFENode6GetURLEv(%struct.TFENode* %{{.*}})
   self.node.GetURL();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 @end
 
 // rdar://8437240

test/Driver/cc-log-diagnostics.c

 // CHECK:       <key>column</key>
 // CHECK:       <integer>11</integer>
 // CHECK:       <key>message</key>
-// CHECK:       <string>control reaches end of non-void function</string>
+// CHECK:       <string>non-void function does not return a value</string>
 // CHECK:     </dict>
 // CHECK:   </array>
 // CHECK: </dict>

test/Frontend/absolute-paths.c

 // directory in the path.
 // NORMAL: SystemHeaderPrefix
 // ABSOLUTE-NOT: SystemHeaderPrefix
-// CHECK: warning: control reaches end of non-void function
+// CHECK: warning: non-void function does not return a value
 
 
 // For files which don't exist, just print the filename.
 #line 123 "non-existant.c"
 int g() {}
-// NORMAL: non-existant.c:123:10: warning: control reaches end of non-void function
-// ABSOLUTE: non-existant.c:123:10: warning: control reaches end of non-void function
+// NORMAL: non-existant.c:123:10: warning: non-void function does not return a value
+// ABSOLUTE: non-existant.c:123:10: warning: non-void function does not return a value

test/Frontend/ast-main.cpp

 };
 template<typename T>
 T *S<T>::mf() {
-    // warning: control reaches end of non-void function [-Wreturn-type]
+    // warning: non-void function does not return a value [-Wreturn-type]
 }
 
 void f() {

test/Index/warning-flags.c

 // RUN: c-index-test -test-load-source-reparse 5 all -w %s 2>&1 | FileCheck -check-prefix=NOWARNINGS %s
 // RUN: c-index-test -test-load-source all -w -O4 %s 2>&1 | FileCheck -check-prefix=NOWARNINGS %s
 
-// CHECK-BOTH-WARNINGS: warning: control reaches end of non-void function
+// CHECK-BOTH-WARNINGS: warning: non-void function does not return a value
 // CHECK-BOTH-WARNINGS: warning: incompatible pointer types returning 'float *' from a function with result type 'int *'
 
-// CHECK-SECOND-WARNING-NOT:control reaches end of non-void
+// CHECK-SECOND-WARNING-NOT:non-void function does not return a value
 // CHECK-SECOND-WARNING: warning: incompatible pointer types returning 'float *' from a function with result type 'int *'
 
 // NOWARNINGS-NOT: warning:

test/Misc/serialized-diags-stable.c

 // RUN: c-index-test -read-diagnostics %S/Inputs/serialized-diags-stable.dia 2>&1 | FileCheck %s
 
 int foo() {
-  // CHECK: serialized-diags-stable.c:[[@LINE+2]]:1: warning: control reaches end of non-void function [-Wreturn-type] [Semantic Issue]
+  // CHECK: serialized-diags-stable.c:[[@LINE+2]]:1: warning: non-void function does not return a value [-Wreturn-type] [Semantic Issue]
   // CHECK-NEXT: Number FIXITs = 0
 }
 

test/Modules/redecl-merge.m

 
 int *call_eventually_noreturn(void) {
   eventually_noreturn();
-} // expected-warning{{control reaches end of non-void function}}
+} // expected-warning{{non-void function does not return a value}}
 
 int *call_eventually_noreturn2(void) {
   eventually_noreturn2();
-} // expected-warning{{control reaches end of non-void function}}
+} // expected-warning{{non-void function does not return a value}}
 
 @import redecl_merge_right;
 

test/PCH/late-parsed-instantiations.cpp

   char data() {
     visit([](auto buffer) -> char { // expected-note {{in instantiation}}
       buffer->data();
-    }); // expected-warning {{control reaches end of non-void lambda}}
-  } // expected-warning {{control reaches end of non-void function}}
+    }); // expected-warning {{non-void lambda does not return a value}}
+  } // expected-warning {{non-void function does not return a value}}
 };
 
 #else

test/Sema/block-return-1.c

 
 int j;
 void foo() {
-  ^ (void) { if (j) return 1; }(); // expected-error {{control may reach end of non-void block}}
+  ^ (void) { if (j) return 1; }(); // expected-error {{non-void block might not return a value}}
 }

test/Sema/block-return-3.c

 // RUN: %clang_cc1 -fsyntax-only %s -verify -fblocks
 
 void foo() {
-  ^ int (void) { }(); // expected-error {{control reaches end of non-void block}}
+  ^ int (void) { }(); // expected-error {{non-void block does not return a value}}
 }

test/Sema/freemain.c

 
 void* main(void* context, long size) {
   if (context) return allocate(size);
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}

test/Sema/return.c

 }
 
 int test1() {
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test2() {
   a: goto a;

 int test3() {
   goto a;
   a: ;
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 
 void halt() {

 
 int test7() {
   unknown();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test8() {
   (void)(1 + unknown());
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int halt3() __attribute__((noreturn));
 

 
 int test10() {
   (void)(unknown() || halt3());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int test11() {
   (void)(unknown() && halt3());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int test12() {
   (void)(halt3() || unknown());

 
 int test14() {
   (void)(1 || unknown());
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test15() {
   (void)(0 || unknown());
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test16() {
   (void)(0 && unknown());
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test17() {
   (void)(1 && unknown());
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test18() {
   (void)(unknown_nohalt() && halt3());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int test19() {
   (void)(unknown_nohalt() && unknown());
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test20() {
   int i;

     return 0;
   else if (0)
     return 2;
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int test21() {
   int i;

 int test22() {
   int i;
   switch (i) default: ;
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int test23() {
   int i;

   case 2:
     return 2;
   }
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int test24() {
   int i;

 
 int test26() {
   0 ? halt3() : unknown();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int j;
 void (*fptr)() __attribute__((noreturn));

 
 // Test that 'static inline' functions are only analyzed for CFG-based warnings
 // when they are used.
-static inline int si_has_missing_return() {} // expected-warning{{control reaches end of non-void function}}
-static inline int si_has_missing_return_2() {}; // expected-warning{{control reaches end of non-void function}}
+static inline int si_has_missing_return() {} // expected-warning{{non-void function does not return a value}}
+static inline int si_has_missing_return_2() {}; // expected-warning{{non-void function does not return a value}}
 static inline int si_forward();
 static inline int si_has_missing_return_3(int x) {
   if (x)
    return si_has_missing_return_3(x+1);
-} // expected-warning{{control may reach end of non-void function}}
+} // expected-warning{{non-void function might not return a value}}
 
 int test_static_inline(int x) {
   si_forward();
   return x ? si_has_missing_return_2() : si_has_missing_return_3(x);
 }
-static inline int si_forward() {} // expected-warning{{control reaches end of non-void function}}
+static inline int si_forward() {} // expected-warning{{non-void function does not return a value}}
 
 // Test warnings on ignored qualifiers on return types.
 const int ignored_c_quals(); // expected-warning{{'const' type qualifier on return type has no effect}}

   default:
     break;
   }
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 // sizeof(long) test.
 int sizeof_long() {

test/SemaCXX/attr-noreturn.cpp

 
   int &test1() {
     a.nofail();
-  } // expected-warning {{control reaches end of non-void function}}
+  } // expected-warning {{non-void function does not return a value}}
 
   int &test2() {
     a.fail();

test/SemaCXX/constant-expression-cxx1y.cpp

       return 2;
     }
   }
-} // expected-note 2{{control reached end of constexpr function}}
+} // expected-note 2{{constexpr function does not return a value}}
 static_assert(j(0) == -3, "");
 static_assert(j(1) == 5, "");
 static_assert(j(2), ""); // expected-error {{constant expression}} expected-note {{in call to 'j(2)'}}

test/SemaCXX/coreturn.cpp

 
 int test2() {
   co_await a;
-} // expected-warning {{control reaches end of coroutine; which is undefined behavior because the promise type 'std::experimental::coroutine_traits<int>::promise_type' (aka 'promise_int') does not declare 'return_void()'}}
+} // expected-warning {{coroutine does not return a value; which is undefined behavior because the promise type 'std::experimental::coroutine_traits<int>::promise_type' (aka 'promise_int') does not declare 'return_void()'}}
 
 int test2a(bool b) {
   if (b)
     co_return 42;
-} // expected-warning {{control may reach end of coroutine; which is undefined behavior because the promise type 'std::experimental::coroutine_traits<int, bool>::promise_type' (aka 'promise_int') does not declare 'return_void()'}}
+} // expected-warning {{coroutine might not return a value; which is undefined behavior because the promise type 'std::experimental::coroutine_traits<int, bool>::promise_type' (aka 'promise_int') does not declare 'return_void()'}}
 
 int test3() {
   co_await a;

 
 void test5(int) {
   co_await a;
-} // expected-warning {{control reaches end of coroutine; which is undefined behavior because}}
+} // expected-warning {{coroutine does not return a value; which is undefined behavior because}}
 
 void test6(int x) {
   if (x)
     co_return 42;
-} // expected-warning {{control may reach end of coroutine; which is undefined behavior because}}
+} // expected-warning {{coroutine might not return a value; which is undefined behavior because}}
 
 void test7(int y) {
   if (y)

 
 VoidTagReturnValue test10() {
   co_await a;
-} // expected-warning {{control reaches end of coroutine}}
+} // expected-warning {{coroutine does not return a value}}
 
 VoidTagReturnValue test11(bool b) {
   if (b)
     co_return 42;
-} // expected-warning {{control may reach end of coroutine}}
+} // expected-warning {{coroutine might not return a value}}

test/SemaCXX/cxx1y-deduced-return-type.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}}
+  template<typename T> struct Y { constexpr T f() {} }; // expected-note {{constexpr function does not return a value}}
   void f() {
     X<int>().f();
     Y<void>().f();

test/SemaCXX/return-noreturn.cpp

   }
   int f2_positive(int x) {
     switch (x) { default: ; }
-  } // expected-warning {{control reaches end of non-void function}}
+  } // expected-warning {{non-void function does not return a value}}
   int f3(int x) {
     switch (x) { default: { pr6884_abort_struct(); } }
   }

       pr6884_abort_struct *p = new pr6884_abort_struct();
       delete p;
     }
-  } // expected-warning {{control reaches end of non-void function}}
+  } // expected-warning {{non-void function does not return a value}}
 
   // Test that these constructs work even when extraneous blocks are created
   // before and after the switch due to implicit destructors.

   int g2_positive(int x) {
     other o;
     switch (x) { default: ; }
-  } // expected-warning {{control reaches end of non-void function}}
+  } // expected-warning {{non-void function does not return a value}}
   int g3(int x) {
     other o;
     switch (x) { default: { pr6884_abort_struct(); } }

     default:
         break;
   }
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 void PR9412_f() {
     PR9412_t<PR9412_Exact>(); // expected-note {{in instantiation of function template specialization 'PR9412_t<PR9412_Exact>' requested here}}

 
 int testTernaryStaticallyConditionalRetrunOnTrue() {
   true ? Return() : NoReturn();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int testTernaryStaticallyConditionalNoretrunOnFalse() {
   false ? Return() : NoReturn();

 
 int testTernaryStaticallyConditionalRetrunOnFalse() {
   false ? NoReturn() : Return();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int testTernaryConditionalNoreturnTrueBranch(bool value) {
   value ? (NoReturn() || NoReturn()) : Return();
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int testTernaryConditionalNoreturnFalseBranch(bool value) {
   value ? Return() : (NoReturn() || NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int testConditionallyExecutedComplexTernaryTrueBranch(bool value) {
   value || (true ? NoReturn() : true);
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int testConditionallyExecutedComplexTernaryFalseBranch(bool value) {
   value || (false ? true : NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int testStaticallyExecutedLogicalOrBranch() {
   false || NoReturn();

 
 int testStaticallySkippedLogicalOrBranch() {
   true || NoReturn();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int testStaticallySkppedLogicalAndBranch() {
   false && NoReturn();
-} // expected-warning {{control reaches end of non-void function}}
+} // expected-warning {{non-void function does not return a value}}
 
 int testConditionallyExecutedComplexLogicalBranch(bool value) {
   value || (true && NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int testConditionallyExecutedComplexLogicalBranch2(bool value) {
   (true && value) || (true && NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int testConditionallyExecutedComplexLogicalBranch3(bool value) {
   (false && (Return() || true)) || (true && NoReturn());

   int bar() {
     X work([](){ Fatal(); });
     foo();
-  } // expected-warning {{control reaches end of non-void function}}
+  } // expected-warning {{non-void function does not return a value}}
 
   int baz() {
     FatalCopy fc;

 int functionTryBlock1(int s) try {
   return 0;
 } catch (...) {
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int functionTryBlock2(int s) try {
 } catch (...) {
   return 0;
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function might not return a value}}
 
 int functionTryBlock3(int s) try {
   return 0;

test/SemaCXX/warn-missing-noreturn.cpp

 
 int rdar8875247_test() {
   rdar8875247 f;
-} // expected-warning{{control reaches end of non-void function}}
+} // expected-warning{{non-void function does not return a value}}
 
 struct rdar8875247_B {
   rdar8875247_B();

test/SemaTemplate/late-parsing-eager-instantiation.cpp

   char data() {
     visit([](auto buffer) -> char { // expected-note {{in instantiation}}
       buffer->data();
-    }); // expected-warning {{control reaches end of non-void lambda}}
-  } // expected-warning {{control reaches end of non-void function}}
+    }); // expected-warning {{non-void lambda does not return a value}}
+  } // expected-warning {{non-void function does not return a value}}
 };
 
 // pr34185