[Coroutines] Do not evaluate InitListExpr of a co_return

[junparser]

Summary

This simple patch fixes the assertion which happens in ScalarExprEmitter::VisitInitListExpr when we try to compute the expression and ignore the result.

the test case here is reduced by c-reduce.

TestPlan: check-clang

[modocache]

Awesome, thank you! This is an issue I've been running into as well in an internal codebase, I'll check whether this patch addresses it.

My suspicion is that the test case could be reduced further, but the implementation itself seems like a straightforward improvement to me.

clang/lib/CodeGen/CGCoroutine.cpp

278–280

Nice. And it looks like such a check also exists in SemaCoroutine.cpp, added in D25296.

280

nit-pick: I slightly prefer "initializer list" over "initlist", but it's your call.

clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp

87

I'm surprised this is the smallest creduce is capable of reducing this test case. This seems like the most important line, since it co_returns an initializer list. My suspicion is that this test case could be reduced further. Certainly the coroutine_traits and definition of the awaitable type l::m would need to remain, but do the functions below this line need to exist?

I also feel creduce's typedefs, such as template <typename = void> using i = std::experimental::coroutine_handle<>, make this example more confusing. They reduce character count, but std::experimental::coroutine_handle is a common type in C++ coroutines code, whereas i is not necessarily.

[junparser]

@modocache thanks.

clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp

87

I try to remove the functions below which makes the case can not address this issue. So for this case, I'll try to simplify it as far as i can.

[junparser]

simplify the testcase

clang/lib/CodeGen/CGCoroutine.cpp

RValue CodeGenFunction::EmitCoyieldExpr(const CoyieldExpr &E,
                                         bool ignoreResult) {
   return emitSuspendExpression(*this, *CurCoro.Data, E, AwaitKind::Yield,
                                aggSlot, ignoreResult, /*forLValue*/false).RV;
 }
 
 void CodeGenFunction::EmitCoreturnStmt(CoreturnStmt const &S) {
   ++CurCoro.Data->CoreturnCount;
   const Expr *RV = S.getOperand();
-  if (RV && RV->getType()->isVoidType()) {
-    // Make sure to evaluate the expression of a co_return with a void
-    // expression for side effects.
+  if (RV && RV->getType()->isVoidType() && !isa<InitListExpr>(RV)) {
+    // Make sure to evaluate the non initlist expression of a co_return
+    // with a void expression for side effects.
     RunCleanupsScope cleanupScope(*this);
     EmitIgnoredExpr(RV);
   }
   EmitStmt(S.getPromiseCall());
   EmitBranchThroughCleanup(CurCoro.Data->FinalJD);
 }
 
 

clang/test/CodeGenCoroutines/coro-return-voidtype-initlist.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++1z -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s
+
+namespace std {
+template <typename a>
+struct b { b(int, a); };
+template <typename, typename = int>
+struct c {};
+namespace experimental {
+template <typename d>
+struct coroutine_traits : d {};
+template <typename = void>
+struct coroutine_handle;
+template <>
+struct coroutine_handle<> {};
+template <typename>
+struct coroutine_handle : coroutine_handle<> {
+  static coroutine_handle from_address(void *);
+};
+struct e {
+  int await_ready();
+  void await_suspend(coroutine_handle<>);
+  void await_resume();
+};
+} // namespace experimental
+} // namespace std
+template <typename ag>
+auto ah(ag) { return ag().ah(0); }
+template <typename>
+struct f;
+struct g {
+  struct h {
+    int await_ready();
+    template <typename al>
+    void await_suspend(std::experimental::coroutine_handle<al>);
+    void await_resume();
+  };
+  std::experimental::e initial_suspend();
+  h final_suspend();
+  template <typename ag>
+  auto await_transform(ag) { return ah(ag()); }
+};
+struct j : g {
+  f<std::b<std::c<int, int>>> get_return_object();
+  void return_value(std::b<std::c<int, int>>);
+  void unhandled_exception();
+};
+struct k {
+  k(std::experimental::coroutine_handle<>);
+  int await_ready();
+};
+template <typename am>
+struct f {
+  using promise_type = j;
+  std::experimental::coroutine_handle<> ar;
+  struct l : k {
+    using at = k;
+    l(std::experimental::coroutine_handle<> m) : at(m) {}
+    void await_suspend(std::experimental::coroutine_handle<>);
+  };
+  struct n : l {
+    n(std::experimental::coroutine_handle<> m) : l(m) {}
+    am await_resume();
+  };
+  auto ah(int) { return n(ar); }
+};
+template <typename am, typename av, typename aw>
+auto ax(std::c<am, av>, aw) -> f<std::c<int, aw>>;
+template <typename>
+struct J { static f<std::b<std::c<int, int>>> bo(); };
+// CHECK-LABEL: _ZN1JIiE2boEv(
+template <typename bc>
+f<std::b<std::c<int, int>>> J<bc>::bo() {
+  std::c<int> bu;
+  int bw(0);
+  // CHECK: void @_ZN1j12return_valueESt1bISt1cIiiEE(%struct.j* %__promise)
+  co_return{0, co_await ax(bu, bw)};
+}
+void bh() {
+  auto cn = [] { J<int>::bo; };
+  cn();
+}