[Diagnostics] Try to improve warning message for -Wreturn-type

[xbolva00]

Summary

I agree with https://easyaspi314.github.io/gcc-vs-clang.html?fbclid=IwAR1VA0qxiWVUusOQUv5z7JESS7ZpeJy-UqAI5mnJscofGLqXcqeErIUB2gU, current warning message is not very good. We should try to improve it..

[xbolva00]

Up.

[xbolva00]

I will update tests after we decide on final text.

[aaron.ballman]

I think the new text is more clear than the old text, so I'm fine with the current direction you're going.

clang/include/clang/Basic/DiagnosticSemaKinds.td

585–588

Should we change this wording as well? Along with any other instances of similar wording (I don't recall if we have something similar for lambdas or if we defer to the function diagnostics in that case)?

[xbolva00]

clang/include/clang/Basic/DiagnosticSemaKinds.td

585–588

+1, I agree.

It would be better if somebody more familiar with Obj-C / coroutines and related terminology would improve these text.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

585–588

I think you've already got the gist of it. block does not return a value; non-void blocks must return a value, and similar for coroutines.

In fact, I wonder why we don't just combine these diagnostics for all three situations and use a %select for them? That seems like a reasonable thing to do (having not put a ton of thought into it).

[• Quuxplusone]

clang/include/clang/Basic/DiagnosticSemaKinds.td

580

As long as we're messing with this wording: Does it actually help any human reader to distinguish "control paths" versus simply "paths"? And could we DRY it up by saying

not all paths in this non-void {function,block} return a value

this non-void {function,block} does not return a value

not all paths in this coroutine return a value, and the promise type %0 does not declare 'return_void()'

this coroutine does not return a value, and the promise type %0 does not declare 'return_void()'

I don't think the Coroutines warning needs to specifically call out "undefined behavior," unless it is trying to say that the code is IFNDR. Of course falling off the end of a function is UB if it ever actually happens at runtime; that's no different whether it's a coroutine or a regular function/block. The only reason for a wording difference in the Coroutines case is that the colloquial notion of a "(non-)void coroutine" (whose return type would be something like task<void>) is slightly less familiar than the colloquial notion of a "(non-)void function" (whose return type is literally void).

[xbolva00]

clang/include/clang/Basic/DiagnosticSemaKinds.td

580

I am also wondering if we could use some better term than "control paths", but I haven't found any :) Paths sound to general for me but I am not strongly opposed.

if @aaron.ballman is happy with your wording, so do I.

[easyaspi314]

How about "this non-void {function|block} {may|does} not return a value"

[• Quuxplusone]

In D69762#1737612, @easyaspi314 wrote:

How about "this non-void {function|block} {may|does} not return a value"

FWIW, I am happy with this clear and concise suggestion. :)

[xbolva00]

I am not sure if "may" is ideal, it could suggest that compiler is not very sure and emits just some conservative message.

"not all paths in this non-void {function,block} return a value" gives some extra confidence that compiler knows there is a buggy control path.

[aaron.ballman]

I'd probably go with "non-void %select{function|block|coroutine}0 does not return a value %select{|in all control paths}1"

[xbolva00]

We cannot use it for block; it is a hard error. Corountine and function can be merged as suggested.

[xbolva00]

Looking at Sema/AnalysisBasedWarnings.cpp, reworking it to "select" would take some time so I will prepare just simple patch without "select".

[xbolva00]

Fixed review comments.

[aaron.ballman]

In D69762#1739022, @xbolva00 wrote:

We cannot use it for block; it is a hard error. Corountine and function can be merged as suggested.

We can use .Text to share diagnostic text between warnings and errors (we do this elsewhere), but I don't insist for this patch.

LGTM aside from a commenting request.

clang/include/clang/Basic/DiagnosticSemaKinds.td

579

A FIXME comment that we'd like to combine these diagnostics eventually would be appreciated.

6861

And maybe move these two up closer to the other duplicate-ish diagnostics.

[xbolva00]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6861

This is in
"let CategoryName = "Lambda Issue" in {"

