[coroutines] Improved diagnostics when unhandled_exception is missing in the promise_type

[GorNishanov]

Summary

Now we helpfully provide a note pointing at the promise_type in question.

[GorNishanov]

LGTM

lib/Sema/SemaCoroutine.cpp

static QualType lookupPromiseType(Sema &S, const FunctionProtoType *FnType,
   }
   if (S.RequireCompleteType(FuncLoc, buildElaboratedType(),
                             diag::err_coroutine_promise_type_incomplete))
     return QualType();
 
   return PromiseType;
 }
 
-/// Look up the std::coroutine_traits<...>::promise_type for the given
-/// function type.
+/// Look up the std::experimental::coroutine_handle<PromiseType>.
 static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType,
                                           SourceLocation Loc) {
   if (PromiseType.isNull())
     return QualType();
 
   NamespaceDecl *StdExp = S.lookupStdExperimentalNamespace();
   assert(StdExp && "Should already be diagnosed");
 
void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {
 
   if (!Body) {
     assert(FD->isInvalidDecl() &&
            "a null body is only allowed for invalid declarations");
     return;
   }
 
   if (isa<CoroutineBodyStmt>(Body)) {
-    // FIXME(EricWF): Nothing todo. the body is already a transformed coroutine
-    // body statement.
+    // Nothing todo. the body is already a transformed coroutine body statement.
     return;
   }
 
   // Coroutines [stmt.return]p1:
   //   A return statement shall not appear in a coroutine.
   if (Fn->FirstReturnLoc.isValid()) {
     assert(Fn->FirstCoroutineStmtLoc.isValid() &&
                    "first coroutine location not set");
bool CoroutineStmtBuilder::makeOnException() {
 
   if (!lookupMember(S, "unhandled_exception", PromiseRecordDecl, Loc)) {
     auto DiagID =
         RequireUnhandledException
             ? diag::err_coroutine_promise_unhandled_exception_required
             : diag::
                   warn_coroutine_promise_unhandled_exception_required_with_exceptions;
     S.Diag(Loc, DiagID) << PromiseRecordDecl;
+    S.Diag(PromiseRecordDecl->getLocation(), diag::note_defined_here)
+        << PromiseRecordDecl;
     return !RequireUnhandledException;
   }
 
   // If exceptions are disabled, don't try to build OnException.
   if (!S.getLangOpts().CXXExceptions)
     return true;
 
   ExprResult UnhandledException = buildPromiseCall(S, Fn.CoroutinePromise, Loc,

test/SemaCXX/coroutine-unhandled_exception-warning.cpp

 #error This test requires exceptions be disabled
 #endif
 
 #include "Inputs/std-coroutine.h"
 
 using std::experimental::suspend_always;
 using std::experimental::suspend_never;
 
+#ifndef DISABLE_WARNING
+struct promise_void { // expected-note {{defined here}}
+#else
 struct promise_void {
+#endif
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend();
   void return_void();
 };
 
 template <typename... T>
 struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise_void; };

test/SemaCXX/coroutines.cpp

 }
 
 template <class T>
 coro<T> bad_implicit_return_dependent(T) { // expected-error {{'bad_promise_6' declares both 'return_value' and 'return_void'}}
   co_await a;
 }
 template coro<bad_promise_6> bad_implicit_return_dependent(bad_promise_6); // expected-note {{in instantiation}}
 
-struct bad_promise_7 {
+struct bad_promise_7 { // expected-note 2 {{defined here}}
   coro<bad_promise_7> get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend();
   void return_void();
 };
 coro<bad_promise_7> no_unhandled_exception() { // expected-error {{'bad_promise_7' is required to declare the member 'unhandled_exception()'}}
   co_await a;
 }