From 97803ced0723007d4a7d9f576cb40629b117725a Mon Sep 17 00:00:00 2001 From: gunbc-ci-auto-heal Date: Tue, 6 Oct 2026 10:51:28 +0000 Subject: [PATCH 1/2] Enroll a qualified-reference fixture-closure floor control beside the bare-name one. The walker already closes dotted module-path edges; this control compiles a small existing pair that reaches its provider only that way, so an imports-only walk is a required red without paying v2.std.node. Co-authored-by: Cursor --- src/v1/stage0/src/cli_run/emit_host.rs | 37 ++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/v1/stage0/src/cli_run/emit_host.rs b/src/v1/stage0/src/cli_run/emit_host.rs index d4e77615ded..48978be43b4 100644 --- a/src/v1/stage0/src/cli_run/emit_host.rs +++ b/src/v1/stage0/src/cli_run/emit_host.rs @@ -3298,6 +3298,21 @@ pub(crate) fn fixture_closure_union_controls() -> Result<(u128, u128), String> { "a provider reached only by reference is missing from the fixture closure: {refusal}" )) })?; + // THE QUALIFIED-REFERENCE EDGE. The same walker must follow a dotted module-path + // reference, not only a bare name: `test.fixture.reference_derived_graph.consumer_reference_only` + // imports `std.types` and names `test.fixture.reference_derived_graph.provider.provided_value` + // qualified, so an import-only walk compiles it without its provider. The pair is small + // (no `v2.std.node`); the large corpus specimens (`v2.std.artifact` → `v2.std.refinement`) + // are the same edge at a cost the floor control must not pay. + fixture_closure_union_emit_receipt( + &fixture_closure_union_control_union(FIXTURE_CLOSURE_QUALIFIED_REFERENCE_REACH_MEMBER) + .map_err(&refuse)?, + ) + .map_err(|refusal| { + refuse(format!( + "a provider reached only by qualified reference is missing from the fixture closure: {refusal}" + )) + })?; // And the closure fix closes providers without narrowing what refuses: a real error in a // member of the fixture's own closure still refuses, located at that member. match fixture_closure_union_emit_receipt( @@ -3323,6 +3338,10 @@ pub(crate) fn fixture_closure_union_controls() -> Result<(u128, u128), String> { /// A member reaching `std.graph` only through `std.syllogism`'s bare references. const FIXTURE_CLOSURE_REFERENCE_REACH_MEMBER: &str = "module efr_member\nimport std.syllogism { Argument, argument_is_acyclic }\nfn acyclic(a: Argument) -> Bool {\n argument_is_acyclic(a)\n}\n"; +/// A member reaching `test.fixture.reference_derived_graph.provider` only through that +/// consumer's dotted qualified reference (no import of the provider, no bare name). +const FIXTURE_CLOSURE_QUALIFIED_REFERENCE_REACH_MEMBER: &str = "module efr_member\nimport test.fixture.reference_derived_graph.consumer_reference_only { uses_provider }\nfn probe() -> Int {\n uses_provider()\n}\n"; + /// The same closure with a call to a function nothing declares. const FIXTURE_CLOSURE_REAL_ERROR_MEMBER: &str = "module efr_member\nimport std.syllogism { Argument }\nfn broken(a: Argument) -> Bool {\n no_such_function_anywhere(a)\n}\n"; @@ -3436,4 +3455,22 @@ mod fixture_closure_union_tests { assert_eq!(union.members.keys().collect::>(), vec!["dag/a.dag"]); assert!(union.conflicts.contains("dag/a.dag")); } + + /// The qualified-reference control's union includes the provider the consumer never imports. + #[test] + fn a_qualified_reference_pulls_its_provider_into_the_fixture_closure() { + let union = + fixture_closure_union_control_union(FIXTURE_CLOSURE_QUALIFIED_REFERENCE_REACH_MEMBER) + .expect("qualified-reference control union"); + assert!( + union + .members + .keys() + .any(|path| path.contains("reference_derived_graph/provider")), + "provider missing from members: {:?}", + union.members.keys().collect::>() + ); + fixture_closure_union_emit_receipt(&union) + .expect("qualified-reference control closure must compile"); + } } From 383c10e52d49bc67c02047ab63e6812f92c09ce0 Mon Sep 17 00:00:00 2001 From: gunbc-ci-auto-heal Date: Tue, 6 Oct 2026 12:09:49 +0000 Subject: [PATCH 2/2] Drop the duplicate Rust unit test for the qualified-reference fixture-closure control. That test ran over 60s in exact-head CI and broke the under-100ms unit-lane ruling; the floor control and fixture stay enrolled. Co-authored-by: Cursor --- src/v1/stage0/src/cli_run/emit_host.rs | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/src/v1/stage0/src/cli_run/emit_host.rs b/src/v1/stage0/src/cli_run/emit_host.rs index 48978be43b4..5d291d0be07 100644 --- a/src/v1/stage0/src/cli_run/emit_host.rs +++ b/src/v1/stage0/src/cli_run/emit_host.rs @@ -3455,22 +3455,4 @@ mod fixture_closure_union_tests { assert_eq!(union.members.keys().collect::>(), vec!["dag/a.dag"]); assert!(union.conflicts.contains("dag/a.dag")); } - - /// The qualified-reference control's union includes the provider the consumer never imports. - #[test] - fn a_qualified_reference_pulls_its_provider_into_the_fixture_closure() { - let union = - fixture_closure_union_control_union(FIXTURE_CLOSURE_QUALIFIED_REFERENCE_REACH_MEMBER) - .expect("qualified-reference control union"); - assert!( - union - .members - .keys() - .any(|path| path.contains("reference_derived_graph/provider")), - "provider missing from members: {:?}", - union.members.keys().collect::>() - ); - fixture_closure_union_emit_receipt(&union) - .expect("qualified-reference control closure must compile"); - } }