Re-enable might_reference_actor optimization where safe

The might_reference_actor optimization was disabled in PR #4256 as a
safety net — hardcoded to true for all types, forcing full tracing of
every immutable object. This caused a ~1/3 performance drop in
message-heavy programs.

The compiler now computes might_reference_actor at compile time using a
monotone fixpoint: actors are always true, classes/structs/tuples
propagate from their fields (including through trait subtypes), and
primitives are always false. The result is baked into the type descriptor
so the runtime reads a constant — no runtime computation needed.

The existing runtime code in gc.c is already correct — it checks
might_reference_actor at all 11 call sites. Only the compiler needed to
change: emit the computed value instead of hardcoded true.

Adds a new full-program test (val-to-val-with-actor-through-trait) that
verifies immutable tracing does recurse when B has an actor field.
Counterfactual-verified: hardcoded true breaks the val-to-val test,
hardcoded false causes regression-1118 to segfault.

Release notes and CHANGELOG updated directly (multi-type PR: Fixed +
Changed). Individual release notes file removed per convention.

Author: SeanTAllen

.release-notes/fix-iso-to-val-trait-memory-leak.md

@@ -100,3 +100,25 @@ Lines inside triple-quoted strings (docstrings) and lines containing `"""` delim
 
 Previously, writing `return error` in a function body would crash the compiler with an assertion failure instead of producing a diagnostic error. The compiler now correctly reports that a return value cannot be a control statement.
 
+## Fix memory leak when a behavior parameter has a different capability than the trait it implements
+
+When a behavior was called through a trait reference and the concrete actor's parameter had a different trace-significant capability (e.g., the trait declared `iso` but the actor declared `val`), the ORCA garbage collector's reference counting was broken. The sender traced the parameter with one trace kind and the receiver traced with another, causing field reference counts to never reach zero. Objects reachable from the parameter were leaked.
+
+```pony
+trait tag Receiver
+  be receive(b: SomeClass iso)
+
+actor MyActor is Receiver
+  be receive(b: SomeClass val) =>
+    // b's fields were leaked when called through a Receiver reference
+    None
+```
+
+The sender and receiver now use consistent tracing for each parameter, regardless of capability differences between the trait and concrete method.
+
+## Re-enable immutable-send GC optimization
+
+The runtime's ORCA garbage collector has an optimization that skips tracing the field graph of immutable objects sent between actors — if an object is already immutable, its fields can't change, so the GC doesn't need to recurse into them on every send. This optimization was disabled in 0.39.0 (PR #4256) because it was unsafe for immutable objects that transitively contain actor references: skipping the trace meant the actor's reference count wasn't updated, leading to premature collection and segfaults.
+
+The compiler now computes at compile time whether each type could transitively contain an actor reference. Types that can't — classes, structs, and tuples whose fields only contain other non-actor types — get the optimization. Types that can contain actors are traced fully, preserving correctness. This restores the performance benefit for the common case (most immutable objects don't reference actors) while keeping the safety fix for the uncommon case.
+

.release-notes/next-release.md

@@ -6,6 +6,7 @@ All notable changes to the Pony compiler and standard library will be documented
 
 ### Fixed
 
