From 4890f738efc2b2d71dc48bb6c1e74ae75e1a5ae4 Mon Sep 17 00:00:00 2001 From: gunbc-ci-auto-heal Date: Fri, 28 Aug 2026 00:20:53 +0000 Subject: [PATCH] Mark the seven resolved-call-emission witnesses `test fn` so the floor enrolls them MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit MAIN IS RED AND HAS BEEN SINCE 23:47, on a refusal that is correct and is catching a real defect: REQUIRED-FLOOR REFUSAL cause=BarrenTestSidecar count=1 — a `*_test.dag` entry must declare at least one `test fn`; the required floor enrolls nothing from: dag/test/claim/resolved_call_emission_identity_witness_test.dag The file declares seven `w_*() -> Bool` witnesses, each calling compile_dag_rust_emit_check with positive and negative traps, and every one of them is a plain `fn`. Floor discovery selects TestMarkedDecl, so a nullary Bool is a SHAPE and not an assertion: all seven have been dead since they landed. Marking them is the state the author plainly intended -- the names, the return type and the note calling them a PERMANENT REGRESSION CONTROL all say so. HOW MAIN BROKE, because neither PR did anything wrong on its own base: 18:43 #9436 lands the file with seven unmarked witnesses 18:56 #9499 lands the barren wall, thirteen minutes later Each was green when it merged. Squash-merge without rebase never compiles siblings together, so two disjoint green PRs broke main on contact, and the second one is the wall that makes the first one's defect visible. That is the wall working, not the wall misfiring. WHAT THIS DOES NOT CLAIM: these seven have never executed, so this change enrolls them for the first time and cannot promise they pass. If one is red, that is a real finding about post-resolution callable identity that has been invisible since #9436, and it should be read as one rather than as a regression this change introduced. Checked: no other module calls any of the seven, and no roster names them, so marking them changes no existing consumer. Co-Authored-By: Claude Opus 5 (1M context) --- ...esolved_call_emission_identity_witness_test.dag | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/dag/test/claim/resolved_call_emission_identity_witness_test.dag b/dag/test/claim/resolved_call_emission_identity_witness_test.dag index 05995c6398b..2921d33472b 100644 --- a/dag/test/claim/resolved_call_emission_identity_witness_test.dag +++ b/dag/test/claim/resolved_call_emission_identity_witness_test.dag @@ -9,7 +9,7 @@ data resolved_call_emission_identity_witness_note: String = "PERMANENT REGRESSIO // BOUNDARY CONTROL 1. The real two-String substring primitive has no declaration to resolve to, // so it stays runtime-bound. This is the arm that would go red if the repair had made emission // stop reaching the bridge at all. -fn w_two_string_substring_contains_stays_runtime_bound() -> Bool { +test fn w_two_string_substring_contains_stays_runtime_bound() -> Bool { compile_dag_rust_emit_check( "module test.claim.runtime_substring_contains_probe\nimport std.types { Bool, String }\nfn probe(s: String, sub: String) -> Bool { contains(s, sub) }\n", "src/test_claim_runtime_substring_contains_probe.rs", @@ -20,7 +20,7 @@ fn w_two_string_substring_contains_stays_runtime_bound() -> Bool { // BOUNDARY CONTROL 2. An EXACT declaration carrying a primitive projection row stays // host-lowered -- the identity is what selects the bridge, and it selects it here. -fn w_primitive_bound_empty_map_stays_runtime_bound() -> Bool { +test fn w_primitive_bound_empty_map_stays_runtime_bound() -> Bool { compile_dag_rust_emit_check( "module test.claim.runtime_empty_map_probe\nimport std.types { Int, String, Map }\nimport std.occurrence_identity { OccurrenceId }\nimport v2.std.collection { empty_map }\nfn probe() -> Map { empty_map() }\n", "src/test_claim_runtime_empty_map_probe.rs", @@ -32,7 +32,7 @@ fn w_primitive_bound_empty_map_stays_runtime_bound() -> Bool { // THE DISCRIMINATING RED, in its first live name. `contains` is both a v1_rt bridge name and an // imported v2.std.algebra declaration; before the repair the leaf spelling won and this emitted // the unrelated two-String primitive. -fn w_imported_generic_contains_keeps_declared_identity() -> Bool { +test fn w_imported_generic_contains_keeps_declared_identity() -> Bool { compile_dag_rust_emit_check( "module test.claim.declared_contains_probe\nimport std.types { Int, Bool }\nimport std.occurrence_identity { OccurrenceId }\nimport v2.std.algebra { FreeMonoid, contains }\nfn int_eq(left: Int, right: Int) -> Bool { left == right }\nfn probe(xs: FreeMonoid) -> Bool { contains(xs: xs, item: 1, eq: int_eq) }\n", "src/test_claim_declared_contains_probe.rs", @@ -46,7 +46,7 @@ fn w_imported_generic_contains_keeps_declared_identity() -> Bool { // "lower to the bridge" would go red here: the row is DivergentProjection -- the declaration // returns Outcome> and the primitive returns Optional -- and the declaration is // what the author called. -fn w_divergent_map_get_keeps_declared_outcome_identity() -> Bool { +test fn w_divergent_map_get_keeps_declared_outcome_identity() -> Bool { compile_dag_rust_emit_check( "module test.claim.declared_map_get_probe\nimport std.types { Int, String, Map }\nimport std.occurrence_identity { OccurrenceId }\nimport v2.std.collection { map_get }\nimport v2.std.diagnostic { Outcome }\nimport v2.std.optional { Optional }\nfn probe(m: Map) -> Outcome> { map_get(m: m, key: \"key\") }\n", "src/test_claim_declared_map_get_probe.rs", @@ -57,7 +57,7 @@ fn w_divergent_map_get_keeps_declared_outcome_identity() -> Bool { // A LOCAL DECLARATION UNRELATED TO ANY PRIMITIVE. Three Int parameters against the bridge's two // Strings: nothing about this call is the primitive except the four letters of its name. -fn w_unrelated_same_named_declaration_never_becomes_runtime_primitive() -> Bool { +test fn w_unrelated_same_named_declaration_never_becomes_runtime_primitive() -> Bool { compile_dag_rust_emit_check( "module test.claim.local_contains_probe\nimport std.types { Int }\nfn contains(left: Int, right: Int, third: Int) -> Int { left + right + third }\nfn probe() -> Int { contains(1, 2, 3) }\n", "src/test_claim_local_contains_probe.rs", @@ -70,7 +70,7 @@ fn w_unrelated_same_named_declaration_never_becomes_runtime_primitive() -> Bool // made call-initialized product data reach the literal/mock path, because the cross-reference // classifier did not name ExprCall as cross-referencing. It is, and the excluded string is the // mock path's own refusal text, so this row cannot pass by the call simply vanishing. -fn w_product_data_call_initializer_reaches_typed_call_emission() -> Bool { +test fn w_product_data_call_initializer_reaches_typed_call_emission() -> Bool { compile_dag_rust_emit_check( "module test.claim.product_data_call_probe\nimport std.types { String }\ntype ProbeIdentity { slug: String }\nfn make_probe_identity() -> ProbeIdentity { ProbeIdentity { slug: \"probe\" } }\ndata probe_identity: ProbeIdentity = make_probe_identity()\n", "src/test_claim_product_data_call_probe.rs", @@ -83,7 +83,7 @@ fn w_product_data_call_initializer_reaches_typed_call_emission() -> Bool { // resolves to a runtime primitive and lowers through the bridge; the excluded string is the // emitter's own Undetermined refusal, so this row goes red if a resolved call ever falls through // to that arm. -fn w_resolved_signature_owner_selects_runtime_primitive() -> Bool { +test fn w_resolved_signature_owner_selects_runtime_primitive() -> Bool { compile_dag_rust_emit_check( "module test.claim.resolved_signature_owner_probe\nimport std.types { Int, String, Map }\nfn probe(m: Map) -> Map { map_insert(m, \"key\", 1) }\n", "src/test_claim_resolved_signature_owner_probe.rs",