GeezerVison

What this is

An app can ship a file of C stubs, one per (class, selector), that the runtime binds as the V8 callback for that method or property getter in place of the generic libffi dispatch. Each stub is a cast objc_msgSend / objc_msgSendSuper call whose C types come from the metadata generator's JSON output, so the generator needs no framework headers and the stub file imports only <NativeScript/NativeScriptAOT.h> and Foundation.

This is a rewrite of the original proof of concept on top of current main. The PR history was replaced; the previous commits are still on the remote reflog.

How it works

• Generator scripts/generate-aot.py CONFIG -m METADATA_JSON_DIR -o NativeScriptAOTStubs.m. The config lists only {"class", "selector", "static"?}; everything else (return/parameter types, ownership flags, struct layouts) is read from the metadata JSON. Methods are found by walking the class's protocols and Base chain, and the stub is registered under the class that declares the member (which is where the runtime binds it). Unsupported entries are skipped with a reason: initializers, NSError** out-parameters, variadics, block or function-pointer parameters, typed pointers, unichar, Protocol*, long long (BigInt marshalling), unions by value, and enums whose metadata lacks an underlying type.
• Bridge NativeScriptAOT.h (public, C) + NativeScriptAOTBridge.mm. A stub resolves its receiver through __ns_aot_get_target, which also returns the selector to send (swizzled when the generic path would) and whether to use objc_msgSendSuper (instances of JS-extended classes); reads arguments through typed getters; sends inside @try; and sets the result through typed setters. Conversions run through the same Interop::WriteValue / ObjectToJsValue / StructToValue code as the generic path, driven by the bound method's real MethodMeta, so clamping, adapters, protocol conformances on returns and NSException conversion are identical.
• Decline and fall back. A handler returns false to decline, and the trampoline runs the generic callback for the same call. Stubs decline on argument-count mismatch (overloads, optional error parameters), alloc receivers, and non-object receivers, which keeps everything they do not model correct.
• Binding happens once per prototype-template build: DiscoverExternalStubs (dlsym("__ns_register_aot_calls"), call_once) fills an immutable registry; the four registration sites in MetadataBuilder look the member up by class name, SEL and static-ness, walking the ObjC superclass chain on a miss (protocol members are re-registered on each adopter). With no stubs registered the extra cost is one check.
• Profiler globalThis.__native_call_profiler (lazy global): start()/stop()/report(n)/aotConfig(n)/aotStats(). aotConfig emits config entries for the hottest generic-path calls; aotStats reports calls served by stubs and declined, counted while profiling is on.
• Metadata JSON objc-metadata-generator -output-json <dir>, enabled in the Xcode build with NS_JSON_METADATA_PATH=<dir>; schema identical to the earlier iteration plus UnderlyingType on enums. YAML and binary outputs are unchanged.

Changes from the previous iteration

• Stubs are objc_msgSend casts from metadata instead of typed Objective-C sends, which removes the header-import and return-type resolution scripts (resolve-aot-imports.py, resolve-aot-returntypes.py) and the imports/objectTypes/protocolTypes/swiftClasses config fields.
• The checked-in built-in AOTDirectCalls.mm (18 Foundation stubs) and the block-invoke patterns are gone: they duplicated the generic path with gaps (no exception handling, no overloads, id block arguments no longer marshalled to primitives).
• Stubs can decline; the old ones returned undefined for anything unexpected.
• NSException is caught in every stub and converted exactly like the generic @catch; owned (+1) returns are balanced by the runtime, so the stub file works with ARC on or off.
• Argument and return conversion use the bound method's metadata rather than stub-supplied encodings.
• callSuper is cached per Class (self-invalidating on ClassPrototypes growth); the lookup allocates nothing per call.
• Struct types are resolved once per stub into a stable handle.

Measurements

Release TestRunner, iPhone 16 Pro simulator on an M4 Pro, ns per op, same spec as PR #496. The branch is based on main with #496 merged, so the last column is main + #496 + stubs:

Stubs remove the libffi dispatch and the per-call struct-name lookup; they do not change how a struct is materialized in JS, which is what dominates the struct rows (see "Not in this PR").

Non-struct calls

A/B on the same Release build: generic path (stub file built from an empty config) vs stubs (TestRunner/AOT/aot-config.json). 20,000 calls per case, ns per op; aotStats() confirms every stubbed call was served (0 declined) in the stub run and none in the generic run. Run-to-run noise is about 3-10%.

Stubs save a roughly constant 20-35 ns per call (the libffi dispatch and the generic argument/return plumbing), which is 17-37% of cheap calls. Where the call itself or the JS-side conversion dominates (string arguments and returns, wrapper creation for new objects, description), the gain drops to single digits.

Validation

• Full TestRunner suite with the checked-in test stubs (TestRunner/AOT/, 52 stubs over TestFixtures, NSObject, Foundation collections/strings/numbers, UIScreen, UIView and UIColor) bound: 1777 tests, 0 failures on the rebased branch (Debug; the AddressSanitizer lane ran clean with the earlier 36-stub subset). The new AOTDirectCallsTests.js (34 specs) asserts served/declined counts per call and covers members, structs, argument kinds, NSException parity, JS-extended overrides calling super, and the decline paths.
• Suite with no stubs registered: 1742/0 (the generic path is untouched).
• Independent review of the runtime diff; its findings (real-metadata conversion, callSuper cache invalidation, profiler teardown, lazy global, trampoline guards) are applied.

Using it in an app

1. Build once with NS_JSON_METADATA_PATH=<dir> to get the metadata JSON.
2. Run the app, __native_call_profiler.start(), exercise the hot screens, __native_call_profiler.aotConfig(50) → paste into aot-config.json.
3. python3 scripts/generate-aot.py aot-config.json -m <dir>/arm64 -o App_Resources/iOS/src/NativeScriptAOTStubs.m.
4. If the app build strips symbols, ___ns_register_aot_calls must stay exported (see TestFixtures/exported-symbols.txt for how the TestRunner does it).

An existing NativeScriptAOTStubs.m generated by the previous iteration targets the old bridge API and must be regenerated.

Not in this PR

• Bridge getters for typed pointers, unichar, Protocol*, block returns, and long long as BigInt; property setters are generated but not bound; overloaded jsNames (baseMethod / baseMethod:) bind in metadata order as before.
• Owned returns that are marshalled to a primitive or hit the instance cache are not released (pre-existing GetResult behavior, same on both paths).
• Struct materialization cost. Two candidate follow-ups: an opt-in per-entry "plain object" return mode for read-only struct getters (the stub builds {origin:{x,y},size:{width,height}} from a cached shape, no wrapper or finalizer, estimated ~400 ns for the full bounds.size.width chain, at the price of snapshot semantics), or per-struct-type object templates with native accessors in the runtime, which keeps live-view semantics for every path.