so I am not sure if should really move it.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6861

I hadn't noticed that, let's leave it here. Good catch!

[xbolva00]

Added FIXME.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 
 def err_invalid_thread : Error<
   "'%0' is only allowed on variable declarations">;
 def err_thread_non_global : Error<
   "'%0' variables must have global storage">;
 def err_thread_unsupported : Error<
   "thread-local storage is not supported for the current target">;
 
+// FIXME: Combine fallout warnings to just one warning.
 def warn_maybe_falloff_nonvoid_function : Warning<
-  "control may reach end of non-void function">,
+  "non-void function does not return a value in all control paths">,
   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 does not return a value in all control paths">;
 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()'">,
+  "non-void coroutine does not return a value in all control paths">,
   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()'">,
+  "non-void coroutine does not return a value">,
   InGroup<ReturnType>;
 def warn_suggest_noreturn_function : Warning<
   "%select{function|method}0 %1 could be declared with attribute 'noreturn'">,
   InGroup<MissingNoreturn>, DefaultIgnore;
 def warn_suggest_noreturn_block : Warning<
   "block could be declared with attribute 'noreturn'">,
   InGroup<MissingNoreturn>, DefaultIgnore;
 
let CategoryName = "Lambda Issue" in {
   def err_lambda_return_init_list : Error<
     "cannot deduce lambda return type from initializer list">;
   def err_lambda_capture_default_arg : Error<
     "lambda expression in default argument cannot capture any entity">;
   def err_lambda_incomplete_result : Error<
     "incomplete result type %0 in lambda expression">;
   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 does not return a value in all control paths">,
     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
     // hopes that someone will bother noticing and reporting if they appear
     "capture of variable '%0' as type %1 calls %select{private|protected}3 "
     "%select{default |copy |move |*ERROR* |*ERROR* |*ERROR* |}2constructor">,
     AccessControl;
   def note_lambda_to_block_conv : Note<

clang/test/Analysis/const-method-call.cpp

 
 // --- PR25392 --- //
 
 struct HasConstMemberFunction {
 public:
   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();
 }
 
 void testNonRegionLocWithConstMemberFunction() {
   (*((HasConstMemberFunction *)(&&label))).constMemberFunction();
 

clang/test/Analysis/structured_bindings.cpp

 // RUN: %clang_analyze_cc1 -std=c++17 -analyzer-checker=core -verify %s
 
 struct s { int a; };
 int foo() {
     auto[a] = s{1}; // FIXME: proper modelling
     if (a) {
     }
-} // expected-warning{{control reaches end of non-void function}}
+} // expected-warning{{non-void function does not return a value}}
 

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

 // RUN: %clang_cc1 -std=c++11 %s -Winvalid-noreturn -verify
 
 // 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{{on-void lambda does not return a value in all control paths}}
 
   // FIXME: GCC accepts the [[gnu::noreturn]] attribute here.
   auto nrl2 = []() [[gnu::noreturn]] { return; }; // expected-warning{{attribute 'noreturn' ignored}}
 }
 
 template<typename T>
 struct bogus_override_if_virtual : public T {
   bogus_override_if_virtual() : T(*(T*)0) { } // expected-warning {{binding dereferenced null pointer to reference has undefined behavior}}

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

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 %s -verify
 
 // 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
 // semantic-analysis part of p7).
 int &check_const_int(int&);
 float &check_const_int(const int&);
 
 void test_capture_constness(int i, const int ic) {

clang/test/Driver/cc-log-diagnostics.c

 // CHECK:       <string>warning</string>
 // CHECK:       <key>filename</key>
 // CHECK:       <string>{{.*}}cc-log-diagnostics.c</string>
 // CHECK:       <key>line</key>
 // CHECK:       <integer>7</integer>
 // 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>

clang/test/Frontend/absolute-paths.c

 // RUN: %clang_cc1 -fsyntax-only -I %S/Inputs/SystemHeaderPrefix/.. %s 2>&1 | FileCheck -check-prefix=NORMAL -check-prefix=CHECK %s
 // RUN: %clang_cc1 -fsyntax-only -I %S/Inputs/SystemHeaderPrefix/.. -fdiagnostics-absolute-paths %s 2>&1 | FileCheck -check-prefix=ABSOLUTE -check-prefix=CHECK %s
 
 #include "absolute-paths.h"
 
 // Check whether the diagnostic from the header above includes the dummy
 // 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

clang/test/Index/warning-flags.c

 int foo() { }
 int *bar(float *f) { return f; }
 
 // RUN: c-index-test -test-load-source all %s 2>&1|FileCheck -check-prefix=CHECK-BOTH-WARNINGS %s
 // RUN: c-index-test -test-load-source-reparse 5 all %s 2>&1|FileCheck -check-prefix=CHECK-BOTH-WARNINGS %s
 // RUN: c-index-test -test-load-source all -Wno-return-type  %s 2>&1|FileCheck -check-prefix=CHECK-SECOND-WARNING %s
 // RUN: c-index-test -test-load-source-reparse 5 all -Wno-return-type %s 2>&1|FileCheck -check-prefix=CHECK-SECOND-WARNING %s
 // RUN: c-index-test -test-load-source all -w %s 2>&1 | FileCheck -check-prefix=NOWARNINGS %s
 // 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:

clang/test/Misc/serialized-diags-stable.c

 // RUN: rm -f %t
 // RUN: not %clang -Wall -fsyntax-only %s --serialize-diagnostics %t.dia > /dev/null 2>&1
 // RUN: c-index-test -read-diagnostics %t.dia 2>&1 | FileCheck %s
 
 // 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
 }
 
 // CHECK: serialized-diags-stable.c:[[@LINE+5]]:13: error: redefinition of 'bar' as different kind of symbol [] [Semantic Issue]
 // CHECK-NEXT: Number FIXITs = 0
 // CHECK-NEXT: +-{{.*}}serialized-diags-stable.c:[[@LINE+2]]:6: note: previous definition is here [] []
 // CHECK-NEXT: Number FIXITs = 0
 void bar() {}
 typedef int bar;
 
 
 // CHECK-LABEL: Number of diagnostics: 2

clang/test/Modules/redecl-merge.m

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -Wreturn-type -fmodules-cache-path=%t -I %S/Inputs %s -verify -Wno-objc-root-class
 
 @class C2;
 @class C3;
 @class C3;
 @import redecl_merge_left;
 typedef struct my_struct_type *my_struct_ref;
 @protocol P4;
 @class C3;
 @class C3;
 
 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;
 
 int *call_eventually_noreturn_again(void) {
   eventually_noreturn();
 }
 
 int *call_eventually_noreturn2_again(void) {

clang/test/PCH/late-parsed-instantiations.cpp

 template <typename _Visitor>
 constexpr void visit(_Visitor __visitor) {
   __visitor(get()); // expected-note {{in instantiation}}
 }
 class ArrayBuffer {
   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
 
 // expected-no-diagnostics
 
 #endif

clang/test/Sema/block-return-1.c

 // RUN: %clang_cc1 -fsyntax-only %s -verify -fblocks
 
 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 does not return a value in all control paths}}
 }

