[coroutines][PR41909] don't build dependent coroutine statements if the coroutine still has a dependent promise type

[blastrock]

Summary

This started with bug https://bugs.llvm.org/show_bug.cgi?id=41909 which was fixed by https://reviews.llvm.org/D62550 . In the last comment of the bug report, Pavel A. Lebedev gives a code snippet that now makes clang trigger an ICE. This code was broken by that very commit.

I am no expert, but I tried to follow this comment. We now build the dependent statements only if the promise type is not dependent anymore. If it still is, I guess dependent statements are built in a later pass when all templates are instantiated.

I have added the second code snippet from the bug and the godbolt snippet from modocache's answer on the review, this patch seems to fix them all.

[modocache]

Great minds think alike! This looks like the patch I sent in November, D70579. I only just committed it two days ago in rG376cf43, but I ought to have updated the bug report. Thanks for pointing this out!

Unfortunately we duplicated some work here, and so I'm not sure this patch is needed.

[blastrock]

Indeed, I'm closing this then, I haven't tested your patch yet but the fix seems to be the exact same. You seem to have a better idea of what you are doing and your patch reflects that ^^

Thanks for the fix!

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
   assert(ReturnObject && "the return object is expected to be valid");
   ExprResult Res = getDerived().TransformInitializer(ReturnObject,
                                                      /*NoCopyInit*/ false);
   if (Res.isInvalid())
     return StmtError();
   Builder.ReturnValue = Res.get();
 
   if (S->hasDependentPromiseType()) {
-    // PR41909: We may find a generic coroutine lambda definition within a
-    // template function that is being instantiated. In this case, the lambda
-    // will have a dependent promise type, until it is used in an expression
-    // that creates an instantiation with a non-dependent promise type. We
-    // should not assert or build coroutine dependent statements for such a
-    // generic lambda.
-    auto *MD = dyn_cast_or_null<CXXMethodDecl>(FD);
-    if (!MD || !MD->getParent()->isGenericLambda()) {
-      assert(!Promise->getType()->isDependentType() &&
-             "the promise type must no longer be dependent");
+    if (!Promise->getType()->isDependentType()) {
       assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
              !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
              "these nodes should not have been built yet");
       if (!Builder.buildDependentStatements())
         return StmtError();
     }
   } else {
     if (auto *OnFallthrough = S->getFallthroughHandler()) {

clang/test/SemaCXX/coroutines.cpp

[](auto& arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
     co_await 12;
   };
   [](auto &arg) -> coro<good_promise_1> {
     co_await 24;
   }("argument");
 }
 template void ok_generic_lambda_coawait_PR41909<int>(); // expected-note {{in instantiation of function template specialization 'ok_generic_lambda_coawait_PR41909<int>' requested here}}
 
+void ok_generic_lambda_coawait_PR41909_2() {
+  [](auto &arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
+    co_await 12;
+  };
+  [](auto &arg) -> coro<good_promise_1> {
+    co_await 24;
+  }("argument");
+}
+
+template <typename T>
+void ok_generic_lambda_coawait_PR41909_3() {
+  [](auto &arg) -> coro<good_promise_1> { // expected-warning {{expression result unused}}
+    []() -> coro<good_promise_1> {
+      co_await 12;
+    };
+    co_await 24;
+  };
+}
+template void ok_generic_lambda_coawait_PR41909_3<int>(); // expected-note {{in instantiation of function template specialization 'ok_generic_lambda_coawait_PR41909_3<int>' requested here}}
+
 template<> struct std::experimental::coroutine_traits<int, int, const char**>
 { using promise_type = promise; };
 
 int main(int, const char**) {
   co_await a; // expected-error {{'co_await' cannot be used in the 'main' function}}
 }
 
 struct good_promise_2 {