[clang] Adjust coroutine namespace diagnostics]

[urnathan]

Summary

The diagnostics concerning mixing std::experimental and std are somewhat wordy and have some typographical errors. Diagnostics do not start with a capital letter nor end with a fullstop. Usually we try and link clauses with a semicolon, rather than start a new sentence. So that's what this patch does. Along with avoiding repetition about std::experimental going away.

[• Quuxplusone]

LGTM!

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_coroutine_invalid_func_context : Error<
   "|the 'main' function|a constexpr function"
   "|a function with a deduced return type|a varargs function"
   "|a consteval function}0">;
 def err_implied_coroutine_type_not_found : Error<
   "%0 type was not found; include <coroutine> before defining "
   "a coroutine; include <experimental/coroutine> if your version "
   "of libcxx is less than 14.0">;
 def warn_deprecated_coroutine_namespace : Warning<
-  "Please move from std::experimental::%0 to std::%0. "
-  "Support for std::experimental::%0 will be removed in LLVM 15.">,
+  "support for std::experimental::%0 will be removed in LLVM 15; "
+  "use std::%0 instead">,
   InGroup<DeprecatedExperimentalCoroutine>;
-def err_mixed_use_std_and_experimental_namespace_for_coroutine : Error <
-  "Found mixed use of std namespace and std::experimental namespace for "
-  "coroutine, which is disallowed. The coroutine components in "
-  "std::experimental namespace is deprecated. Please use coroutine components "
-  "under std namespace.">;
+def err_mixed_use_std_and_experimental_namespace_for_coroutine : Error<
+  "mixed use of std and std::experimental namespaces for "
+  "coroutine components">;
 def err_implicit_coroutine_std_nothrow_type_not_found : Error<
   "std::nothrow was not found; include <new> before defining a coroutine which "
   "uses get_return_object_on_allocation_failure()">;
 def err_malformed_std_nothrow : Error<
   "std::nothrow must be a valid variable declaration">;
 def err_malformed_std_coroutine_handle : Error<
   "std::coroutine_handle isn't a class template">;
 def err_coroutine_handle_missing_member : Error<

clang/lib/Sema/SemaCoroutine.cpp

if (!CoroNamespace || !LookupQualifiedName(Result, CoroNamespace)) {
       /// misleading definition in std::experimental namespace.
       NamespaceDecl *ExpNamespace = lookupStdExperimentalNamespace();
       LookupResult ExpResult(*this,
                              &PP.getIdentifierTable().get("coroutine_traits"),
                              FuncLoc, LookupOrdinaryName);
       if (ExpNamespace && LookupQualifiedName(ExpResult, ExpNamespace)) {
         Diag(KwLoc,
              diag::err_mixed_use_std_and_experimental_namespace_for_coroutine);
+        Diag(KwLoc, diag::warn_deprecated_coroutine_namespace)
+            << "coroutine_traits";
         return nullptr;
       }
     }
 
     if (!(StdCoroutineTraitsCache = Result.getAsSingle<ClassTemplateDecl>())) {
       Result.suppressDiagnostics();
       NamedDecl *Found = *Result.begin();
       Diag(Found->getLocation(), diag::err_malformed_std_coroutine_traits);
       return nullptr;
     }
     CoroTraitsNamespaceCache = CoroNamespace;
   }
   Namespace = CoroTraitsNamespaceCache;
   return StdCoroutineTraitsCache;
 }

clang/test/SemaCXX/co_await-range-for-exp-namespace.cpp