clang/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}}
 }

clang/test/Sema/freemain.c

 // RUN: %clang_cc1 -triple i686-pc-openbsd -fsyntax-only -verify -ffreestanding %s
 
 // Tests that -ffreestanding disables all special treatment of main().
 
 void* allocate(long size);
 
 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 does not return a value in all control paths}}

clang/test/Sema/return.c

 }
 
 int unknown();
 
 void test0() {
 }
 
 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() {
   a: goto a;
 }
 
 void halt2() __attribute__((noreturn));
 

 
 int j;
 int unknown_nohalt() {
   return j;
 }
 
 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 test9() {
   (void)(halt3() + unknown());
 }
 
 int test10() {
   (void)(unknown() || halt3());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int test11() {
   (void)(unknown() && halt3());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int test12() {
   (void)(halt3() || unknown());
 }
 
 int test13() {
   (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 does not return a value in all control paths}}
 
 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;
   if (i)
     return 0;
   else if (0)
     return 2;
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int test21() {
   int i;
   if (i)
     return 0;
   else if (1)
     return 2;
 }
 
 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;
   switch (i) {
   case 0:
     return 0;
   case 2:
     return 2;
   }
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int test24() {
   int i;
   switch (i) {
     case 0:
     return 0;
   case 2:
     return 2;
   default:
     return -1;
   }
 }
 
 int test25() {
   1 ? halt3() : unknown();
 }
 
 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));
 int test27() {
   switch (j) {
   case 1:
     do { } while (1);
     break;

 }
 
 void test33() {
   if (j) while (1) { }
 }
 
 // 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 does not return a value in all control paths}}
 
 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}}
 const volatile int ignored_cv_quals(); // expected-warning{{'const volatile' type qualifiers on return type have no effect}}
 char* const volatile restrict ignored_cvr_quals(); // expected-warning{{'const volatile restrict' type qualifiers on return type have no effect}}
 
 typedef const int CI;
 CI ignored_quals_typedef();

 
 int PR19074_positive(int x) {
   switch(x) {
   case 0:
     return 0;
   default:
     break;
   }
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 // sizeof(long) test.
 int sizeof_long() {
   if (sizeof(long) == 4)
     return 1;
   if (sizeof(long) == 8)
     return 2;
 } // no-warning
 
 int return_statement_expression() {
   if (unknown())
     return ({
       while (0)
         ;
       0;
     });
   else
     return 0;
-} // no-warning (used to be "control may reach end of non-void function")
+} // no-warning (used to be "non-void function does not return a value in all control paths")

