Add a compiled-invoker fast lane for single-candidate interop method calls - #2733
Merged
Merged
Conversation
Cache MethodBase.IsGenericMethod on MethodDescriptor (computed in the ctor) so the per-call argument-binding path no longer pays the RuntimeMethodHandle::HasMethodInstantiation reflection cost in MethodInfoFunction.ResolveMethod/TryCall and in descriptor prioritization. This helps every path, including AOT. Add CompiledMethodInvoker: a lazily-built, strongly-typed delegate for the dominant interop shape (host.add(int,int) etc.). For single-candidate call sites whose parameters are exact-type primitives (int/long/double/bool/string) or a pass-through JsValue, and whose return is void/int/long/double/bool/string or a JsValue, the delegate binds and invokes without the per-call object?[] parameter array, argument boxes, boxed return value, and return-mapper lookup. Design notes: - Built only when RuntimeFeature.IsDynamicCodeCompiled is true (under AOT and interpreted-only Expression.Compile the cached MethodInvoker path is faster), and only on NET8_0_OR_GREATER (matching the existing fast-invoker gating). - Numeric argument conversion replicates InteropHelper.TryConvertNumberFast bit-for-bit (integral + range checks); any non-exact argument (fractional to int, out-of-range, wrong JS type) makes the delegate decline so the caller falls back to the full TryCall machinery, preserving today's behavior. - Returns are produced via the public JsValue implicit operators, which match DefaultObjectConverter exactly (void maps to JS null, as today). - The method is invoked through a cached open delegate (Expression.Invoke) rather than a direct Expression.Call: a direct call lets the JIT inline a small host method into the compiled lambda, erasing its frame from a thrown exception's stack trace. The delegate keeps the frame (reflection never inlines) so bubbling CLR exceptions look identical, while staying allocation free and fully typed. - The fast lane is skipped when custom object converters are registered, since those must observe primitive return values. - Exceptions thrown by the target propagate and are normalized at the call site to TargetInvocationException, matching the reflection path's error shape. Adds targeted tests covering fast-lane hits (int/long/double/bool/string/JsValue args and returns, void, static), fallbacks (overloaded, params, optional, fractional/string-to-int, out-of-range), host-exception fidelity, and the custom-converter bypass. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
lahma
added a commit
that referenced
this pull request
Jul 22, 2026
… foreign receivers (#2737) Two behavior-parity gaps in the #2733 exact-type fast lane found in pre-release review: - The lane's gate checked custom IObjectConverters but not the engine's user-replaceable ITypeConverter. The reflection path consults the converter for some exact-type argument conversions (e.g. bool under default value coercion), so a custom converter installed via SetTypeConverter was silently bypassed. The lane now requires the exact DefaultTypeConverter. - An extracted instance method invoked with a wrong-typed this (f.call(foreignObject)) surfaced InvalidCastException from the compiled receiver cast instead of the reflection path's TargetException, which host code and Interop.ExceptionHandler predicates key on. The lane now declines when the receiver is not an instance of the declaring type so the slow path surfaces the original exception shape. Both new tests fail without the gate changes. Claude-Session: https://claude.ai/code/session_0115tQFNyyQqc1HQGPLUgZND Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
This was referenced Jul 22, 2026
4 of 5 tasks
This was referenced Jul 22, 2026
legrab
added a commit
to legrab/pocok
that referenced
this pull request
Jul 29, 2026
Updated [Jint](https://github.com/sebastienros/jint) from 4.13.0 to 4.14.0. <details> <summary>Release notes</summary> _Sourced from [Jint's releases](https://github.com/sebastienros/jint/releases)._ ## 4.14.0 Jint 4.14.0 is an **interop-focused performance release**: CLR arrays now cross into script as live views instead of copies, recently wrapped host objects reuse their wrappers, single-candidate interop method calls dispatch through compiled invokers, and `JSON.parse` interns repeated keys and values. Host collection traversal is **10.9× faster** than 4.13.0. **Two interop defaults changed in this release** — read the first two highlights if you pass CLR arrays to scripts or rely on per-crossing conversion behavior; everything else needs no code changes to benefit. ### Highlights **CLR arrays are live views by default (behavior change).** `Options.Interop.ArrayConversion` now defaults to `ArrayConversionMode.LiveView` (#2721, #2728, #2735): a single-rank `T[]` crossing into script becomes a live, fixed-size view over the underlying array — the way wrapped `List<T>` already behaves — instead of being copied into a new JS array on every read. Writes go through in both directions, and arrays exposed through read-only-declared members (e.g. `IReadOnlyList<T>`) produce read-only views. Iteration, `Array.prototype` methods, JSON serialization, index-key enumeration (`Object.keys` / `for..in` yield `"0"`..`"n-1"`) and `undefined` for out-of-range reads all behave array-like, but `Array.isArray` returns `false`, and because CLR arrays are fixed-size, resizing operations (`push`/`pop`/`length` writes) throw a `TypeError` like integer-indexed exotic objects do — `shift`/`splice` may move elements before their length change throws, as for typed arrays. Set `Options.Interop.ArrayConversion = ArrayConversionMode.Copy` to restore the 4.13 behavior. **Recently wrapped CLR objects reuse their wrappers (behavior change).** The new `Options.Interop.CacheRecentObjectWrappers` defaults to `true` (#2734): a small bounded ring (8 entries, keyed by reference identity and exposed type) reuses wrappers for host objects that repeatedly cross into script. Wrapper identity becomes stable (`host.Obj === host.Obj`), script-attached state (freeze, `defineProperty`, expandos) survives crossings, and the per-crossing wrapper allocation disappears. Under `Copy` array conversion this also means repeated reads of the same CLR array reuse the first `JsArray` snapshot while it stays cached — CLR-side mutations are not re-copied; set the option to `false` for the pre-4.14 fresh-snapshot-per-crossing behavior. `Engine.Dispose()` releases the ring. **Interop fast lanes.** Single-candidate method calls run through a compiled invoker that binds and invokes without argument arrays or boxing (#2733), with per-parameter binding flags precomputed (#2719). Resolved `ObjectWrapper` members get a per-call-site inline cache (#2722) and the member-call fast path covers primitive string receivers (#2717). Array-like wrapper creation is a cached factory call with lazily materialized `length` (#2730), primitive elements convert without boxing on both indexed reads and `Array.prototype` iteration (#2731, #2735), the wrapper identity caches cover CLR arrays (#2716), and implicitly implemented interface methods are deduplicated in member resolution (#2711). **JSON.** `JSON.parse` interns property keys and string values within a parse, parses numbers off the span with an exactly-rounded fast path and scans string content in bulk (#2718, #2725, #2732) — the `json-parse-modern` comparison row is 6% faster with 23% less allocation than 4.13.0. Parsing is also aligned with the JSON grammar (#2738): malformed numbers like `-09` and `1.` are now rejected as in V8, while raw U+2028/U+2029 in strings and escaped control characters in keys — both valid JSON — are now accepted. **Strings.** Chained `slice`/`substring` and `split` segments stay zero-copy views (#2720), whole-string `substring`/`substr` return the receiver, and mismatched-length comparisons no longer materialize views (#2740). **Execution constraints at host boundaries.** Timeouts and cancellation are re-checked when control returns from host CLR code, so detection latency is bounded by one host call instead of a statement-count window, without adding per-statement cost — gated on execution depth so host-side reads of wrapped objects on an idle engine never observe a stale timer (#2713, #2714, #2715). Execution-context depth stays balanced when constraint exceptions unwind generator/async frames, and a host callback that re-enters the engine no longer resets the outer script's budget (#2736). **Correctness (including a pre-release review).** A review of everything since 4.13.0 fixed: spurious TDZ when a for-header reads a name the loop body shadows (#2709) and stale closure captures from destructuring defaults in for-loop headers (#2739); the compiled-invoker lane now defers to custom `ITypeConverter`s and preserves reflection exception types (#2737); and the new wrapper defaults were hardened — declared-type contracts for arrays (an `IReadOnlyList<T>`-typed member no longer yields a writable view), a static type-mapper poisoning crash, `Engine.Dispose` releasing the wrapper caches, and JS-array `in`/enumeration/out-of-range semantics on array views (#2735). Closure reads memoize slot-cache chain reachability (#2726). On the [engine comparison benchmarks](https://github.com/sebastienros/jint/blob/main/Jint.Benchmark/README.md), Jint 4.14.0 beats ClearScript (native V8) by 7.1×–9.1× on every script ↔ host interop row — host collection traversal went from last to second among all engines at 15,597 → 1,433 µs with 99% less allocation — while remaining the fastest managed engine on 10 of 12 pure-JS scripts and the fastest interpreter on all 12, and now leading `array-stress` and `dromaeo-object-array`, rows V8 narrowly led at 4.13.0. ## What's Changed * Refresh EngineComparison benchmarks for 4.13.0 by @lahma in sebastienros/jint#2704 * Fix spurious TDZ when a for-header reads a name the loop body shadows by @svenrog in sebastienros/jint#2709 * Bump the testing group with 1 update by @dependabot[bot] in sebastienros/jint#2710 * Add tests for using modules from script code run via Evaluate by @lahma in sebastienros/jint#2712 * Deduplicate implicitly implemented interface methods in member resolution by @lahma in sebastienros/jint#2711 * Re-check amortized constraints at interpreter/host-code boundaries by @lahma in sebastienros/jint#2713 * Add ClearScript V8 to engine comparison benchmarks, trim suite, add script-to-host interop suite by @viceice in sebastienros/jint#1775 * Gate host-boundary constraint checks on active evaluation and harden coverage by @lahma in sebastienros/jint#2714 * Key the host-boundary constraint gate on execution depth and close remaining lanes by @lahma in sebastienros/jint#2715 * Cover CLR arrays with the interop identity caches by @lahma in sebastienros/jint#2716 * Extend the member-call fast path to primitive string receivers by @lahma in sebastienros/jint#2717 * Intern object property keys within a single JSON parse by @lahma in sebastienros/jint#2718 * Precompute per-parameter interop binding flags by @lahma in sebastienros/jint#2719 * Keep slice-of-slice and split segments zero-copy by @lahma in sebastienros/jint#2720 * Add opt-in ClrArrayConversion.LiveView interop mode for CLR arrays by @lahma in sebastienros/jint#2721 * Cache resolved ObjectWrapper members per member-expression node by @lahma in sebastienros/jint#2722 * Refresh engine comparison README after the V8-gap campaign by @lahma in sebastienros/jint#2723 * Bulk string scanning and a simple-number fast path for JSON.parse by @lahma in sebastienros/jint#2725 * Memoize slot-cache chain reachability for closure reads by @lahma in sebastienros/jint#2726 * Refresh engine comparison tables after the second campaign round by @lahma in sebastienros/jint#2727 * Default Interop.ArrayConversion to LiveView for 4.14 by @lahma in sebastienros/jint#2728 * Cache array-like wrapper factories and materialize length lazily by @lahma in sebastienros/jint#2730 * Convert primitive array-like wrapper elements without boxing by @lahma in sebastienros/jint#2731 * Add a compiled-invoker fast lane for single-candidate interop method calls by @lahma in sebastienros/jint#2733 * Intern JSON.parse string values and parse numbers off the span by @lahma in sebastienros/jint#2732 * Default Interop.CacheRecentObjectWrappers to true for 4.14 by @lahma in sebastienros/jint#2734 * Harden LiveView array wrappers and interop wrapper caches for 4.14 by @lahma in sebastienros/jint#2735 * Keep execution-context depth balanced under raw constraint exceptions by @lahma in sebastienros/jint#2736 ... (truncated) Commits viewable in [compare view](sebastienros/jint@v4.13.0...v4.14.0). </details> [](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) --- <details> <summary>Dependabot commands and options</summary> <br /> You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) </details>
This was referenced Jul 29, 2026
This was referenced Aug 7, 2026
This was referenced Aug 14, 2026
This was referenced Aug 24, 2026
This was referenced Sep 1, 2026
This was referenced Sep 9, 2026
This was referenced Sep 21, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
For the dominant interop shape — a single-candidate method whose parameters are exact-type primitives — the binding path still pays four allocations per call (
object?[]parameter array, per-argument boxes, boxed return) plus theMethodInvokerindirection and the return-mapper dictionary lookup. #2719 removed the reflection re-derivation; this PR removes the rest for the hot case.Changes
MethodDescriptorcachesIsGenericMethod(the reflection property resolves throughRuntimeMethodHandle::HasMethodInstantiation— ~1% of the interop-method-calls row on its own) and uses it in binding and overload ordering. This part benefits every target including AOT.MethodDescriptor(same benign-race lazy-field idiom as_methodInvoker). Eligibility is conservative: single candidate, public non-generic instance/static method on a visible reference type, no params/optional arguments, parameters in {int, long, double, bool, string, JsValue}, return in {void, int, long, double, bool, string, JsValue-assignable}. The delegate handles exact-type argument hits only; anything else (fractional number to int, out-of-range, wrong JS type, custom object converters registered) declines and falls back to the existingTryCallmachinery, so conversion behavior is preserved bit-for-bit — the int/long guards replicateTryConvertNumberFastexactly, including the exclusive 2^63 upper bound.RuntimeFeature.IsDynamicCodeCompiled: under AOT (or interpretedExpression.Compile) an interpreted lambda would be slower than the cachedMethodInvoker, so those targets keep the current path unchanged.Expression.Call: a direct call lets the JIT inline small host methods into the lambda, which erases the host method's frame from thrown exceptions' stack traces (caught by the existing error tests). The delegate invoke keeps frames identical to the reflection path while staying allocation-free. Exception normalization (TargetInvocationException) and the host-boundary constraint checks sit at the same points as the reflection path.Benchmarks (same machine, adjacent same-base A/B, default job)
InteropMethodDispatchBenchmark:EngineComparisonInteropBenchmark(Jint lane):Gates: full Jint.Tests on net10.0 (fast lane active) and net472 (lane compiled out — proves fallback identity), Jint.Tests.PublicInterface both TFMs, Test262 99,431 passed / 0 failed. 15 new targeted tests cover fast-lane hits per type, fallback cases (overloads, params, optional args, coercions), host exceptions, and void returns.
🤖 Generated with Claude Code