[coroutines] Fix co_return statement for initializer list arguments

[EricWF]

Summary

Previously the statement co_return {42} would be transformed into P.return_void(), since the type of {42} is represented as void by Clang.

This patch fixes the bug by checking for InitListExpr arguments and transforming them accordingly.

[GorNishanov]

LGTM, but, I cannot approve clang patches. Let's wait on @rsmith to give the go ahead.

lib/Sema/SemaCoroutine.cpp

if (E && E->getType()->isPlaceholderType() &&
     if (R.isInvalid()) return StmtError();
     E = R.get();
   }
 
   // FIXME: If the operand is a reference to a variable that's about to go out
   // of scope, we should treat the operand as an xvalue for this overload
   // resolution.
   ExprResult PC;
-  if (E && !E->getType()->isVoidType()) {
+  if (E && (isa<InitListExpr>(E) || !E->getType()->isVoidType())) {
     PC = buildPromiseCall(*this, Coroutine, Loc, "return_value", E);
   } else {
     E = MakeFullDiscardedValueExpr(E).get();
     PC = buildPromiseCall(*this, Coroutine, Loc, "return_void", None);
   }
   if (PC.isInvalid())
     return StmtError();
 

test/SemaCXX/coroutines.cpp

 struct std::experimental::coroutine_traits<double, int> {
   struct promise_type {};
 };
 double bad_promise_type_2(int) {
   co_yield 0; // expected-error {{no member named 'yield_value' in 'std::experimental::coroutine_traits<double, int>::promise_type'}}
 }
 
 struct promise; // expected-note 2{{forward declaration}}
+struct promise_void;
+struct void_tag {};
 template <typename... T>
 struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise; };
+template <typename... T>
+struct std::experimental::coroutine_traits<void, void_tag, T...>
+{ using promise_type = promise_void; };
 
 namespace std {
 namespace experimental {
 template <typename Promise = void>
 struct coroutine_handle;
 }
 }
 

 
 struct promise {
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend();
   awaitable yield_value(int); // expected-note 2{{candidate}}
   awaitable yield_value(yielded_thing); // expected-note 2{{candidate}}
   not_awaitable yield_value(void()); // expected-note 2{{candidate}}
-  void return_void();
   void return_value(int); // expected-note 2{{here}}
 };
 
+struct promise_void {
+  void get_return_object();
+  suspend_always initial_suspend();
+  suspend_always final_suspend();
+  awaitable yield_value(int);
+  awaitable yield_value(yielded_thing);
+  not_awaitable yield_value(void());
+  void return_void();
+};
+
 void yield() {
   co_yield 0;
   co_yield {"foo", 1, 2};
   co_yield {1e100}; // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{changes value}} expected-warning {{braces around scalar}}
   co_yield {"foo", __LONG_LONG_MAX__}; // expected-error {{cannot be narrowed}} expected-note {{explicit cast}} expected-warning {{changes value}}
   co_yield {"foo"};
   co_yield "foo"; // expected-error {{no matching}}
   co_yield 1.0;
   co_yield yield; // expected-error {{no member named 'await_ready' in 'not_awaitable'}}
 }
 
 void coreturn(int n) {
   co_await a;
   if (n == 0)
     co_return 3;
   if (n == 1)
-    co_return {4};
+    co_return {4}; // expected-warning {{braces around scalar initializer}}
   if (n == 2)
     co_return "foo"; // expected-error {{cannot initialize a parameter of type 'int' with an lvalue of type 'const char [4]'}}
-  co_return;
+  co_return 42;
 }
 
 void mixed_yield() {
   co_yield 0; // expected-note {{use of 'co_yield'}}
   return; // expected-error {{not allowed in coroutine}}
 }
 
 void mixed_await() {
   co_await a; // expected-note {{use of 'co_await'}}
   return; // expected-error {{not allowed in coroutine}}
 }
 
-void only_coreturn() {
+void only_coreturn(void_tag) {
   co_return; // expected-warning {{'co_return' used in a function that uses neither 'co_await' nor 'co_yield'}}
 }
 
-void mixed_coreturn(bool b) {
+void mixed_coreturn(void_tag, bool b) {
   if (b)
     // expected-warning@+1 {{'co_return' used in a function that uses neither}}
     co_return; // expected-note {{use of 'co_return'}}
   else
     return; // expected-error {{not allowed in coroutine}}
 }
 
 struct CtorDtor {