+- Fix memory leak when a behavior parameter has a different capability than the trait it implements ([PR #4944](https://github.com/ponylang/ponyc/pull/4944))
 - Fix pool_memalign crash due to insufficient alignment for AVX instructions ([PR #4909](https://github.com/ponylang/ponyc/pull/4909))
 - Fix `assignment-indent` to require RHS indented relative to assignment ([PR #4913](https://github.com/ponylang/ponyc/pull/4913))
 - Fix tool install with `use` flags ([PR #4915](https://github.com/ponylang/ponyc/pull/4915))
@@ -20,6 +21,7 @@ All notable changes to the Pony compiler and standard library will be documented
 
 ### Changed
 
+- Re-enable immutable-send GC optimization ([PR #4944](https://github.com/ponylang/ponyc/pull/4944))
 - Update to LLVM 21.1.8 ([PR #4876](https://github.com/ponylang/ponyc/pull/4876))
 - Exempt unsplittable string literals from line length rule ([PR #4923](https://github.com/ponylang/ponyc/pull/4923))
 

CHANGELOG.md

@@ -254,11 +254,11 @@ static LLVMValueRef make_field_offset(compile_t* c, reach_type_t* t)
     LLVMOffsetOfElement(c->target_data, c_t->structure, index), false);
 }
 
+// Pre-computed by reach_compute_might_reference_actor(), which must be
+// called before gendesc_init().
 static LLVMValueRef make_might_reference_actor(compile_t* c, reach_type_t* t)
 {
-  (void)t;
-
-  return LLVMConstInt(c->i1, 1, false);
+  return LLVMConstInt(c->i1, t->might_reference_actor ? 1 : 0, false);
 }
 
 static LLVMValueRef make_field_list(compile_t* c, reach_type_t* t)

src/libponyc/codegen/gendesc.c

@@ -1,6 +1,7 @@
 #include "gentype.h"
 #include "genbox.h"
 #include "gendesc.h"
+#include "../reach/reach.h"
 #include "genexpr.h"
 #include "genfun.h"
 #include "genident.h"
@@ -843,6 +844,9 @@ bool gentypes(compile_t* c)
   if(c->opt->verbosity >= VERBOSITY_INFO)
     fprintf(stderr, " Descriptors\n");
 
+  // Compute might_reference_actor before gendesc_init reads it.
+  reach_compute_might_reference_actor(c->reach);
+
   i = HASHMAP_BEGIN;
 
   while((t = reach_types_next(&c->reach->types, &i)) != NULL)

src/libponyc/codegen/gentype.c

@@ -1595,6 +1595,74 @@ uint32_t reach_max_type_id(reach_t* r)
   return len;
 }
 
+// Check whether a single field's reach_type_t might reference an actor.
+// For trait-like types, checks all concrete subtypes.
+static bool field_might_reference_actor(reach_type_t* field_type)
+{
+  if(!field_type->is_trait)
+    return field_type->might_reference_actor;
+
+  size_t j = HASHMAP_BEGIN;
+  reach_type_t* sub;
+
+  while((sub = reach_type_cache_next(&field_type->subtypes, &j)) != NULL)
+  {
+    if(!sub->is_trait && sub->might_reference_actor)
+      return true;
+  }
+
+  return false;
+}
+
+void reach_compute_might_reference_actor(reach_t* r)
+{
+  size_t i;
+  reach_type_t* t;
+
+  // First pass: actors always might reference an actor (they ARE actors).
+  i = HASHMAP_BEGIN;
+  while((t = reach_types_next(&r->types, &i)) != NULL)
+  {
+    if(t->underlying == TK_ACTOR)
+      t->might_reference_actor = true;
+  }
+
+  // Fixpoint: propagate through fields until stable.
+  // Values only move false->true (monotone), so this converges.
+  bool changed = true;
+  while(changed)
+  {
+    changed = false;
+    i = HASHMAP_BEGIN;
+
+    while((t = reach_types_next(&r->types, &i)) != NULL)
+    {
+      if(t->might_reference_actor)
+        continue;
+
+      switch(t->underlying)
+      {
+        case TK_CLASS:
+        case TK_STRUCT:
+        case TK_TUPLETYPE:
+          break;
+        default:
+          continue;
+      }
+
+      for(uint32_t f = 0; f < t->field_count; f++)
+      {
+        if(field_might_reference_actor(t->fields[f].type))
+        {
+          t->might_reference_actor = true;
+          changed = true;
+          break;
+        }
+      }
+    }
+  }
+}
+
 void reach_dump(reach_t* r)
 {
   printf("REACH\n");
@@ -1610,6 +1678,8 @@ void reach_dump(reach_t* r)
 
     printf("    serialise_id: %" PRIu64 "\n", t->serialise_id);
     printf("    is_trait: %s\n", (t->is_trait)?"true":"false");
+    printf("    might_reference_actor: %s\n",
+      (t->might_reference_actor)?"true":"false");
     printf("    can_be_boxed: %s\n", (t->can_be_boxed)?"true":"false");
 
     printf("    vtable: %d\n", t->vtable_size);
@@ -2022,6 +2092,7 @@ static void reach_type_serialise(pony_ctx_t* ctx, void* object, void* buf,
   dst->vtable_size = t->vtable_size;
   dst->can_be_boxed = t->can_be_boxed;
   dst->is_trait = t->is_trait;
+  dst->might_reference_actor = t->might_reference_actor;
   dst->serialise_id = t->serialise_id;
 
   dst->field_count = t->field_count;

src/libponyc/reach/reach.c

@@ -102,6 +102,7 @@ struct reach_type_t
   uint64_t serialise_id;
   bool can_be_boxed;
   bool is_trait;
+  bool might_reference_actor;
 
   uint32_t field_count;
   reach_field_t* fields;
@@ -148,6 +149,8 @@ uint32_t reach_vtable_index(reach_type_t* t, const char* name);
 
 uint32_t reach_max_type_id(reach_t* r);
 
+void reach_compute_might_reference_actor(reach_t* r);
+
 void reach_dump(reach_t* r);
 
 pony_type_t* reach_method_pony_type();

src/libponyc/reach/reach.h

@@ -0,0 +1 @@
+1

test/full-program-tests/codegen-trace-val-to-val-with-actor-through-trait/expected-exit-code.txt

@@ -0,0 +1,44 @@
+use "lib:codegen-trace-additional"
+
+use @gc_local[Pointer[None]](target: Main)
+use @gc_local_snapshot[Pointer[None]](target: Main)
+use @gc_local_snapshot_destroy[None](obj_map: Pointer[None])
+use @objectmap_has_object[Bool](obj_map: Pointer[None], obj: Any tag)
+use @objectmap_has_object_rc[Bool](obj_map: Pointer[None], obj: Any tag, rc: USize)
+use @pony_exitcode[None](code: I32)
+
+actor Dummy
+
+class A
+
+class B
+  let a: A = A
+  let d: Dummy
+
+  new create(d': Dummy) => d = d'
+
+trait tag Receiver
+  be receive(b: B val)
+
+actor Main is Receiver
+  var map_before: Pointer[None] = Pointer[None]
+
+  new create(env: Env) =>
+    // Call through a trait-typed variable, same as the val-to-val test.
+    // B has an actor field (Dummy), so might_reference_actor is true.
+    // Immutable tracing DOES recurse into fields despite val capability.
+    let r: Receiver = this
+    r.receive(recover B(Dummy) end)
+    map_before = @gc_local_snapshot(this)
+
+  be receive(b: B val) =>
+    let map_after = @gc_local(this)
+    // Both sender and receiver trace b as IMMUTABLE (val). Since B has an
+    // actor field (might_reference_actor is true), immutable tracing recurses
+    // into fields. So b.a DOES appear in the object map with rc bookkeeping.
+    let ok = @objectmap_has_object_rc(map_before, b, USize(1)) and
+      @objectmap_has_object(map_before, b.a) and
+      @objectmap_has_object_rc(map_after, b, USize(0)) and
+      @objectmap_has_object(map_after, b.a)
+    @gc_local_snapshot_destroy(map_before)
+    @pony_exitcode(I32(if ok then 1 else 0 end))