fix(typecheck): auto-deref ref/own/mut for struct field access (Refs #122)

`fn(c: ref Point) = c.x` failed with "Field 'x' not found in type
ref {x: Int, ...}": ExprField unified the receiver type directly with
the expected record, so a TRef/TMut/TOwn wrapper made projection fail.

Strip TRef/TMut/TOwn (via repr) before record projection — Rust-like
auto-deref for field access. The borrow checker still governs aliasing
separately; this only affects the *type* of the projected field, which
is identical through a reference. Trait-method fallback path unchanged.

This unblocks receiver-first methods that take `ref/own/mut self|recv`
(the idiomatic, allocation-free form) under the Deno-ESM class synth.

Regression: tests/codegen-deno/ref_fields.{affine,harness.mjs} —
ref/own/mut receivers synthesised as Point methods, field access
verified. `dune runtest` unchanged (same 2 pre-existing E2E Node-CJS
vscode failures, 214 tests, zero new regressions). Deno-ESM suite green.

Refs #122.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: hyperpolymath

lib/typecheck.ml

@@ -749,10 +749,21 @@ let rec synth (ctx : context) (expr : expr) : ty result =
   (* Field access — first try record-field projection, then trait method lookup *)
   | ExprField (obj, { name = field; _ }) ->
     let* obj_ty = synth ctx obj in
+    (* Auto-deref reference/owned wrappers before record projection
+       (issue #122 v2): `c.field` where `c : ref/own/mut S` projects the
+       field of S — the borrow checker still governs aliasing separately.
+       Without this, `fn(c: ref S) = c.field` failed with
+       "Field 'field' not found in type ref {...}". *)
+    let rec strip_ref t =
+      match repr t with
+      | TRef u | TMut u | TOwn u -> strip_ref u
+      | u -> u
+    in
+    let obj_ty_deref = strip_ref obj_ty in
     let field_ty = fresh_tyvar ctx.level in
     let rest_row = fresh_rowvar ctx.level in
     let expected_record = TRecord (RExtend (field, field_ty, rest_row)) in
-    begin match Unify.unify (repr obj_ty) expected_record with
+    begin match Unify.unify (repr obj_ty_deref) expected_record with
     | Ok () -> Ok field_ty
     | Error _ ->
       (* Record projection failed — try trait method dispatch.

tests/codegen-deno/ref_fields.affine

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.3 regression: struct field access through ref/own/mut
+// receivers must typecheck (auto-deref before record projection).
+// Previously `fn(c: ref S) = c.field` failed: "Field 'field' not found
+// in type ref {...}".
+
+struct Point { x: Int, y: Int }
+
+pub fn mk_point(x: Int, y: Int) -> Point = Point { x: x, y: y };
+
+pub fn sum_ref(p: ref Point) -> Int = p.x + p.y;
+
+pub fn get_x_own(p: own Point) -> Int = p.x;
+
+pub fn get_y_mut(p: mut Point) -> Int = p.y;

tests/codegen-deno/ref_fields.harness.mjs

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.3 — field access through ref/own/mut receivers.
+// mk_point returns Point (constructor); sum_ref/get_x_own/get_y_mut
+// take Point first (ref/own/mut) so they synthesise as Point methods —
+// exercising auto-deref field access *and* class synthesis together.
+import assert from "node:assert/strict";
+import { Point } from "./ref_fields.deno.js";
+
+const p = new Point(3, 4);
+assert.equal(p.x, 3, "constructor assigns x");
+assert.equal(p.y, 4, "constructor assigns y");
+assert.equal(await p.sum_ref(), 7, "field access through ref receiver");
+assert.equal(await p.get_x_own(), 3, "field access through own receiver");
+assert.equal(await p.get_y_mut(), 4, "field access through mut receiver");
+
+console.log("ref_fields.harness.mjs OK");