[coroutines] Make sure auto return type of await_resume is properly handled

[rsmith]

lib/Sema/SemaCoroutine.cpp

451 ↗

(On Diff #113798)

Don't desugar the type; instead, use AdjRetType->isBooleanType() || AdjRetType->isVoidType() here. You can also delete the getUnqualifiedType() call above if you do this, and just use RetType here, since ->isBooleanType() on const bool returns true.

[GorNishanov]

use isVoidType() and isBooleantType() instead of cruft that used to be there before

[GorNishanov]

lib/Sema/SemaCoroutine.cpp

451 ↗

(On Diff #113798)

Cool! Much shorter and prettier. Thank you!

[javed.absar]

test/SemaCXX/coroutines.cpp

169 ↗

(On Diff #113800)

maybe change the comment to something more meaningful, or remove it.

[GorNishanov]

test/SemaCXX/coroutines.cpp

169 ↗

(On Diff #113800)

Sure thing. I'll remove the comment.

cfe/trunk/lib/Sema/SemaCoroutine.cpp

if (!AwaitReady->getType()->isDependentType()) {
     Calls.Results[ACT::ACT_Ready] = Conv.get();
   }
   CallExpr *AwaitSuspend = cast<CallExpr>(Calls.Results[ACT::ACT_Suspend]);
   if (!AwaitSuspend->getType()->isDependentType()) {
     // [expr.await]p3 [...]
     //   - await-suspend is the expression e.await_suspend(h), which shall be
     //     a prvalue of type void or bool.
     QualType RetType = AwaitSuspend->getCallReturnType(S.Context);
+
     // Experimental support for coroutine_handle returning await_suspend.
     if (Expr *TailCallSuspend = maybeTailCall(S, RetType, AwaitSuspend, Loc))
       Calls.Results[ACT::ACT_Suspend] = TailCallSuspend;
     else {
       // non-class prvalues always have cv-unqualified types
-      QualType AdjRetType = RetType.getUnqualifiedType();
       if (RetType->isReferenceType() ||
-          (AdjRetType != S.Context.BoolTy && AdjRetType != S.Context.VoidTy)) {
+          (!RetType->isBooleanType() && !RetType->isVoidType())) {
         S.Diag(AwaitSuspend->getCalleeDecl()->getLocation(),
                diag::err_await_suspend_invalid_return_type)
             << RetType;
         S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
             << AwaitSuspend->getDirectCallee();
         Calls.IsInvalid = true;
       }
     }

cfe/trunk/test/SemaCXX/coroutines.cpp

 };
 
 struct suspend_never {
   bool await_ready() { return true; }
   template <typename F> void await_suspend(F);
   void await_resume() {}
 };
 
+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;
 }
 
 template <typename... T>
 struct std::experimental::coroutine_traits<int, T...> {};
 
void yield() {
   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 check_auto_await_suspend() {
+  co_await auto_await_suspend{}; // Should compile successfully.
+}
+
 void coreturn(int n) {
   co_await a;
   if (n == 0)
     co_return 3;
   if (n == 1)
     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]'}}