[PATCH] c++/coroutines: correct passing *this to promise type

[Patrick Palka]

Tested on x86_64-pc-linux-gnu, does this look OK for trunk
and perhaps backports?

-- >8 --

When passing *this to the promise type ctor (or operator new) (as
per [dcl.fct.def.coroutine]/4), we add an explicit cast to lvalue
reference, but that's unnecessary since *this is already an lvalue.
And it'd mean we'd have to call convert_from_reference afterwards to
lower the reference-yielding expression into an implicit dereference,
otherwise overload resolution gets confused when computing argument
conversions.  So this patch removes the unnecessary reference cast when
passing *this to the promise ctor, and removes both the cast and
implicit deref when passing *this to operator new, for consistency.

	PR c++/104981
	PR c++/115550

gcc/cp/ChangeLog:

	* coroutines.cc (morph_fn_to_coro): Remove unnecessary calls
	to convert_to_reference and convert_from_reference for *this.

gcc/testsuite/ChangeLog:

	* g++.dg/coroutines/pr104981-preview-this.C: New test.
	* g++.dg/coroutines/pr115550-preview-this.C: New test.
---
 gcc/cp/coroutines.cc                          | 10 +---
 .../g++.dg/coroutines/pr104981-preview-this.C | 34 ++++++++++++++
 .../g++.dg/coroutines/pr115550-preview-this.C | 47 +++++++++++++++++++
 3 files changed, 82 insertions(+), 9 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/coroutines/pr104981-preview-this.C
 create mode 100644 gcc/testsuite/g++.dg/coroutines/pr115550-preview-this.C

diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
index f350fc33e9b..b8a53182c38 100644
--- a/gcc/cp/coroutines.cc
+++ b/gcc/cp/coroutines.cc
@@ -4622,11 +4622,7 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer)
 	      /* We pass a reference to *this to the allocator lookup.  */
 	      tree tt = TREE_TYPE (TREE_TYPE (arg));
 	      tree this_ref = build1 (INDIRECT_REF, tt, arg);
-	      tt = cp_build_reference_type (tt, false);
-	      this_ref = convert_to_reference (tt, this_ref, CONV_STATIC,
-					       LOOKUP_NORMAL , NULL_TREE,
-					       tf_warning_or_error);
-	      vec_safe_push (args, convert_from_reference (this_ref));
+	      vec_safe_push (args, this_ref);
 	    }
 	  else
 	    vec_safe_push (args, convert_from_reference (arg));
@@ -4849,10 +4845,6 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer)
 	      gcc_checking_assert (POINTER_TYPE_P (tt));
 	      tree ct = TREE_TYPE (tt);
 	      tree this_ref = build1 (INDIRECT_REF, ct, arg);
-	      tree rt = cp_build_reference_type (ct, false);
-	      this_ref = convert_to_reference (rt, this_ref, CONV_STATIC,
-					       LOOKUP_NORMAL, NULL_TREE,
-					       tf_warning_or_error);
 	      vec_safe_push (promise_args, this_ref);
 	    }
 	  else if (parm.rv_ref)
diff --git a/gcc/testsuite/g++.dg/coroutines/pr104981-preview-this.C b/gcc/testsuite/g++.dg/coroutines/pr104981-preview-this.C
new file mode 100644
index 00000000000..81eb963db4a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr104981-preview-this.C
@@ -0,0 +1,34 @@
+// PR c++/104981 - ICE from convert_to_base when passing *this to promise ctor
+
+#include <coroutine>
+
+class Base {};
+
+struct PromiseType;
+
+struct Result {
+ using promise_type = PromiseType;
+};
+
+struct PromiseType {
+  PromiseType(const Base& parser, auto&&...) {}
+
+  Result get_return_object() { return {}; }
+
+  static std::suspend_never initial_suspend() { return {}; }
+  static std::suspend_always final_suspend() noexcept { return {}; }
+  [[noreturn]] static void unhandled_exception() { throw; }
+
+  void return_value(int) {}
+};
+
+struct Derived : Base {
+  Result f() {
+   co_return 42;
+  }
+};
+
+int main() {
+  Derived d;
+  d.f();
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/pr115550-preview-this.C b/gcc/testsuite/g++.dg/coroutines/pr115550-preview-this.C
new file mode 100644
index 00000000000..f62c07096b6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr115550-preview-this.C
@@ -0,0 +1,47 @@
+// PR c++/115550 - wrong deduction when passing *this to promise ctor template
+
+#include <coroutine>
+
+template <typename T> struct remove_reference { using type = T; };
+template <typename T> struct remove_reference<T&> { using type = T; };
+template <typename T> struct remove_reference<T&&> { using type = T; };
+template <typename T> using remove_reference_t = remove_reference<T>::type;
+
+template <typename, typename>
+struct is_same { static inline constexpr bool value = false; };
+template <typename T>
+struct is_same<T, T> { static inline constexpr bool value = true; };
+
+template <typename T, typename U>
+concept same_as = is_same<T, U>::value;
+
+struct coroutine
+{
+    struct promise_type
+    {
+        template <typename Arg>
+        explicit promise_type(Arg&&)
+        {
+            static_assert(same_as<
+                remove_reference_t<remove_reference_t<Arg>>,
+                remove_reference_t<Arg>
+            >);
+        }
+
+        coroutine get_return_object() { return {}; }
+
+        std::suspend_never initial_suspend() noexcept { return {}; }
+        std::suspend_never final_suspend() noexcept { return {}; }
+
+        void return_void() {}
+        void unhandled_exception() {throw;}
+    };
+};
+
+struct x
+{
+    coroutine f()
+    {
+        co_return;
+    }
+};
-- 
2.46.0.rc0.106.g1c4a234a1c