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

[rsmith]

lib/Sema/SemaCoroutine.cpp

451

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

Cool! Much shorter and prettier. Thank you!

[javed.absar]

test/SemaCXX/coroutines.cpp

169

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

[GorNishanov]

test/SemaCXX/coroutines.cpp

169

Sure thing. I'll remove the comment.

lib/Sema/SemaCoroutine.cpp

if (!AwaitSuspend->getType()->isDependentType()) {
     //     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 (auto *AT = dyn_cast<AutoType>(AdjRetType))
+        AdjRetType = AT->desugar();
+
       if (RetType->isReferenceType() ||
           (AdjRetType != S.Context.BoolTy && AdjRetType != S.Context.VoidTy)) {
         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;
       }
     }

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{}; // OK
+}
+
 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]'}}