clang/test/SemaCXX/attr-noreturn.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Reachability tests have to come first because they get suppressed
 // if any errors have occurred.
 namespace test5 {
   struct A {
     __attribute__((noreturn)) void fail();
     void nofail();
   } a;
 
   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();
   }
 }
 
 namespace destructor_tests {
   __attribute__((noreturn)) void fail();

clang/test/SemaCXX/coreturn.cpp

 template <typename... T>
 struct std::experimental::coroutine_traits<int, T...> { using promise_type = promise_int; };
 
 void test0() { co_await a; }
 float test1() { co_await a; }
 
 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 {{non-void coroutine does not return a value}}
 
 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 {{non-void coroutine does not return a value in all control paths}}
 
 int test3() {
   co_await a;
 b:
   goto b;
 }
 
 int test4() {
   co_return 42;
 }
 
 void test5(int) {
   co_await a;
-} // expected-warning {{control reaches end of coroutine; which is undefined behavior because}}
+} // expected-warning {{non-void coroutine does not return a value}}
 
 void test6(int x) {
   if (x)
     co_return 42;
-} // expected-warning {{control may reach end of coroutine; which is undefined behavior because}}
+} // expected-warning {{non-void coroutine does not return a value in all control paths}}
 
 void test7(int y) {
   if (y)
     co_return 42;
   else
     co_return 101;
 }
 
 VoidTagReturnVoid test8() {
   co_await a;
 }
 
 VoidTagReturnVoid test9(bool b) {
   if (b)
     co_return;
 }
 
 VoidTagReturnValue test10() {
   co_await a;
-} // expected-warning {{control reaches end of coroutine}}
+} // expected-warning {{non-void 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 {{non-void coroutine does not return a value in all control paths}}

clang/test/SemaCXX/return-noreturn.cpp