struct promise_type {
     suspend_never initial_suspend();
     suspend_never final_suspend() noexcept;
     template <class T>
     Awaiter<T *> await_transform(T *) = delete; // expected-note {{explicitly deleted}}
   };
 };
 MyForLoopArrayAwaiter g() {
   int arr[10] = {0};
-  for co_await (auto i : arr) {} // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+  for co_await (auto i : arr) {} // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
   // expected-error@-1 {{call to deleted member function 'await_transform'}}
   // expected-note@-2 {{'await_transform' implicitly required by 'co_await' here}}
 }
 
 struct ForLoopAwaiterBadBeginTransform {
   struct promise_type {
     ForLoopAwaiterBadBeginTransform get_return_object();
     void return_void();

clang/test/SemaCXX/coreturn-eh-exp-namespace.cpp

 };
 
 template <typename T1>
 struct std::experimental::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
 
 VoidTagReturnValue test() {
   object x = {};
   try {
-    co_return {}; // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+    co_return {}; // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
   } catch (...) {
     throw;
   }
 }

clang/test/SemaCXX/coreturn-exp-namespace.cpp

 struct std::experimental::coroutine_traits<void, T1> { using promise_type = promise_void_return_value; };
 
 template <typename... T>
 struct std::experimental::coroutine_traits<float, T...> { using promise_type = promise_float; };
 
 template <typename... T>
 struct std::experimental::coroutine_traits<int, T...> { using promise_type = promise_int; };
 
-void test0() { co_await a; } // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+void test0() { co_await a; } // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
 float test1() { co_await a; }
 
 int test2() {
   co_await a;
 } // expected-warning {{non-void coroutine does not return a value}}
 
 int test2a(bool b) {
   if (b)

clang/test/SemaCXX/coroutine-final-suspend-noexcept-exp-namespace.cpp

struct promise_type {
     std::experimental::suspend_always final_suspend(); // expected-note 2 {{must be declared with 'noexcept'}}
     void return_void();
     static void unhandled_exception();
   };
 };
 
 coro_t f(int n) { // expected-error {{the expression 'co_await __promise.final_suspend()' is required to be non-throwing}}
   A a{};
-  co_await a; // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+  co_await a; // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
 }
 
 template <typename T>
 coro_t f_dep(T n) { // expected-error {{the expression 'co_await __promise.final_suspend()' is required to be non-throwing}}
   A a{};
   co_await a;
 }
 
 void foo() {
   f_dep<int>(5); // expected-note {{in instantiation of function template specialization 'f_dep<int>' requested here}}
 }

clang/test/SemaCXX/coroutine-mixed-exp-namespace.cpp

 // This file is to test the mixed use of `std::experimental::coroutine*` and `std::coroutine*`
-// wouldn't make the compliler to crash and emit the diagnostic message correctly.
+// wouldn't make the compiler to crash and emit the diagnostic message correctly.
 // RUN: %clang_cc1 -verify -std=c++20 -fsyntax-only %s
 
 #include "Inputs/std-coroutine-exp-namespace.h"
 #include "Inputs/std-coroutine.h"
 
 struct my_awaitable {
   bool await_ready() noexcept;
   void await_suspend(std::experimental::coroutine_handle<> coro) noexcept;
   void await_resume() noexcept;
 };
 
 struct promise_void {
   void get_return_object();
   my_awaitable initial_suspend();
   my_awaitable final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
 
 template <>
 struct std::coroutine_traits<void> { using promise_type = promise_void; };
 
 void test() {
-  co_return; // expected-error {{Found mixed use of std namespace and std::experimental namespace for coroutine, which is disallowed. The coroutine components in std::experimental namespace is deprecated. Please use coroutine components under std namespace.}}
+  co_return; // expected-error {{mixed use of std and std::experimental namespaces for coroutine components}}
+  // expected-warning@-1{{support for std::experimental::coroutine_traits will be removed}}
 }

clang/test/SemaCXX/coroutine-mixed2-exp-namespace.cpp

struct promise_void {
   void return_void();
   void unhandled_exception();
 };
 
 template <>
 struct std::coroutine_traits<void> { using promise_type = promise_void; };
 
 void test() {
-  co_return; // expected-error {{Found mixed use of std namespace and std::experimental namespace for coroutine, which is disallowed. The coroutine components in std::experimental namespace is deprecated. Please use coroutine components under std namespace.}}
+  co_return; // expected-error {{mixed use of std and std::experimental namespaces for coroutine components}}
+  // expected-warning@-1{{support for std::experimental::coroutine_traits will be removed}}
 }

clang/test/SemaCXX/coroutine-rvo-exp-namespace.cpp

struct promise_type {
     auto get_return_object() { return task{}; }
     static void unhandled_exception() {}
     void return_value(T &&value) {} // expected-note 4{{passing argument}}
   };
 };
 
 task<NoCopyNoMove> local2val() {
   NoCopyNoMove value;
-  co_return value; // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+  co_return value; // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
 }
 
 task<NoCopyNoMove &> local2ref() {
   NoCopyNoMove value;
   co_return value; // expected-error {{non-const lvalue reference to type 'NoCopyNoMove' cannot bind to a temporary of type 'NoCopyNoMove'}}
 }
 
 // We need the move constructor for construction of the coroutine.

clang/test/SemaCXX/coroutine-seh-exp-namespace.cpp

struct promise_type {
     void return_void() noexcept;
     void unhandled_exception() noexcept;
   };
 };
 
 void SEH_used() {
   __try {      // expected-error {{cannot use SEH '__try' in a coroutine when C++ exceptions are enabled}}
     co_return; // expected-note {{function is a coroutine due to use of 'co_return' here}}
-               // expected-warning@-1 {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+               // expected-warning@-1 {{support for std::experimental::coroutine_traits will be removed}}
   } __except (0) {
   }
 }

