[Coroutines] Fix a few failing tests

[lxfind]

Summary

https://reviews.llvm.org/D82029 introduced the non-throw check for final_suspend(). There are a few tests I missed in that patch.
Fixing them here.

[lxfind]

Address lint message

[lxfind]

Rebase. Fix two more tests.

libcxx/test/libcxx/experimental/language.support/support.coroutines/dialect_support.pass.cpp

 
 coro::suspend_always sa;
 coro::suspend_never sn;
 
 struct MyFuture {
   struct promise_type {
     typedef coro::coroutine_handle<promise_type> HandleT;
     coro::suspend_never initial_suspend() { return sn; }
-    coro::suspend_always final_suspend() { return sa; }
+    coro::suspend_always final_suspend() noexcept { return sa; }
     coro::suspend_never yield_value(int) { return sn; }
     MyFuture get_return_object() {
       MyFuture f(HandleT::from_promise(*this));
       return f;
     }
     void return_void() {}
     void unhandled_exception() {}
   };

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp

 
 namespace coro = std::experimental;
 
 struct MyCoro {
   struct promise_type {
     void unhandled_exception() {}
     void return_void() {}
     coro::suspend_never initial_suspend() { return {}; }
-    coro::suspend_never final_suspend() { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
     MyCoro get_return_object() {
       do_runtime_test();
       return {};
     }
     void do_runtime_test() {
       // Test that a coroutine_handle<const T> can be created from a const
       // promise_type and that it represents the same coroutine as
       // coroutine_handle<T>

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/await_result.pass.cpp

 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() {
       coroutine_handle<promise_type>{};
       return {};
     }
     suspend_never initial_suspend() { return {}; }
-    suspend_never final_suspend() { return {}; }
+    suspend_never final_suspend() noexcept { return {}; }
     void return_void() {}
     static void unhandled_exception() {}
   };
 };
 
 struct B {
   ~B() {}
   bool await_ready() { return true; }

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp

 using namespace std::experimental;
 
 struct coro_t {
   struct promise_type {
     coro_t get_return_object() {
       return coroutine_handle<promise_type>::from_promise(*this);
     }
     suspend_never initial_suspend() { return {}; }
-    suspend_never final_suspend() { return {}; }
+    suspend_never final_suspend() noexcept { return {}; }
     void return_void() {}
     void unhandled_exception() {}
   };
   coro_t(coroutine_handle<promise_type> hh) : h(hh) {}
   coroutine_handle<promise_type> h;
 };
 
 struct NoSuspend {

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp

struct expected {
   expected(T val) : data{std::move(val),{}} {}
   expected(struct error, Error error) : data{{}, std::move(error)} {}
   expected(DataPtr & p) : data{std::move(p.p->val), std::move(p.p->error)} {}
 
   struct promise_type {
     Data* data;
     DataPtr get_return_object() { data = new Data{}; return {data}; }
     suspend_never initial_suspend() { return {}; }
-    suspend_never final_suspend() { return {}; }
+    suspend_never final_suspend() noexcept { return {}; }
     void return_value(T v) { data->val = std::move(v); data->error = {};}
     void unhandled_exception() {}
   };
 
   bool await_ready() { return !data.error; }
   T await_resume() { return std::move(data.val); }
   void await_suspend(coroutine_handle<promise_type> h) {
     h.promise().data->error =std::move(data.error);

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp

 struct Bug {
   bool await_ready() { return true; }
   void await_suspend(std::experimental::coroutine_handle<>) {}
   Noisy await_resume() { return {}; }
 };
 struct coro2 {
   struct promise_type {
     suspend_never initial_suspend() { return{}; }
-    suspend_never final_suspend() { return{}; }
+    suspend_never final_suspend() noexcept { return{}; }
     coro2 get_return_object() { return{}; }
     void return_void() {}
     Bug yield_value(int) { return {}; }
     void unhandled_exception() {}
   };
 };
 
 // Checks that destructors are correctly invoked for the object returned by

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp

 struct minig {
   struct promise_type {
     int current_value;
     suspend_always yield_value(int value) {
       this->current_value = value;
       return {};
     }
     suspend_always initial_suspend() { return {}; }
-    suspend_always final_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
     minig get_return_object() { return minig{this}; };
     void return_void() {}
     void unhandled_exception() {}
   };
 
   bool move_next() {
     p.resume();
     return !p.done();

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/go.pass.cpp

static void run_one()
     stack[--count]();
   }
 
   struct promise_type
   {
     suspend_never initial_suspend() {
       return {};
     }
-    suspend_never final_suspend() {
+    suspend_never final_suspend() noexcept {
       return {};
     }
     void return_void() {}
     goroutine get_return_object() {
       return{};
     }
     void unhandled_exception() {}
   };