Convert a hash variant on the way out through a declared return type

A method's C return type comes from its --rbs signature; the expression it
answers is typed from observed dataflow. The hash variants are separate C
structs, so where ivar writes widen one past what the signature declares,
the return handed back an sp_PolyPolyHash * through an sp_StrPolyHash *
signature and the build stopped.

Nothing in such a program is wrong. The signature is a true description of
what the method answers, the widening is spinel's own, and there is no way
to write the RBS that avoids it short of dropping the declaration.

The assignment side has made this conversion since #4089, through the boxed
form the converting entries take. The return side is the same crossing and
gets the same conversion.

Fixes #4095

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: matz

Makefile

@@ -593,6 +593,12 @@ rbs-seed-test: $(SPINEL) $(RBS_EXTRACT_BIN) $(SP_RT_LIB)
 	  "$$tmp/cp" > "$$tmp/cp.out" 2>/dev/null; \
 	  cmp -s "$$tmp/cp.out" test/rbs-seed/colliding_class_pin.expected || { echo "rbs-seed-test: FAIL (colliding_class_pin output mismatch)"; diff -u test/rbs-seed/colliding_class_pin.expected "$$tmp/cp.out" || true; ok=0; }; \
 	else echo "rbs-seed-test: FAIL (colliding_class_pin C did not compile)"; ok=0; fi; \
+	$(SPINEL) test/rbs-seed/return_hash_variant.rb --rbs test/rbs-seed/sig \
+	  -c --no-line-map -o "$$tmp/rh.c" 2>/dev/null; \
+	if $(CC) -O0 -Ilib $(RBS_SEED_STRICT) "$$tmp/rh.c" $(SP_RT_LIB) $(LDFLAGS) -lm -o "$$tmp/rh" 2>"$$tmp/rh.err"; then \
+	  "$$tmp/rh" > "$$tmp/rh.out" 2>/dev/null; \
+	  cmp -s "$$tmp/rh.out" test/rbs-seed/return_hash_variant.expected || { echo "rbs-seed-test: FAIL (#4095 declared-return hash variant output mismatch)"; diff -u test/rbs-seed/return_hash_variant.expected "$$tmp/rh.out" || true; ok=0; }; \
+	else echo "rbs-seed-test: FAIL (#4095 declared-return hash variant C did not compile)"; ok=0; fi; \
 	$(SPINEL) test/rbs-seed/writer_poly_narrowing.rb --rbs test/rbs-seed/sig \
 	  -c --no-line-map -o "$$tmp/wp.c" 2>/dev/null; \
 	if $(CC) -O0 -Ilib $(RBS_SEED_STRICT) "$$tmp/wp.c" $(SP_RT_LIB) $(LDFLAGS) -lm -o "$$tmp/wp" 2>"$$tmp/wp.err"; then \

src/codegen_stmt.c

@@ -4856,6 +4856,23 @@ static void emit_tail_value(Compiler *c, int node, Buf *b) {
       return;
     }
   }
+  /* A hash variant the body answers where the signature declares another one:
+     the variants are separate C structs, so the pointer went back uncoerced
+     and the build stopped. An --rbs return type is the usual way the two come
+     apart -- the signature is a true description of the method while the ivar
+     writes widened its variant -- and the conversion is the one the assignment
+     side already makes (#4089), through the boxed form the converting entries
+     take. */
+  if (ty_is_hash(g_ret_type) && ty_is_hash(comp_ntype(c, node)) &&
+      g_ret_type != comp_ntype(c, node) &&
+      (g_ret_type == TY_POLY_POLY_HASH || g_ret_type == TY_SYM_POLY_HASH ||
+       g_ret_type == TY_STR_POLY_HASH)) {
+    const char *hconv = g_ret_type == TY_POLY_POLY_HASH ? "sp_poly_as_poly_poly_hash"
+                      : g_ret_type == TY_SYM_POLY_HASH  ? "sp_poly_as_sym_poly_hash"
+                      : "sp_poly_as_str_poly_hash";
+    buf_printf(b, "%s(", hconv); emit_boxed(c, node, b); buf_puts(b, ")");
+    return;
+  }
   /* A bare `nil` returned through an int or float slot. emit_expr renders
      NilNode as the numeric default 0, which in those two slots is a real
      value -- the caller reads 0 / 0.0 where the method said nil. Both have a

test/rbs-seed/return_hash_variant.expected

@@ -0,0 +1,4 @@
+{"a" => "b"}
+{"a" => "b", "c" => "d"}
+{}
+{a: 1}

test/rbs-seed/return_hash_variant.rb

@@ -0,0 +1,38 @@
+# A method's C return type comes from its --rbs signature while the expression
+# it answers is typed from observed dataflow. Where ivar writes widen a hash
+# past the signature's variant the two are separate C structs, and the return
+# went back uncoerced (#4095). The assignment side already made this
+# conversion; the return side did not.
+class Jar
+  def initialize(inbound = {})
+    @inbound = {}
+    @out = {}
+    inbound.each { |k, v| @inbound[k.to_s] = v }
+  end
+
+  def to_h
+    @inbound.merge(@out)
+  end
+
+  def add(k, v)
+    @out[k] = v
+    self
+  end
+end
+
+p Jar.new({ "a" => "b" }).to_h
+p Jar.new({ "a" => "b" }).add("c", "d").to_h
+p Jar.new.to_h
+
+class SymJar
+  def initialize
+    @h = {}
+    [[:a, 1]].each { |k, v| @h[k] = v }
+  end
+
+  def to_h
+    @h
+  end
+end
+
+p SymJar.new.to_h

test/rbs-seed/sig/return_hash_variant.rbs

@@ -0,0 +1,10 @@
+class Jar
+  def initialize: (?Hash[String, String] inbound) -> void
+  def to_h: () -> Hash[String, String]
+  def add: (String k, String v) -> Jar
+end
+
+class SymJar
+  def initialize: () -> void
+  def to_h: () -> Hash[Symbol, Integer]
+end