namespace abort_struct_complex_cfgs {
   int f1(int x) {
     switch (x) default: pr6884_abort_struct();
   }
   int f2(int x) {
     switch (x) { default: pr6884_abort_struct(); }
   }
   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(); } }
   }
   int f4(int x) {
     switch (x) default: L1: L2: case 4: pr6884_abort_struct();
   }
   int f5(int x) {
     switch (x) default: L1: { L2: case 4: pr6884_abort_struct(); }
   }
   int f6(int x) {
     switch (x) default: L1: L2: case 4: { pr6884_abort_struct(); }
   }
 
   // FIXME: detect noreturn destructors triggered by calls to delete.
   int f7(int x) {
     switch (x) default: L1: L2: case 4: {
       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 g1(int x) {
     other o;
     switch (x) default: pr6884_abort_struct();
   }
   int g2(int x) {
     other o;
     switch (x) { default: pr6884_abort_struct(); }
   }
   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(); } }
   }
   int g4(int x) {
     other o;
     switch (x) default: L1: L2: case 4: pr6884_abort_struct();
   }

 enum PR9412_MatchType { PR9412_Exact };
 
 template <PR9412_MatchType type> int PR9412_t() {
   switch (type) {
     case PR9412_Exact:
     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}}
 }
 
 struct NoReturn {
   ~NoReturn() __attribute__((noreturn));
   operator bool() const;
 };
 struct Return {
   ~Return();
   operator bool() const;
 };
 
 int testTernaryUnconditionalNoreturn() {
   true ? NoReturn() : NoReturn();
 }
 
 int testTernaryStaticallyConditionalNoretrunOnTrue() {
   true ? NoReturn() : Return();
 }
 
 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 does not return a value in all control paths}}
 
 int testTernaryConditionalNoreturnFalseBranch(bool value) {
   value ? Return() : (NoReturn() || NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int testConditionallyExecutedComplexTernaryTrueBranch(bool value) {
   value || (true ? NoReturn() : true);
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int testConditionallyExecutedComplexTernaryFalseBranch(bool value) {
   value || (false ? true : NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int testStaticallyExecutedLogicalOrBranch() {
   false || NoReturn();
 }
 
 int testStaticallyExecutedLogicalAndBranch() {
   true && 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 does not return a value in all control paths}}
 
 int testConditionallyExecutedComplexLogicalBranch2(bool value) {
   (true && value) || (true && NoReturn());
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int testConditionallyExecutedComplexLogicalBranch3(bool value) {
   (false && (Return() || true)) || (true && NoReturn());
 }
 
 int testConditionallyExecutedComplexLogicalBranch4(bool value) {
   false || ((Return() || true) && (true && NoReturn()));
 }
 
 #if __cplusplus >= 201103L
 namespace LambdaVsTemporaryDtor {
   struct Y { ~Y(); };
   struct X { template<typename T> X(T, Y = Y()) {} };
 
   struct Fatal { ~Fatal() __attribute__((noreturn)); };
   struct FatalCopy { FatalCopy(); FatalCopy(const FatalCopy&, Fatal F = Fatal()); };
 
   void foo();
 
   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;
     X work([fc](){});
     foo();
   } // ok, initialization of lambda does not return
 }
 #endif
 
 // Ensure that function-try-blocks also check for return values properly.
 int functionTryBlock1(int s) try {
   return 0;
 } catch (...) {
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int functionTryBlock2(int s) try {
 } catch (...) {
   return 0;
-} // expected-warning {{control may reach end of non-void function}}
+} // expected-warning {{non-void function does not return a value in all control paths}}
 
 int functionTryBlock3(int s) try {
   return 0;
 } catch (...) {
   return 0;
 } // ok, both paths return.

clang/test/SemaCXX/warn-missing-noreturn.cpp

 // <rdar://problem/8875247> - Properly handle CFGs with destructors.
 struct rdar8875247 {
   ~rdar8875247 ();
 };
 void rdar8875247_aux();
 
 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();
   ~rdar8875247_B();
 };
 
 rdar8875247_B test_rdar8875247_B() {
   rdar8875247_B f;

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

 template <typename _Visitor>
 constexpr void visit(_Visitor __visitor) {
   __visitor(get()); // expected-note {{in instantiation}}
 }
 class ArrayBuffer {
   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
 template <typename Promise> struct coroutine_handle {
   Promise &promise() const { return
     *static_cast<Promise *>(nullptr); // expected-warning {{binding dereferenced null}}
   }
 };