[ASDAlexander77]

Under rc, let v = mkv(1); let m = v.get; v = mkv(2); m() ran on a freed object and printed 1003/1004, where gc prints 3. A bound method kept in a field (h.f = v.get) or in an element ([v.get]) failed the same way. Receivers already retain and release bound values through the tag at CLOSURE_TYPE_INDEX, but a bound method carried a null tag there, so keeping it counted nothing.

Fix (LowerToLLVM)

• Under rc, a method bound to a class object now gets that class's type tag, the same way an interface over the object gets its tag at INTERFACE_TYPE_INDEX.
• A bound value is still born with no count. Each receiver that keeps it (RetainSlot / field / element) counts the object, and its release gives that count back.
• ThisSymbolRef and ThisVirtualSymbolRef cast this to an opaque pointer before building the CreateBoundFunction. So they record the object's type on it in a new attribute, BOUND_OBJECT_TYPE_ATTR_NAME (Defines.h).
• own, gc and none keep the null tag. Under own a second reference to the object is already rejected.

Still open: const m = h.v.get, a const bound method over a field read, is folded and holds nothing. That's the const-folding side and is not changed here. #637 covers the const over a local.

Tests

• tests/00bound_method_count.ts (default + rc/none corpus): a bound method in a let, in a field, in an element.
• Teeth: with the new tag switched off, each case fails under rc (AOT).

Results

• Windows: ctest -C Release, 4886/4886 passed
• WSL (Linux, where the heap catches double frees): 4868/4868 passed
• DefaultLib was not rebuilt under rc against this change.

🤖 Generated with Claude Code

[ASDAlexander77]

Two follow-up notes from checks after opening:

• Checked: a bound method folded into a const and returned (pick() { const m = this.get; return m; }, keep() { const v = new V(1); const m = v.get; return m; }), called 100 times with churn: correct under rc on Windows (AOT, JIT, --opt) and on Linux with glibc's heap (AOT and JIT). No over-release.
• Behaviour change: an object that stores a method bound to itself in its own field (this.f = this.m) is now a reference cycle under rc. It leaks instead of being freed, which is the usual cost of counting. The memory benchmark could see it.