clang/test/SemaCXX/coroutine-traits-undefined-template-exp-namespace.cpp

 };
 
 template <> struct coroutine_traits<void>; // expected-note {{forward declaration of 'std::experimental::coroutine_traits<void>'}}
 } // namespace experimental
 } // namespace std
 
 void uses_forward_declaration() {
   co_return; // expected-error {{this function cannot be a coroutine: missing definition of specialization 'coroutine_traits<void>'}}
-             // expected-warning@-1 {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+             // expected-warning@-1 {{support for std::experimental::coroutine_traits will be removed}}
 }

clang/test/SemaCXX/coroutine-unhandled_exception-warning-exp-namespace.cpp

#endif
   void return_void();
 };
 
 template <typename... T>
 struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise_void; };
 
 #ifndef DISABLE_WARNING
 void test0() { // expected-warning {{'promise_void' is required to declare the member 'unhandled_exception()' when exceptions are enabled}}
-  co_return;   // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+  co_return;   // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
 }
 #else
 void test0() { // expected-no-diagnostics
   co_return;
 }
 #endif

clang/test/SemaCXX/coroutine_handle-address-return-type-exp-namespace.cpp

struct awaitable {
   bool await_ready();
 
   std::experimental::coroutine_handle<task::promise_type>
   await_suspend(std::experimental::coroutine_handle<> handle);
   void await_resume();
 } a;
 
 task f() {
-  co_await a; // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+  co_await a; // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
 }
 
 int main() {
   f();
   return 0;
 }

clang/test/SemaCXX/coroutines-exp-namespace.cpp

 struct auto_await_suspend {
   bool await_ready();
   template <typename F> auto await_suspend(F) {}
   void await_resume();
 };
 
 struct DummyVoidTag {};
 DummyVoidTag no_specialization() { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<DummyVoidTag>' has no member named 'promise_type'}}
-  co_await a;                      // expected-warning {{Please move from std::experimental::coroutine_traits to std::coroutine_traits}}
+  co_await a;                      // expected-warning {{support for std::experimental::coroutine_traits will be removed}}
 }
 
 template <typename... T>
 struct std::experimental::coroutine_traits<int, T...> {};
 
 int no_promise_type() { // expected-error {{this function cannot be a coroutine: 'std::experimental::coroutine_traits<int>' has no member named 'promise_type'}}
   co_await a;
 }