-mm=own: an importer can build objects of an imported class

[ASDAlexander77]

Fixes the issue found in #409: an importer built under -mm=own couldn't create an object of a library's class.

Cause

new H() of an imported class calls the library's H..new, then runs H.constructor through a method bound to the new object: CreateBoundFunction(Cast(h to opaque), ctor), split straight back into GetThis/GetMethod for the call. The inference read that cast as taking h, so every later use of h reported "used after its value was moved".

Fix

• The cast is a borrow when that bound-method call is its only use, and the object comes out again only as a call's argument. This is what ThisSymbolRef already is for a method of this module.
• The object is fresh, and owned here, only when the library was built under own. Its ..new is on the library's __own_no_drops list (-mm=own: a library exports which of its functions destroy nothing #409), so the signature pass marks the call __own_fresh_result, which isFresh reads.
• rc libraries keep the old conservative rule. An rc library lists nothing, and its blocks carry a count their module holds, so there a borrow under the object still ends at any unknown call.

test-runner fix (affects every -shared -mm=... test)

In -shared mode, -mm= reached only the library, so every -shared -mm=rc/none/own test built its program under gc and ran a mixed link. That includes #409's two -shared tests; only its Windows script test actually checked the facts. The flag now goes into tslang_opt, as -x86's triple does, and all 302 -shared tests pass with it.

Tests

• New own/import_own_class.ts + own/export_own_class.ts, as a -shared pair under own, rc, none and gc, AOT and JIT. They cover construction with arguments, a field store, method and getter calls, and an imported function, with each object read after a churn.
• own-shared-no-drops.cmake also checks that the program is rejected against the same library built under rc.
• Windows Release: 3253/3253.
• Linux (WSL): 3239/3239.
• -mm=own corpus: unchanged at 303.

JIT heap fix (CI failure on the first push)

test-jit-rc-shared-import-class and test-jit-own-shared-import-class crashed on Windows CI with 0xC0000005. It was a heap mismatch, not the change above:

• The JIT bound the program's malloc/free to tslang.exe's own.
• With CI's prebuilt LLVM, those are rpmalloc's: LLVMSupport brings it as the process malloc (scripts/llvm_prebuilt_common.ps1).
• The library, like every module tslang builds and TypeScriptRuntime.dll, allocates with the static release CRT, which uses the process heap.
• Under rc and own, an object made in the library is freed by the program, so the free faults. gc and none never free across the boundary, and a locally built LLVM has no rpmalloc, so only CI saw it.

That first fix exposed a second pairing on CI. test-jit-{rc,none}-corpus-00async-gc-threading failed with 0xC0000374:

• A coroutine frame comes from TypeScriptRuntime.dll's aligned_alloc shim, which called that DLL's malloc.
• TypeScriptRuntime.dll links LLVMSupport, so on CI that malloc is rpmalloc too.
• The frame goes back through plain free, which the JIT now binds to the process heap.

The runtime's four allocation exports (Alloc/AlignedAlloc/Free/AlignedFree) now use ucrtbase.dll in release builds as well. Checked by putting them on a private heap of their own, which is CI's condition: exactly those two tests fail, and with the fix both pass.

In release builds the JIT now takes malloc/calloc/realloc/free from ucrtbase.dll, the release CRT on the process heap. Debug builds are unchanged. Checked locally by binding the JIT to a private heap: that reproduces the CI pattern exactly (own and rc fail, none and gc pass), and with the fix all four pass. Windows 3253/3253.

Known gap, recorded in §15.7, not fixed here

A value an own importer receives from an rc library is destroyed at the end of its owner's scope, because own's release skips only immortal blocks. That was already true of call results, and now applies to new objects too. If the library kept a reference of its own, that is a use-after-free, where the mixed-link policy promises a leak.

🤖 Generated with Claude Code