[BUMP:cli:0.4.0-canary.0] [BUMP:py_client:1.3.0+canary.0] [BUMP:vscode_ext:0.5.0-canary.0] - #6
Merged
Merged
Conversation
…de_ext:0.5.0-canary.0]
hellovai
added a commit
that referenced
this pull request
Jan 20, 2026
Complete the BEX garbage collector by closing 5 identified gaps: - Gap #1: Parked VM roots now collected via VM pointer registry - Gap #2: VM stacks updated with forwarding pointers after GC - Gap #3: TLABs invalidated after GC space swap - Gap #6: Handle race condition fixed with EpochGuard Key changes: - Add parked_vms registry to EpochState for tracking VMs at safepoints - Collect roots from all parked VM stacks during GC - Update parked VM stacks with forwarding pointers after copying - Remove cached ObjectIndex from Handle (always resolve through table) - Add gc_in_progress flag to synchronize new calls with GC - Add EpochGuard token for compile-time epoch protection enforcement - Add heap accessor API for safe external code access (read_string, etc.) - Add GC coordination documentation to module docs
6 tasks
antoniosarosi
added a commit
that referenced
this pull request
May 4, 2026
- pull_semantics: debug_assert on the default `make_closure_with_type_args` so a sink that drops `ntypeargs` fails fast instead of silently modeling the wrong stack shape (#1). - mir/lower: `enclosing_generic_params()` now prepends class-level generics (matching TIR's `enclosing_class_generic_params ++ user` convention), so `reflect.type_of<T>()` and explicit `<T>` calls inside a method on `class Box<T>` lower to `TypeArgRef(N)` instead of silently emitting `Concrete(Void)` (#2, MIR side only — runtime ABI for class type-arg threading via the receiver is still TODO; documented on the helper). Two stdlib snapshots regenerated to reflect the now-correct lowering for `Stream<T,S>::final()` / `__sap_parse_partial<T,S>`. - tir/builder: add `Ty::Type { .. }` arm to `try_resolve_member_on_ty` so unions like `(cond ? type_of<A>() : type_of<B>()).to_string()` resolve via the `TypeValue` companion class (#4). - vm: gate the post-`Call` `type_args` writeback on `frames.len() > frames_before` so completed Native callees don't clobber the caller's frame, and `extend` rather than replace so a closure callee's `captured_type_args` are preserved with call-site args appended (#6, critical). - tests/load_type: tighten the concrete `LoadType` tests to match `Object::Type(ty)` against `Ty::int()`/`Ty::string()` and assert they differ, instead of accepting any `Value::Object(_)` (#7). - type_class / reflect_type_of: document `TypeValue.to_string()` as a stable identity key (package names are unique within a workspace, so the existing `Display` form is unambiguous) and add an end-to-end `map<string, V>` keyed-by-`type_of<T>().to_string()` test as the user-reachable analogue of `map<type, V>` (#8). - conversion: document the runtime gap that class-instance matching in `value_matches_type` and `find_matching_union_member` ignores `Ty::Class` type args because `Object::Instance` carries no resolved class type args — needed for proper union dispatch on parametric classes (#9, runtime side bundled with #2 follow-up).
codeshaunted
added a commit
that referenced
this pull request
Jun 2, 2026
Addresses two more CodeRabbit comments on generic instantiation exprs: #3 (lower.rs): a `GenericApply` whose base is not a compile-time function reference (a local/captured generic function value, e.g. `let g = foo; let h = g<int>`) previously fell back to lowering the base with its type args ERASED — reintroducing the type/runtime mismatch the feature removes. Now the runtime value is specialized: a new `Rvalue::MakeGenericFunctionFromValue` + `MakeGenericFunctionFromValue` opcode wraps the evaluated callable in a Closure carrying the (frame-resolved) type args, reusing the closure call path that already seeds `frame.type_args`. So `g<int>` runs end-to-end and a type-reifying body (`reflect.type_of<T>`) resolves T correctly, including the param-dependent `g<T>` case. No new GC-traced object: the only reachable non-ItemRef base is a local holding a bare function (static methods take the pooled ItemRef path, lambdas/GenericFunction bases are rejected by TIR). #6 (instantiation_interning.rs): `baml.deep_equals` is structural, so the fixture couldn't prove the pooled, pointer-stable identity (`foo<int> === foo<int>`); BAML has no in-language identity operator. Added a Rust harness that inspects the compiled object pool: two `identity<Marker>` references intern to one `Object::GenericFunction`, distinct from `identity<Other>`. Full workspace suite green (5006 passed).
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.
Automated flow to bump version [BUMP:cli:0.4.0-canary.0] [BUMP:py_client:1.3.0+canary.0] [BUMP:vscode_ext:0.5.0-canary.0]