From 895185b39869509a7644dd8be51946b47f5f3d16 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 17:57:15 +0000 Subject: [PATCH 01/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v2/compiler/trait_derive_completeness.dag | 50 +++ src/v2/extdeps/languages/rust.dag | 11 +- src/v2/std/compilers/target_model.dag | 292 +++++++++++++++++- ...ait_derive_completeness_predicate_test.dag | 157 ++++++++++ 4 files changed, 492 insertions(+), 18 deletions(-) create mode 100644 src/v2/compiler/trait_derive_completeness.dag create mode 100644 src/v2/test/claim/trait_derive_completeness_predicate_test.dag diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag new file mode 100644 index 00000000000..2cbed3069e8 --- /dev/null +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -0,0 +1,50 @@ +module v2.compiler.trait_derive_completeness + +import v2.std.compilers.target_model { + ReprDeriveAdd, + ReprDeriveClone, + ReprDeriveOrd, + ReprDeriveSerialize, + ReprGroundingDeriveTrait, + RequiredTraitWitness, + repr_grounding_derive_completeness_predicate, + repr_grounding_derive_traits_for_collection_witness +} +import v2.std.collection { List } +import v2.std.logic { Bool } +import v2.std.node { Node } + +type TraitDeriveCompletenessGate + = TraitDeriveCompletenessSatisfied + | TraitDeriveCompletenessIncomplete + +fn trait_derive_completeness_gate( + required: List, + elem: Node +) -> TraitDeriveCompletenessGate { + if repr_grounding_derive_completeness_predicate(required: required, elem: elem) { + TraitDeriveCompletenessSatisfied + } else { + TraitDeriveCompletenessIncomplete + } +} + +fn trait_derive_completeness_gate_for_collection_witness( + witness: RequiredTraitWitness, + elem: Node +) -> TraitDeriveCompletenessGate { + trait_derive_completeness_gate( + required: repr_grounding_derive_traits_for_collection_witness(witness: witness), + elem: elem + ) +} + +fn trait_derive_completeness_gate_is_satisfied( + required: List, + elem: Node +) -> Bool { + match trait_derive_completeness_gate(required: required, elem: elem) { + TraitDeriveCompletenessSatisfied => true + TraitDeriveCompletenessIncomplete => false + } +} diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index da26320f0a8..9e4c74010d1 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -152,6 +152,7 @@ import v2.std.compilers.target_model { ValueCharUnicodeScalar, ValueSymbolToOwnedString, char_kernel_type_node, + repr_grounding_derive_surface_binding_for_coproduct, symbol_kernel_type_node, target_atom_realization_catalog_node, TargetFunctionSignatureRealization, @@ -2194,15 +2195,7 @@ fn rust_decl_struct_derive_binding() -> Symbol { } fn rust_decl_enum_derive_binding_for_coproduct(coproduct: Node) -> Symbol { - match coproduct.kind { - TypeNode { connective: Disj } => - if rust_coproduct_all_variants_nullary(edges: coproduct.children) { - ^rust_decl_derive_enum_copy_binding - } else { - ^rust_decl_derive_enum_binding - } - _ => ^rust_decl_derive_enum_binding - } + repr_grounding_derive_surface_binding_for_coproduct(coproduct: coproduct) } fn rust_decl_derive_binding_spellings() -> Map { diff --git a/src/v2/std/compilers/target_model.dag b/src/v2/std/compilers/target_model.dag index 73688dd10c2..9379b7fceb3 100644 --- a/src/v2/std/compilers/target_model.dag +++ b/src/v2/std/compilers/target_model.dag @@ -3074,6 +3074,14 @@ fn char_kernel_type_node() -> Node { } } +fn bool_kernel_type_node() -> Node { + Node { + kind: TypeNode { connective: Atom { identity: ^bool_node_symbol } }, + children: [], + occurrence_id: SyntheticOccurrence + } +} + fn source_atom_symbol(identity: Symbol) -> SourceAtomValue { SourceAtomSymbol { identity: identity } } @@ -9314,23 +9322,289 @@ fn target_collection_fallback_from_node(node: Node) -> Outcome { ) } -fn target_collection_element_ord_eligible(elem: Node) -> Bool { - match elem.kind { - TypeNode { connective: Atom { identity: id } } => - id == ^target_collection_kernel_string - || id == ^target_collection_kernel_int - || id == ^target_collection_kernel_bool - || id == ^target_collection_kernel_unit +data repr_grounding_derive_note: String = "E0308 sub-wall 2 (Gate-1 repr grounding): trait-derive completeness predicate for grounded native reprs. A grounded element satisfies a required derive trait when its modeled shape carries that trait on the emitted Rust surface (kernel carriers, Symbol->String grounding, nullary enum copy shapes). Fail-closed: unknown shapes refuse. Dissolve-on: semantic_decl + v1 emit derive selection route through repr_grounding_derive_surface_binding_* (construction), not post-hoc rustc histogram." + +type ReprGroundingDeriveTrait + = ReprDeriveClone + | ReprDeriveCopy + | ReprDerivePartialEq + | ReprDeriveEq + | ReprDerivePartialOrd + | ReprDeriveOrd + | ReprDeriveSerialize + | ReprDeriveDeserialize + | ReprDeriveAdd + | ReprDeriveSub + | ReprDeriveMul + | ReprDeriveDiv + | ReprDeriveRem + | ReprDeriveNeg + +type ReprGroundingDeriveElemShape + = ReprDeriveElemKernelString + | ReprDeriveElemKernelInt + | ReprDeriveElemKernelBool + | ReprDeriveElemKernelUnit + | ReprDeriveElemNullaryEnumCopy + | ReprDeriveElemUnknown + +fn int_kernel_type_node() -> Node { + Node { + kind: TypeNode { connective: Atom { identity: ^int_kernel_type_atom } }, + children: [], + occurrence_id: SyntheticOccurrence + } +} + +fn unit_kernel_type_node() -> Node { + Node { + kind: TypeNode { connective: Atom { identity: ^unit_kernel_type_atom } }, + children: [], + occurrence_id: SyntheticOccurrence + } +} + +fn repr_grounding_variant_edge_has_payload(edge: Edge) -> Bool { + match edge.target.kind { + TypeNode { connective: Conj } => + match edge.target.children { + Empty => false + Cons { head: _, tail: _ } => true + } _ => false } } +fn repr_grounding_coproduct_all_variants_nullary(edges: List) -> Bool { + fold_list( + xs: edges, + empty: true, + cons: fn(acc, edge) { + acc && !repr_grounding_variant_edge_has_payload(edge: edge) + } + ) +} + +fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape { + if content_hash(n: elem) == content_hash(n: symbol_kernel_type_node()) { + ReprDeriveElemKernelString + } else { + if content_hash(n: elem) == content_hash(n: int_kernel_type_node()) { + ReprDeriveElemKernelInt + } else { + if content_hash(n: elem) == content_hash(n: bool_kernel_type_node()) { + ReprDeriveElemKernelBool + } else { + if content_hash(n: elem) == content_hash(n: unit_kernel_type_node()) { + ReprDeriveElemKernelUnit + } else { + match elem.kind { + TypeNode { connective: Disj } => + if repr_grounding_coproduct_all_variants_nullary(edges: elem.children) { + ReprDeriveElemNullaryEnumCopy + } else { + ReprDeriveElemUnknown + } + TypeNode { connective: Atom { identity: id } } => + if id == ^target_collection_kernel_string + || id == ^symbol_kernel_type_atom { + ReprDeriveElemKernelString + } else { + if id == ^target_collection_kernel_int || id == ^int_kernel_type_atom { + ReprDeriveElemKernelInt + } else { + if id == ^target_collection_kernel_bool || id == ^bool_node_symbol { + ReprDeriveElemKernelBool + } else { + if id == ^target_collection_kernel_unit || id == ^unit_kernel_type_atom { + ReprDeriveElemKernelUnit + } else { + ReprDeriveElemUnknown + } + } + } + } + _ => ReprDeriveElemUnknown + } + } + } + } + } +} + +fn repr_grounding_derive_shape_has_trait( + shape: ReprGroundingDeriveElemShape, + trait: ReprGroundingDeriveTrait +) -> Bool { + match shape { + ReprDeriveElemKernelString => + match trait { + ReprDeriveClone => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemKernelInt => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + ReprDeriveAdd => true + ReprDeriveSub => true + ReprDeriveMul => true + ReprDeriveDiv => true + ReprDeriveRem => true + ReprDeriveNeg => true + } + ReprDeriveElemKernelBool => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemKernelUnit => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemNullaryEnumCopy => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemUnknown => false + } +} + +fn repr_grounding_derive_trait_satisfied( + trait: ReprGroundingDeriveTrait, + elem: Node +) -> Bool { + repr_grounding_derive_shape_has_trait( + shape: repr_grounding_derive_elem_shape(elem: elem), + trait: trait + ) +} + +fn repr_grounding_derive_completeness_predicate( + required: List, + elem: Node +) -> Bool { + fold_list( + xs: required, + empty: true, + cons: fn(acc, trait) { + acc && repr_grounding_derive_trait_satisfied(trait: trait, elem: elem) + } + ) +} + +fn repr_grounding_derive_traits_for_collection_witness( + witness: RequiredTraitWitness +) -> List { + match witness { + TargetCollectionWitnessOrd { type_param: _ } => + Cons { + head: ReprDeriveOrd, + tail: Cons { + head: ReprDerivePartialOrd, + tail: Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDeriveClone, tail: Empty } + } + } + } + } + TargetCollectionWitnessHash { type_param: _ } => + Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDeriveClone, tail: Empty } + } + } + TargetCollectionWitnessEq { type_param: _ } => + Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDeriveClone, tail: Empty } + } + } + } +} + +fn repr_grounding_derive_surface_binding_for_coproduct(coproduct: Node) -> Symbol { + match repr_grounding_derive_elem_shape(elem: coproduct) { + ReprDeriveElemNullaryEnumCopy => ^rust_decl_derive_enum_copy_binding + _ => ^rust_decl_derive_enum_binding + } +} + +fn repr_grounding_derive_surface_binding_for_record(heap_allocated: Bool) -> Symbol { + if heap_allocated { + ^rust_decl_derive_struct_binding + } else { + ^rust_decl_derive_struct_copy_binding + } +} + +fn target_collection_element_ord_eligible(elem: Node) -> Bool { + repr_grounding_derive_completeness_predicate( + required: repr_grounding_derive_traits_for_collection_witness( + witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t } + ), + elem: elem + ) +} + fn target_collection_element_hash_eligible(elem: Node) -> Bool { - target_collection_element_ord_eligible(elem: elem) + repr_grounding_derive_completeness_predicate( + required: repr_grounding_derive_traits_for_collection_witness( + witness: TargetCollectionWitnessHash { type_param: ^target_collection_type_param_t } + ), + elem: elem + ) } fn target_collection_element_eq_eligible(elem: Node) -> Bool { - target_collection_element_hash_eligible(elem: elem) + repr_grounding_derive_completeness_predicate( + required: repr_grounding_derive_traits_for_collection_witness( + witness: TargetCollectionWitnessEq { type_param: ^target_collection_type_param_t } + ), + elem: elem + ) } fn target_collection_trait_witness_satisfied( diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag new file mode 100644 index 00000000000..e24d8557aa2 --- /dev/null +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -0,0 +1,157 @@ +module v2.test.claim.trait_derive_completeness_predicate + +import v2.compiler.trait_derive_completeness { + trait_derive_completeness_gate_is_satisfied +} +import v2.std.compilers.target_model { + ReprDeriveAdd, + ReprDeriveClone, + ReprDeriveOrd, + ReprDeriveSerialize, + ReprDeriveElemKernelInt, + ReprDeriveElemKernelString, + ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemUnknown, + TargetCollectionWitnessOrd, + int_kernel_type_node, + repr_grounding_derive_completeness_predicate, + repr_grounding_derive_elem_shape, + repr_grounding_derive_surface_binding_for_coproduct, + repr_grounding_derive_surface_binding_for_record, + repr_grounding_derive_trait_satisfied, + repr_grounding_derive_traits_for_collection_witness, + symbol_kernel_type_node +} +import v2.std.algebra { Cons, Empty } +import v2.std.collection { List } +import v2.std.logic { Bool } +import v2.std.node { + Atom, + Conj, + Disj, + Edge, + Node, + Positional, + Symbol, + SyntheticOccurrence, + TypeNode +} + +data trait_derive_completeness_predicate_note: String = "Derisk witnesses for E0308 sub-wall 2: repr_grounding_derive_completeness_predicate is the single authority for whether a grounded element carries the Clone/arith/serde (+ Ord/Eq) derives its collection repr or declaration surface requires. RED: Int kernel must satisfy Add but not vice versa for String; unknown atom refuses Ord; nullary enum selects copy derive binding." + +fn tdc_nullary_enum_node() -> Node { + Node { + kind: TypeNode { connective: Disj }, + children: [ + Edge { + label: Positional, + target: Node { + kind: TypeNode { connective: Conj }, + children: [], + occurrence_id: SyntheticOccurrence + } + }, + Edge { + label: Positional, + target: Node { + kind: TypeNode { connective: Conj }, + children: [], + occurrence_id: SyntheticOccurrence + } + } + ], + occurrence_id: SyntheticOccurrence + } +} + +fn tdc_payload_enum_node() -> Node { + Node { + kind: TypeNode { connective: Disj }, + children: [ + Edge { + label: Positional, + target: Node { + kind: TypeNode { connective: Conj }, + children: [ + Edge { + label: Positional, + target: Node { + kind: TypeNode { connective: Atom { identity: ^tdc_payload_field } }, + children: [], + occurrence_id: SyntheticOccurrence + } + } + ], + occurrence_id: SyntheticOccurrence + } + } + ], + occurrence_id: SyntheticOccurrence + } +} + +fn tdc_unknown_atom_node() -> Node { + Node { + kind: TypeNode { connective: Atom { identity: ^tdc_unknown_carrier } }, + children: [], + occurrence_id: SyntheticOccurrence + } +} + +test fn tdc_string_kernel_satisfies_clone_ord_serde_not_add() -> Bool { + repr_grounding_derive_trait_satisfied(trait: ReprDeriveClone, elem: symbol_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: symbol_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(trait: ReprDeriveSerialize, elem: symbol_kernel_type_node()) + && !repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: symbol_kernel_type_node()) +} + +test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { + repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: int_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: int_kernel_type_node()) + && repr_grounding_derive_completeness_predicate( + required: Cons { + head: ReprDeriveAdd, + tail: Cons { head: ReprDeriveClone, tail: Cons { head: ReprDeriveSerialize, tail: Empty } } + }, + elem: int_kernel_type_node() + ) +} + +test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { + !repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) + && repr_grounding_derive_elem_shape(elem: tdc_unknown_atom_node()) == ReprDeriveElemUnknown + && !trait_derive_completeness_gate_is_satisfied( + required: repr_grounding_derive_traits_for_collection_witness( + witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t } + ), + elem: tdc_unknown_atom_node() + ) +} + +test fn tdc_nullary_enum_copy_shape_and_binding() -> Bool { + repr_grounding_derive_elem_shape(elem: tdc_nullary_enum_node()) == ReprDeriveElemNullaryEnumCopy + && repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_nullary_enum_node()) + == ^rust_decl_derive_enum_copy_binding + && repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_payload_enum_node()) + == ^rust_decl_derive_enum_binding +} + +test fn tdc_symbol_kernel_string_shape() -> Bool { + repr_grounding_derive_elem_shape(elem: symbol_kernel_type_node()) == ReprDeriveElemKernelString +} + +test fn tdc_record_surface_binding_heap_vs_copy() -> Bool { + repr_grounding_derive_surface_binding_for_record(heap_allocated: true) + == ^rust_decl_derive_struct_binding + && repr_grounding_derive_surface_binding_for_record(heap_allocated: false) + == ^rust_decl_derive_struct_copy_binding +} + +test fn tdc_trait_derive_completeness_predicate_witness_holds() -> Bool { + tdc_string_kernel_satisfies_clone_ord_serde_not_add() + && tdc_int_kernel_satisfies_arith_and_ord() + && tdc_unknown_atom_refuses_ord_completeness() + && tdc_nullary_enum_copy_shape_and_binding() + && tdc_symbol_kernel_string_shape() + && tdc_record_surface_binding_heap_vs_copy() +} From 4108ead0bfd8201cfc6dc4934019cdb2cb4c0842 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 18:06:51 +0000 Subject: [PATCH 02/53] Fix trait-derive witness parse errors blocking CI regen. The .dag parser rejects test bodies that start with unary `!` or use multiline `==` on enum variants; rewrite comparisons via match helpers and `== false` so heal_generated_artifacts and regen can parse the module. Co-authored-by: Cursor --- ...ait_derive_completeness_predicate_test.dag | 66 ++++++++++++++----- 1 file changed, 49 insertions(+), 17 deletions(-) diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index e24d8557aa2..c5f82b933ea 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -23,7 +23,7 @@ import v2.std.compilers.target_model { symbol_kernel_type_node } import v2.std.algebra { Cons, Empty } -import v2.std.collection { List } +import v2.std.collection { List, Symbol } import v2.std.logic { Bool } import v2.std.node { Atom, @@ -32,7 +32,6 @@ import v2.std.node { Edge, Node, Positional, - Symbol, SyntheticOccurrence, TypeNode } @@ -98,11 +97,36 @@ fn tdc_unknown_atom_node() -> Node { } } +fn tdc_elem_shape_is_unknown(elem: Node) -> Bool { + match repr_grounding_derive_elem_shape(elem: elem) { + ReprDeriveElemUnknown => true + _ => false + } +} + +fn tdc_elem_shape_is_nullary_enum_copy(elem: Node) -> Bool { + match repr_grounding_derive_elem_shape(elem: elem) { + ReprDeriveElemNullaryEnumCopy => true + _ => false + } +} + +fn tdc_elem_shape_is_kernel_string(elem: Node) -> Bool { + match repr_grounding_derive_elem_shape(elem: elem) { + ReprDeriveElemKernelString => true + _ => false + } +} + +fn tdc_binding_is(binding: Symbol, expected: Symbol) -> Bool { + binding == expected +} + test fn tdc_string_kernel_satisfies_clone_ord_serde_not_add() -> Bool { repr_grounding_derive_trait_satisfied(trait: ReprDeriveClone, elem: symbol_kernel_type_node()) && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: symbol_kernel_type_node()) && repr_grounding_derive_trait_satisfied(trait: ReprDeriveSerialize, elem: symbol_kernel_type_node()) - && !repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: symbol_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: symbol_kernel_type_node()) == false } test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { @@ -118,33 +142,41 @@ test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { } test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { - !repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) - && repr_grounding_derive_elem_shape(elem: tdc_unknown_atom_node()) == ReprDeriveElemUnknown - && !trait_derive_completeness_gate_is_satisfied( + repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) == false + && tdc_elem_shape_is_unknown(elem: tdc_unknown_atom_node()) + && trait_derive_completeness_gate_is_satisfied( required: repr_grounding_derive_traits_for_collection_witness( witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t } ), elem: tdc_unknown_atom_node() - ) + ) == false } test fn tdc_nullary_enum_copy_shape_and_binding() -> Bool { - repr_grounding_derive_elem_shape(elem: tdc_nullary_enum_node()) == ReprDeriveElemNullaryEnumCopy - && repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_nullary_enum_node()) - == ^rust_decl_derive_enum_copy_binding - && repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_payload_enum_node()) - == ^rust_decl_derive_enum_binding + tdc_elem_shape_is_nullary_enum_copy(elem: tdc_nullary_enum_node()) + && tdc_binding_is( + binding: repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_nullary_enum_node()), + expected: ^rust_decl_derive_enum_copy_binding + ) + && tdc_binding_is( + binding: repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_payload_enum_node()), + expected: ^rust_decl_derive_enum_binding + ) } test fn tdc_symbol_kernel_string_shape() -> Bool { - repr_grounding_derive_elem_shape(elem: symbol_kernel_type_node()) == ReprDeriveElemKernelString + tdc_elem_shape_is_kernel_string(elem: symbol_kernel_type_node()) } test fn tdc_record_surface_binding_heap_vs_copy() -> Bool { - repr_grounding_derive_surface_binding_for_record(heap_allocated: true) - == ^rust_decl_derive_struct_binding - && repr_grounding_derive_surface_binding_for_record(heap_allocated: false) - == ^rust_decl_derive_struct_copy_binding + tdc_binding_is( + binding: repr_grounding_derive_surface_binding_for_record(heap_allocated: true), + expected: ^rust_decl_derive_struct_binding + ) + && tdc_binding_is( + binding: repr_grounding_derive_surface_binding_for_record(heap_allocated: false), + expected: ^rust_decl_derive_struct_copy_binding + ) } test fn tdc_trait_derive_completeness_predicate_witness_holds() -> Bool { From 3b5a02e7aac46ecec3b0e22ae4b27798ba5deff0 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 18:22:39 +0000 Subject: [PATCH 03/53] Address review 42213: delete shadow nullary helpers, single elem-shape path. Remove dead rust_coproduct_* nullary predicates now superseded by repr_grounding_coproduct_all_variants_nullary, and drop the content_hash prefix in repr_grounding_derive_elem_shape so kernel identity is answered once via atom symbols. Co-authored-by: Cursor --- src/v2/extdeps/languages/rust.dag | 19 --------- src/v2/std/compilers/target_model.dag | 59 ++++++++++----------------- 2 files changed, 21 insertions(+), 57 deletions(-) diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index 9e4c74010d1..20791e29c4d 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -2171,25 +2171,6 @@ fn rust_decl_shared_derive_productions() -> List { ] } -fn rust_coproduct_variant_edge_has_payload(edge: Edge) -> Bool { - match edge.target.kind { - TypeNode { connective: Conj } => - match edge.target.children { - Empty => false - Cons { head: _, tail: _ } => true - } - _ => false - } -} - -fn rust_coproduct_all_variants_nullary(edges: List) -> Bool { - fold_list( - xs: edges, - empty: true, - cons: fn(acc, edge) { acc && !rust_coproduct_variant_edge_has_payload(edge: edge) } - ) -} - fn rust_decl_struct_derive_binding() -> Symbol { ^rust_decl_derive_struct_binding } diff --git a/src/v2/std/compilers/target_model.dag b/src/v2/std/compilers/target_model.dag index 9379b7fceb3..85c6092f226 100644 --- a/src/v2/std/compilers/target_model.dag +++ b/src/v2/std/compilers/target_model.dag @@ -9386,49 +9386,32 @@ fn repr_grounding_coproduct_all_variants_nullary(edges: List) -> Bool { } fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape { - if content_hash(n: elem) == content_hash(n: symbol_kernel_type_node()) { - ReprDeriveElemKernelString - } else { - if content_hash(n: elem) == content_hash(n: int_kernel_type_node()) { - ReprDeriveElemKernelInt - } else { - if content_hash(n: elem) == content_hash(n: bool_kernel_type_node()) { - ReprDeriveElemKernelBool + match elem.kind { + TypeNode { connective: Disj } => + if repr_grounding_coproduct_all_variants_nullary(edges: elem.children) { + ReprDeriveElemNullaryEnumCopy + } else { + ReprDeriveElemUnknown + } + TypeNode { connective: Atom { identity: id } } => + if id == ^target_collection_kernel_string || id == ^symbol_kernel_type_atom { + ReprDeriveElemKernelString } else { - if content_hash(n: elem) == content_hash(n: unit_kernel_type_node()) { - ReprDeriveElemKernelUnit + if id == ^target_collection_kernel_int || id == ^int_kernel_type_atom { + ReprDeriveElemKernelInt } else { - match elem.kind { - TypeNode { connective: Disj } => - if repr_grounding_coproduct_all_variants_nullary(edges: elem.children) { - ReprDeriveElemNullaryEnumCopy - } else { - ReprDeriveElemUnknown - } - TypeNode { connective: Atom { identity: id } } => - if id == ^target_collection_kernel_string - || id == ^symbol_kernel_type_atom { - ReprDeriveElemKernelString - } else { - if id == ^target_collection_kernel_int || id == ^int_kernel_type_atom { - ReprDeriveElemKernelInt - } else { - if id == ^target_collection_kernel_bool || id == ^bool_node_symbol { - ReprDeriveElemKernelBool - } else { - if id == ^target_collection_kernel_unit || id == ^unit_kernel_type_atom { - ReprDeriveElemKernelUnit - } else { - ReprDeriveElemUnknown - } - } - } - } - _ => ReprDeriveElemUnknown + if id == ^target_collection_kernel_bool || id == ^bool_node_symbol { + ReprDeriveElemKernelBool + } else { + if id == ^target_collection_kernel_unit || id == ^unit_kernel_type_atom { + ReprDeriveElemKernelUnit + } else { + ReprDeriveElemUnknown + } } } } - } + _ => ReprDeriveElemUnknown } } From 3e0e2bb53d1eb51e4c116893f185899d0283ede6 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 18:31:53 +0000 Subject: [PATCH 04/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v2/compiler/trait_derive_completeness.dag | 251 ++++++++++++++++- src/v2/extdeps/languages/rust.dag | 42 ++- src/v2/std/compilers/target_model.dag | 265 +----------------- ...ait_derive_completeness_predicate_test.dag | 33 +-- 4 files changed, 306 insertions(+), 285 deletions(-) diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index 2cbed3069e8..dd58fb85fd8 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -1,23 +1,254 @@ module v2.compiler.trait_derive_completeness +import v2.std.algebra { Cons, Empty, fold_list } +import v2.std.collection { List } +import v2.std.logic { Bool } +import v2.std.node { + Atom, + Conj, + Disj, + Edge, + Node, + SyntheticOccurrence, + TypeNode +} import v2.std.compilers.target_model { - ReprDeriveAdd, - ReprDeriveClone, - ReprDeriveOrd, - ReprDeriveSerialize, - ReprGroundingDeriveTrait, RequiredTraitWitness, - repr_grounding_derive_completeness_predicate, - repr_grounding_derive_traits_for_collection_witness + TargetCollectionWitnessEq, + TargetCollectionWitnessHash, + TargetCollectionWitnessOrd } -import v2.std.collection { List } -import v2.std.logic { Bool } -import v2.std.node { Node } + +data trait_derive_completeness_note: String = "Gate-1 sub-wall #2: structure-driven trait-derive completeness authority (Clone/arith/serde/ord). Agnostic predicate on modeled Node shapes — consumed by rust.dag surface-binding rows and v1 emit derive/impl selection. Fail-closed: unknown shapes refuse. NOT in target_model.dag (emit/ingest fold); mirrors wrap_decision.dag placement (#6776). Dissolve-on: three emit arms + layer-boundary mock test wire through this module." + +type ReprGroundingDeriveTrait + = ReprDeriveClone + | ReprDeriveCopy + | ReprDerivePartialEq + | ReprDeriveEq + | ReprDerivePartialOrd + | ReprDeriveOrd + | ReprDeriveSerialize + | ReprDeriveDeserialize + | ReprDeriveAdd + | ReprDeriveSub + | ReprDeriveMul + | ReprDeriveDiv + | ReprDeriveRem + | ReprDeriveNeg + +type ReprGroundingDeriveElemShape + = ReprDeriveElemKernelString + | ReprDeriveElemKernelInt + | ReprDeriveElemKernelBool + | ReprDeriveElemKernelUnit + | ReprDeriveElemNullaryEnumCopy + | ReprDeriveElemUnknown type TraitDeriveCompletenessGate = TraitDeriveCompletenessSatisfied | TraitDeriveCompletenessIncomplete +fn trait_derive_int_kernel_type_node() -> Node { + Node { + kind: TypeNode { connective: Atom { identity: ^int_kernel_type_atom } }, + children: [], + occurrence_id: SyntheticOccurrence + } +} + +fn trait_derive_unit_kernel_type_node() -> Node { + Node { + kind: TypeNode { connective: Atom { identity: ^unit_kernel_type_atom } }, + children: [], + occurrence_id: SyntheticOccurrence + } +} + +fn trait_derive_variant_edge_has_payload(edge: Edge) -> Bool { + match edge.target.kind { + TypeNode { connective: Conj } => + match edge.target.children { + Empty => false + Cons { head: _, tail: _ } => true + } + _ => false + } +} + +fn trait_derive_coproduct_all_variants_nullary(edges: List) -> Bool { + fold_list( + xs: edges, + empty: true, + cons: fn(acc, edge) { + acc && !trait_derive_variant_edge_has_payload(edge: edge) + } + ) +} + +fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape { + match elem.kind { + TypeNode { connective: Disj } => + if trait_derive_coproduct_all_variants_nullary(edges: elem.children) { + ReprDeriveElemNullaryEnumCopy + } else { + ReprDeriveElemUnknown + } + TypeNode { connective: Atom { identity: id } } => + if id == ^target_collection_kernel_string || id == ^symbol_kernel_type_atom { + ReprDeriveElemKernelString + } else { + if id == ^target_collection_kernel_int || id == ^int_kernel_type_atom { + ReprDeriveElemKernelInt + } else { + if id == ^target_collection_kernel_bool || id == ^bool_node_symbol { + ReprDeriveElemKernelBool + } else { + if id == ^target_collection_kernel_unit || id == ^unit_kernel_type_atom { + ReprDeriveElemKernelUnit + } else { + ReprDeriveElemUnknown + } + } + } + } + _ => ReprDeriveElemUnknown + } +} + +fn repr_grounding_derive_shape_has_trait( + shape: ReprGroundingDeriveElemShape, + trait: ReprGroundingDeriveTrait +) -> Bool { + match shape { + ReprDeriveElemKernelString => + match trait { + ReprDeriveClone => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemKernelInt => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + ReprDeriveAdd => true + ReprDeriveSub => true + ReprDeriveMul => true + ReprDeriveDiv => true + ReprDeriveRem => true + ReprDeriveNeg => true + } + ReprDeriveElemKernelBool => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemKernelUnit => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemNullaryEnumCopy => + match trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemUnknown => false + } +} + +fn repr_grounding_derive_trait_satisfied( + trait: ReprGroundingDeriveTrait, + elem: Node +) -> Bool { + repr_grounding_derive_shape_has_trait( + shape: repr_grounding_derive_elem_shape(elem: elem), + trait: trait + ) +} + +fn repr_grounding_derive_completeness_predicate( + required: List, + elem: Node +) -> Bool { + fold_list( + xs: required, + empty: true, + cons: fn(acc, trait) { + acc && repr_grounding_derive_trait_satisfied(trait: trait, elem: elem) + } + ) +} + +fn repr_grounding_derive_traits_for_collection_witness( + witness: RequiredTraitWitness +) -> List { + match witness { + TargetCollectionWitnessOrd { type_param: _ } => + Cons { + head: ReprDeriveOrd, + tail: Cons { + head: ReprDerivePartialOrd, + tail: Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDeriveClone, tail: Empty } + } + } + } + } + TargetCollectionWitnessHash { type_param: _ } => + Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDeriveClone, tail: Empty } + } + } + TargetCollectionWitnessEq { type_param: _ } => + Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDeriveClone, tail: Empty } + } + } + } +} + fn trait_derive_completeness_gate( required: List, elem: Node diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index 20791e29c4d..8e447e8b411 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -152,7 +152,6 @@ import v2.std.compilers.target_model { ValueCharUnicodeScalar, ValueSymbolToOwnedString, char_kernel_type_node, - repr_grounding_derive_surface_binding_for_coproduct, symbol_kernel_type_node, target_atom_realization_catalog_node, TargetFunctionSignatureRealization, @@ -2171,12 +2170,51 @@ fn rust_decl_shared_derive_productions() -> List { ] } +fn rust_coproduct_variant_edge_has_payload(edge: Edge) -> Bool { + match edge.target.kind { + TypeNode { connective: Conj } => + match edge.target.children { + Empty => false + Cons { head: _, tail: _ } => true + } + _ => false + } +} + +fn rust_coproduct_all_variants_nullary(edges: List) -> Bool { + fold_list( + xs: edges, + empty: true, + cons: fn(acc, edge) { acc && !rust_coproduct_variant_edge_has_payload(edge: edge) } + ) +} + +fn rust_trait_derive_surface_binding_for_coproduct(coproduct: Node) -> Symbol { + match coproduct.kind { + TypeNode { connective: Disj } => + if rust_coproduct_all_variants_nullary(edges: coproduct.children) { + ^rust_decl_derive_enum_copy_binding + } else { + ^rust_decl_derive_enum_binding + } + _ => ^rust_decl_derive_enum_binding + } +} + +fn rust_trait_derive_surface_binding_for_record(heap_allocated: Bool) -> Symbol { + if heap_allocated { + ^rust_decl_derive_struct_binding + } else { + ^rust_decl_derive_struct_copy_binding + } +} + fn rust_decl_struct_derive_binding() -> Symbol { ^rust_decl_derive_struct_binding } fn rust_decl_enum_derive_binding_for_coproduct(coproduct: Node) -> Symbol { - repr_grounding_derive_surface_binding_for_coproduct(coproduct: coproduct) + rust_trait_derive_surface_binding_for_coproduct(coproduct: coproduct) } fn rust_decl_derive_binding_spellings() -> Map { diff --git a/src/v2/std/compilers/target_model.dag b/src/v2/std/compilers/target_model.dag index 85c6092f226..357c17c0204 100644 --- a/src/v2/std/compilers/target_model.dag +++ b/src/v2/std/compilers/target_model.dag @@ -9322,272 +9322,23 @@ fn target_collection_fallback_from_node(node: Node) -> Outcome { ) } -data repr_grounding_derive_note: String = "E0308 sub-wall 2 (Gate-1 repr grounding): trait-derive completeness predicate for grounded native reprs. A grounded element satisfies a required derive trait when its modeled shape carries that trait on the emitted Rust surface (kernel carriers, Symbol->String grounding, nullary enum copy shapes). Fail-closed: unknown shapes refuse. Dissolve-on: semantic_decl + v1 emit derive selection route through repr_grounding_derive_surface_binding_* (construction), not post-hoc rustc histogram." - -type ReprGroundingDeriveTrait - = ReprDeriveClone - | ReprDeriveCopy - | ReprDerivePartialEq - | ReprDeriveEq - | ReprDerivePartialOrd - | ReprDeriveOrd - | ReprDeriveSerialize - | ReprDeriveDeserialize - | ReprDeriveAdd - | ReprDeriveSub - | ReprDeriveMul - | ReprDeriveDiv - | ReprDeriveRem - | ReprDeriveNeg - -type ReprGroundingDeriveElemShape - = ReprDeriveElemKernelString - | ReprDeriveElemKernelInt - | ReprDeriveElemKernelBool - | ReprDeriveElemKernelUnit - | ReprDeriveElemNullaryEnumCopy - | ReprDeriveElemUnknown - -fn int_kernel_type_node() -> Node { - Node { - kind: TypeNode { connective: Atom { identity: ^int_kernel_type_atom } }, - children: [], - occurrence_id: SyntheticOccurrence - } -} - -fn unit_kernel_type_node() -> Node { - Node { - kind: TypeNode { connective: Atom { identity: ^unit_kernel_type_atom } }, - children: [], - occurrence_id: SyntheticOccurrence - } -} - -fn repr_grounding_variant_edge_has_payload(edge: Edge) -> Bool { - match edge.target.kind { - TypeNode { connective: Conj } => - match edge.target.children { - Empty => false - Cons { head: _, tail: _ } => true - } - _ => false - } -} - -fn repr_grounding_coproduct_all_variants_nullary(edges: List) -> Bool { - fold_list( - xs: edges, - empty: true, - cons: fn(acc, edge) { - acc && !repr_grounding_variant_edge_has_payload(edge: edge) - } - ) -} - -fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape { +fn target_collection_element_ord_eligible(elem: Node) -> Bool { match elem.kind { - TypeNode { connective: Disj } => - if repr_grounding_coproduct_all_variants_nullary(edges: elem.children) { - ReprDeriveElemNullaryEnumCopy - } else { - ReprDeriveElemUnknown - } TypeNode { connective: Atom { identity: id } } => - if id == ^target_collection_kernel_string || id == ^symbol_kernel_type_atom { - ReprDeriveElemKernelString - } else { - if id == ^target_collection_kernel_int || id == ^int_kernel_type_atom { - ReprDeriveElemKernelInt - } else { - if id == ^target_collection_kernel_bool || id == ^bool_node_symbol { - ReprDeriveElemKernelBool - } else { - if id == ^target_collection_kernel_unit || id == ^unit_kernel_type_atom { - ReprDeriveElemKernelUnit - } else { - ReprDeriveElemUnknown - } - } - } - } - _ => ReprDeriveElemUnknown - } -} - -fn repr_grounding_derive_shape_has_trait( - shape: ReprGroundingDeriveElemShape, - trait: ReprGroundingDeriveTrait -) -> Bool { - match shape { - ReprDeriveElemKernelString => - match trait { - ReprDeriveClone => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemKernelInt => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - ReprDeriveAdd => true - ReprDeriveSub => true - ReprDeriveMul => true - ReprDeriveDiv => true - ReprDeriveRem => true - ReprDeriveNeg => true - } - ReprDeriveElemKernelBool => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemKernelUnit => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemNullaryEnumCopy => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemUnknown => false - } -} - -fn repr_grounding_derive_trait_satisfied( - trait: ReprGroundingDeriveTrait, - elem: Node -) -> Bool { - repr_grounding_derive_shape_has_trait( - shape: repr_grounding_derive_elem_shape(elem: elem), - trait: trait - ) -} - -fn repr_grounding_derive_completeness_predicate( - required: List, - elem: Node -) -> Bool { - fold_list( - xs: required, - empty: true, - cons: fn(acc, trait) { - acc && repr_grounding_derive_trait_satisfied(trait: trait, elem: elem) - } - ) -} - -fn repr_grounding_derive_traits_for_collection_witness( - witness: RequiredTraitWitness -) -> List { - match witness { - TargetCollectionWitnessOrd { type_param: _ } => - Cons { - head: ReprDeriveOrd, - tail: Cons { - head: ReprDerivePartialOrd, - tail: Cons { - head: ReprDeriveEq, - tail: Cons { - head: ReprDerivePartialEq, - tail: Cons { head: ReprDeriveClone, tail: Empty } - } - } - } - } - TargetCollectionWitnessHash { type_param: _ } => - Cons { - head: ReprDeriveEq, - tail: Cons { - head: ReprDerivePartialEq, - tail: Cons { head: ReprDeriveClone, tail: Empty } - } - } - TargetCollectionWitnessEq { type_param: _ } => - Cons { - head: ReprDeriveEq, - tail: Cons { - head: ReprDerivePartialEq, - tail: Cons { head: ReprDeriveClone, tail: Empty } - } - } - } -} - -fn repr_grounding_derive_surface_binding_for_coproduct(coproduct: Node) -> Symbol { - match repr_grounding_derive_elem_shape(elem: coproduct) { - ReprDeriveElemNullaryEnumCopy => ^rust_decl_derive_enum_copy_binding - _ => ^rust_decl_derive_enum_binding - } -} - -fn repr_grounding_derive_surface_binding_for_record(heap_allocated: Bool) -> Symbol { - if heap_allocated { - ^rust_decl_derive_struct_binding - } else { - ^rust_decl_derive_struct_copy_binding + id == ^target_collection_kernel_string + || id == ^target_collection_kernel_int + || id == ^target_collection_kernel_bool + || id == ^target_collection_kernel_unit + _ => false } } -fn target_collection_element_ord_eligible(elem: Node) -> Bool { - repr_grounding_derive_completeness_predicate( - required: repr_grounding_derive_traits_for_collection_witness( - witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t } - ), - elem: elem - ) -} - fn target_collection_element_hash_eligible(elem: Node) -> Bool { - repr_grounding_derive_completeness_predicate( - required: repr_grounding_derive_traits_for_collection_witness( - witness: TargetCollectionWitnessHash { type_param: ^target_collection_type_param_t } - ), - elem: elem - ) + target_collection_element_ord_eligible(elem: elem) } fn target_collection_element_eq_eligible(elem: Node) -> Bool { - repr_grounding_derive_completeness_predicate( - required: repr_grounding_derive_traits_for_collection_witness( - witness: TargetCollectionWitnessEq { type_param: ^target_collection_type_param_t } - ), - elem: elem - ) + target_collection_element_hash_eligible(elem: elem) } fn target_collection_trait_witness_satisfied( diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index c5f82b933ea..9bbcda9064e 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -1,25 +1,26 @@ module v2.test.claim.trait_derive_completeness_predicate import v2.compiler.trait_derive_completeness { - trait_derive_completeness_gate_is_satisfied -} -import v2.std.compilers.target_model { ReprDeriveAdd, ReprDeriveClone, ReprDeriveOrd, ReprDeriveSerialize, - ReprDeriveElemKernelInt, ReprDeriveElemKernelString, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, - TargetCollectionWitnessOrd, - int_kernel_type_node, repr_grounding_derive_completeness_predicate, repr_grounding_derive_elem_shape, - repr_grounding_derive_surface_binding_for_coproduct, - repr_grounding_derive_surface_binding_for_record, repr_grounding_derive_trait_satisfied, repr_grounding_derive_traits_for_collection_witness, + trait_derive_completeness_gate_is_satisfied, + trait_derive_int_kernel_type_node +} +import v2.extdeps.languages.rust { + rust_trait_derive_surface_binding_for_coproduct, + rust_trait_derive_surface_binding_for_record +} +import v2.std.compilers.target_model { + TargetCollectionWitnessOrd, symbol_kernel_type_node } import v2.std.algebra { Cons, Empty } @@ -36,7 +37,7 @@ import v2.std.node { TypeNode } -data trait_derive_completeness_predicate_note: String = "Derisk witnesses for E0308 sub-wall 2: repr_grounding_derive_completeness_predicate is the single authority for whether a grounded element carries the Clone/arith/serde (+ Ord/Eq) derives its collection repr or declaration surface requires. RED: Int kernel must satisfy Add but not vice versa for String; unknown atom refuses Ord; nullary enum selects copy derive binding." +data trait_derive_completeness_predicate_note: String = "Derisk witnesses for Gate-1 sub-wall #2: trait_derive_completeness.dag is the agnostic predicate authority; rust.dag owns surface-binding rows. RED: Int kernel must satisfy Add but not vice versa for String; unknown atom refuses Ord; nullary enum selects copy derive binding." fn tdc_nullary_enum_node() -> Node { Node { @@ -130,14 +131,14 @@ test fn tdc_string_kernel_satisfies_clone_ord_serde_not_add() -> Bool { } test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { - repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: int_kernel_type_node()) - && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: int_kernel_type_node()) + repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: trait_derive_int_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: trait_derive_int_kernel_type_node()) && repr_grounding_derive_completeness_predicate( required: Cons { head: ReprDeriveAdd, tail: Cons { head: ReprDeriveClone, tail: Cons { head: ReprDeriveSerialize, tail: Empty } } }, - elem: int_kernel_type_node() + elem: trait_derive_int_kernel_type_node() ) } @@ -155,11 +156,11 @@ test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { test fn tdc_nullary_enum_copy_shape_and_binding() -> Bool { tdc_elem_shape_is_nullary_enum_copy(elem: tdc_nullary_enum_node()) && tdc_binding_is( - binding: repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_nullary_enum_node()), + binding: rust_trait_derive_surface_binding_for_coproduct(coproduct: tdc_nullary_enum_node()), expected: ^rust_decl_derive_enum_copy_binding ) && tdc_binding_is( - binding: repr_grounding_derive_surface_binding_for_coproduct(coproduct: tdc_payload_enum_node()), + binding: rust_trait_derive_surface_binding_for_coproduct(coproduct: tdc_payload_enum_node()), expected: ^rust_decl_derive_enum_binding ) } @@ -170,11 +171,11 @@ test fn tdc_symbol_kernel_string_shape() -> Bool { test fn tdc_record_surface_binding_heap_vs_copy() -> Bool { tdc_binding_is( - binding: repr_grounding_derive_surface_binding_for_record(heap_allocated: true), + binding: rust_trait_derive_surface_binding_for_record(heap_allocated: true), expected: ^rust_decl_derive_struct_binding ) && tdc_binding_is( - binding: repr_grounding_derive_surface_binding_for_record(heap_allocated: false), + binding: rust_trait_derive_surface_binding_for_record(heap_allocated: false), expected: ^rust_decl_derive_struct_copy_binding ) } From 9b022aef5a8d7dce7e37a40562e34ee287e7ecf8 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 18:45:20 +0000 Subject: [PATCH 05/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v2/compiler/trait_derive_completeness.dag | 10 ++++++++++ src/v2/std/compilers/target_model.dag | 8 -------- .../claim/trait_derive_completeness_predicate_test.dag | 9 +++------ 3 files changed, 13 insertions(+), 14 deletions(-) diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index dd58fb85fd8..f3878760a29 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -270,6 +270,16 @@ fn trait_derive_completeness_gate_for_collection_witness( ) } +fn trait_derive_completeness_collection_witness_is_satisfied( + witness: RequiredTraitWitness, + elem: Node +) -> Bool { + match trait_derive_completeness_gate_for_collection_witness(witness: witness, elem: elem) { + TraitDeriveCompletenessSatisfied => true + TraitDeriveCompletenessIncomplete => false + } +} + fn trait_derive_completeness_gate_is_satisfied( required: List, elem: Node diff --git a/src/v2/std/compilers/target_model.dag b/src/v2/std/compilers/target_model.dag index 357c17c0204..73688dd10c2 100644 --- a/src/v2/std/compilers/target_model.dag +++ b/src/v2/std/compilers/target_model.dag @@ -3074,14 +3074,6 @@ fn char_kernel_type_node() -> Node { } } -fn bool_kernel_type_node() -> Node { - Node { - kind: TypeNode { connective: Atom { identity: ^bool_node_symbol } }, - children: [], - occurrence_id: SyntheticOccurrence - } -} - fn source_atom_symbol(identity: Symbol) -> SourceAtomValue { SourceAtomSymbol { identity: identity } } diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index 9bbcda9064e..d9201030bc8 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -11,8 +11,7 @@ import v2.compiler.trait_derive_completeness { repr_grounding_derive_completeness_predicate, repr_grounding_derive_elem_shape, repr_grounding_derive_trait_satisfied, - repr_grounding_derive_traits_for_collection_witness, - trait_derive_completeness_gate_is_satisfied, + trait_derive_completeness_collection_witness_is_satisfied, trait_derive_int_kernel_type_node } import v2.extdeps.languages.rust { @@ -145,10 +144,8 @@ test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) == false && tdc_elem_shape_is_unknown(elem: tdc_unknown_atom_node()) - && trait_derive_completeness_gate_is_satisfied( - required: repr_grounding_derive_traits_for_collection_witness( - witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t } - ), + && trait_derive_completeness_collection_witness_is_satisfied( + witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t }, elem: tdc_unknown_atom_node() ) == false } From 7ae4780f37ff78be86c8823b524d6527da44c161 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 18:55:54 +0000 Subject: [PATCH 06/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v2/compiler/trait_derive_completeness.dag | 44 +------------------ src/v2/extdeps/languages/rust.dag | 22 +--------- .../std/compilers/coproduct_variant_shape.dag | 29 ++++++++++++ .../std/compilers/semantic_decl_emission.dag | 33 +++++--------- ...ait_derive_completeness_predicate_test.dag | 19 ++++++-- 5 files changed, 59 insertions(+), 88 deletions(-) create mode 100644 src/v2/std/compilers/coproduct_variant_shape.dag diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index f3878760a29..bcf47da66da 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -12,6 +12,7 @@ import v2.std.node { SyntheticOccurrence, TypeNode } +import v2.std.compilers.coproduct_variant_shape { coproduct_all_variants_nullary } import v2.std.compilers.target_model { RequiredTraitWitness, TargetCollectionWitnessEq, @@ -65,31 +66,10 @@ fn trait_derive_unit_kernel_type_node() -> Node { } } -fn trait_derive_variant_edge_has_payload(edge: Edge) -> Bool { - match edge.target.kind { - TypeNode { connective: Conj } => - match edge.target.children { - Empty => false - Cons { head: _, tail: _ } => true - } - _ => false - } -} - -fn trait_derive_coproduct_all_variants_nullary(edges: List) -> Bool { - fold_list( - xs: edges, - empty: true, - cons: fn(acc, edge) { - acc && !trait_derive_variant_edge_has_payload(edge: edge) - } - ) -} - fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape { match elem.kind { TypeNode { connective: Disj } => - if trait_derive_coproduct_all_variants_nullary(edges: elem.children) { + if coproduct_all_variants_nullary(edges: elem.children) { ReprDeriveElemNullaryEnumCopy } else { ReprDeriveElemUnknown @@ -269,23 +249,3 @@ fn trait_derive_completeness_gate_for_collection_witness( elem: elem ) } - -fn trait_derive_completeness_collection_witness_is_satisfied( - witness: RequiredTraitWitness, - elem: Node -) -> Bool { - match trait_derive_completeness_gate_for_collection_witness(witness: witness, elem: elem) { - TraitDeriveCompletenessSatisfied => true - TraitDeriveCompletenessIncomplete => false - } -} - -fn trait_derive_completeness_gate_is_satisfied( - required: List, - elem: Node -) -> Bool { - match trait_derive_completeness_gate(required: required, elem: elem) { - TraitDeriveCompletenessSatisfied => true - TraitDeriveCompletenessIncomplete => false - } -} diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index 8e447e8b411..fb375b55ec3 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -97,6 +97,7 @@ import v2.std.model_core { PrimitiveFactBundle, PrimitiveOperationRef } +import v2.std.compilers.coproduct_variant_shape { coproduct_all_variants_nullary } import v2.std.compilers.target_model { ConcreteSyntaxToken, FixedToken, @@ -2170,29 +2171,10 @@ fn rust_decl_shared_derive_productions() -> List { ] } -fn rust_coproduct_variant_edge_has_payload(edge: Edge) -> Bool { - match edge.target.kind { - TypeNode { connective: Conj } => - match edge.target.children { - Empty => false - Cons { head: _, tail: _ } => true - } - _ => false - } -} - -fn rust_coproduct_all_variants_nullary(edges: List) -> Bool { - fold_list( - xs: edges, - empty: true, - cons: fn(acc, edge) { acc && !rust_coproduct_variant_edge_has_payload(edge: edge) } - ) -} - fn rust_trait_derive_surface_binding_for_coproduct(coproduct: Node) -> Symbol { match coproduct.kind { TypeNode { connective: Disj } => - if rust_coproduct_all_variants_nullary(edges: coproduct.children) { + if coproduct_all_variants_nullary(edges: coproduct.children) { ^rust_decl_derive_enum_copy_binding } else { ^rust_decl_derive_enum_binding diff --git a/src/v2/std/compilers/coproduct_variant_shape.dag b/src/v2/std/compilers/coproduct_variant_shape.dag new file mode 100644 index 00000000000..89b4f1d285f --- /dev/null +++ b/src/v2/std/compilers/coproduct_variant_shape.dag @@ -0,0 +1,29 @@ +module v2.std.compilers.coproduct_variant_shape + +import v2.std.algebra { Cons, Empty, fold_list } +import v2.std.collection { List } +import v2.std.logic { Bool } +import v2.std.node { Conj, Edge, TypeNode } + +data coproduct_variant_shape_note: String = "Single authority for nullary vs payload-bearing coproduct variant classification (Conj-child presence on variant targets). Consumed by semantic_decl_emission decoration rules, rust derive-binding rows, and trait_derive_completeness elem-shape. Fail-closed: non-Conj targets carry no payload." + +fn coproduct_variant_edge_has_payload(edge: Edge) -> Bool { + match edge.target.kind { + TypeNode { connective: Conj } => + match edge.target.children { + Empty => false + Cons { head: _, tail: _ } => true + } + _ => false + } +} + +fn coproduct_all_variants_nullary(edges: List) -> Bool { + fold_list( + xs: edges, + empty: true, + cons: fn(acc, edge) { + acc && !coproduct_variant_edge_has_payload(edge: edge) + } + ) +} diff --git a/src/v2/std/compilers/semantic_decl_emission.dag b/src/v2/std/compilers/semantic_decl_emission.dag index a75bf1dc9fa..2b26725e4ee 100644 --- a/src/v2/std/compilers/semantic_decl_emission.dag +++ b/src/v2/std/compilers/semantic_decl_emission.dag @@ -1,5 +1,9 @@ module v2.std.compilers.semantic_decl_emission +import v2.std.compilers.coproduct_variant_shape { + coproduct_all_variants_nullary, + coproduct_variant_edge_has_payload +} import v2.std.compilers.lexing { CharClassPattern, IdentContinueChar, @@ -1752,24 +1756,7 @@ fn target_semantic_decl_surface_generic_params(params: List) -> Node { ) } -data target_semantic_decl_shape_predicate_dissolution_note: String = "🟡 dissolve-on: target_semantic_decl_variant_edge_has_payload and target_semantic_decl_coproduct_has_shape_rule are interim Node-tree shape predicates for coproduct decoration selection; dissolve when decoration rules key on typed surface facts from the bundle authority, not Conj-child presence heuristics." - -fn target_semantic_decl_variant_edge_has_payload(edge: Edge) -> Bool { - match edge.target.kind { - TypeNode { connective: Conj } => !is_empty(xs: edge.target.children) - _ => false - } -} - -fn target_semantic_decl_coproduct_all_variants_nullary(edges: List) -> Bool { - fold_list( - xs: edges, - empty: true, - cons: fn(acc, edge) { - acc && !target_semantic_decl_variant_edge_has_payload(edge: edge) - } - ) -} +data target_semantic_decl_shape_predicate_dissolution_note: String = "DISSOLVED 2026-07-24 (silent-badger-23): nullary/payload coproduct variant walk consolidated onto v2.std.compilers.coproduct_variant_shape (single authority). Remaining dissolve-on: decoration rules key on typed surface facts from the bundle authority, not ad-hoc Conj-child heuristics at call sites." fn semantic_decl_coproduct_shape_key_unsupported_connective_diagnostic( coproduct: Node @@ -1784,7 +1771,7 @@ fn semantic_decl_coproduct_shape_key_unsupported_connective_diagnostic( fn target_semantic_decl_coproduct_shape_key(coproduct: Node) -> Outcome { match coproduct.kind { TypeNode { connective: Disj } => - if target_semantic_decl_coproduct_all_variants_nullary(edges: coproduct.children) { + if coproduct_all_variants_nullary(edges: coproduct.children) { outcome_accepted(value: ^semantic_decl_coproduct_shape_all_variants_nullary) } else { outcome_accepted(value: ^semantic_decl_coproduct_shape_default) @@ -1922,7 +1909,7 @@ fn target_semantic_decl_tagged_union_variant_surface_from_edge( ) -> Outcome { match edge.label { Named { name: vname } => - if target_semantic_decl_variant_edge_has_payload(edge: edge) { + if coproduct_variant_edge_has_payload(edge: edge) { bind_outcome( o: target_semantic_decl_field_surfaces( edges: edge.target.children, @@ -1981,7 +1968,7 @@ fn target_semantic_decl_variant_surface_from_edge( ) -> Outcome { match edge.label { Named { name: vname } => - if target_semantic_decl_variant_edge_has_payload(edge: edge) { + if coproduct_variant_edge_has_payload(edge: edge) { bind_outcome( o: target_semantic_decl_field_surfaces( edges: edge.target.children, @@ -2045,7 +2032,7 @@ fn target_semantic_decl_variant_surfaces_for_coproduct( coproduct: Node ) -> Outcome> { if target_semantic_decl_coproduct_uses_tagged_union_layout(layout: projection.coproduct_layout) - && !target_semantic_decl_coproduct_all_variants_nullary(edges: coproduct.children) + && !coproduct_all_variants_nullary(edges: coproduct.children) { target_semantic_decl_tagged_union_variant_surfaces( edges: coproduct.children, @@ -2082,7 +2069,7 @@ fn target_semantic_enum_surface_from_coproduct( if target_semantic_decl_coproduct_uses_tagged_union_layout( layout: projection.coproduct_layout ) - && !target_semantic_decl_coproduct_all_variants_nullary(edges: coproduct.children) + && !coproduct_all_variants_nullary(edges: coproduct.children) { if is_empty(xs: params) { outcome_accepted( diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index d9201030bc8..2f66b7db902 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -8,10 +8,12 @@ import v2.compiler.trait_derive_completeness { ReprDeriveElemKernelString, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, + TraitDeriveCompletenessIncomplete, + TraitDeriveCompletenessSatisfied, repr_grounding_derive_completeness_predicate, repr_grounding_derive_elem_shape, repr_grounding_derive_trait_satisfied, - trait_derive_completeness_collection_witness_is_satisfied, + trait_derive_completeness_gate_for_collection_witness, trait_derive_int_kernel_type_node } import v2.extdeps.languages.rust { @@ -19,6 +21,7 @@ import v2.extdeps.languages.rust { rust_trait_derive_surface_binding_for_record } import v2.std.compilers.target_model { + RequiredTraitWitness, TargetCollectionWitnessOrd, symbol_kernel_type_node } @@ -118,6 +121,16 @@ fn tdc_elem_shape_is_kernel_string(elem: Node) -> Bool { } } +fn tdc_collection_witness_gate_is_incomplete( + witness: RequiredTraitWitness, + elem: Node +) -> Bool { + match trait_derive_completeness_gate_for_collection_witness(witness: witness, elem: elem) { + TraitDeriveCompletenessIncomplete => true + TraitDeriveCompletenessSatisfied => false + } +} + fn tdc_binding_is(binding: Symbol, expected: Symbol) -> Bool { binding == expected } @@ -144,10 +157,10 @@ test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) == false && tdc_elem_shape_is_unknown(elem: tdc_unknown_atom_node()) - && trait_derive_completeness_collection_witness_is_satisfied( + && tdc_collection_witness_gate_is_incomplete( witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t }, elem: tdc_unknown_atom_node() - ) == false + ) } test fn tdc_nullary_enum_copy_shape_and_binding() -> Bool { From 5029dcf3f47a184381d09b77c5bcc3e9c332a7f6 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 19:36:51 +0000 Subject: [PATCH 07/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/gunbc/non_fold_residue.dag | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/dag/gunbc/non_fold_residue.dag b/dag/gunbc/non_fold_residue.dag index c9e75ee67d1..876776c43a5 100644 --- a/dag/gunbc/non_fold_residue.dag +++ b/dag/gunbc/non_fold_residue.dag @@ -46,6 +46,10 @@ data nfr_reason_ci_floor_gate_membership: String = "gate-identity membership fol data nfr_dissolve_gate_membership: String = "derived equality on Gate from inhabitance lands (dag/std/algebra, DESIGN §3/§4): the nested per-variant match is a hand-rolled sg-equals-g test, so the membership fold collapses to found or sg == g, the nested matches delete, and the row deletes with them" +data nfr_reason_trait_derive_shape_table: String = "trait-shape→derive-trait capability table (nested match on ReprGroundingDeriveElemShape × ReprGroundingDeriveTrait with off-trait wildcard arms returning false) landed with Gate-1 sub-wall #2 predicate scaffold (#7174); surfaced by whole-corpus nfr receipt after affected-set predict-skipped corpus-read witness at landing" + +data nfr_dissolve_trait_derive_shape_table: String = "the three emit arms wire derive/impl selection through trait_derive_completeness.dag and the hand table migrates to derived rows (or a total match) — row deletes with the emit wiring landing" + data nfr_reason_native_agreement_octet: String = "RuntimeValue primitive-discriminant projection (RuntimePrimitive arm extracts byte[1]; off-variant wildcard Absent) landed with Lane B native-agreement loudness (#7111); surfaced by whole-corpus nfr receipt after affected-set predict-skipped corpus-read witness at landing" data nfr_dissolve_native_agreement_octet: String = "RuntimeValue model↔realization grounds each primitive variant and the wildcard arm migrates to a total match — or the receipt formatter derives from inhabitance and the row deletes" @@ -671,6 +675,11 @@ data non_fold_residue_frontier: List = [ reason: nfr_reason_mint_era, dissolve_on: nfr_dissolve_wildcard_total }, + FrontierRow { + unit: "src/v2/compiler/trait_derive_completeness.dag::repr_grounding_derive_shape_has_trait", + reason: nfr_reason_trait_derive_shape_table, + dissolve_on: nfr_dissolve_trait_derive_shape_table + }, FrontierRow { unit: "src/v2/workflow/ci_floor_plan.dag::gate_in_cheap_floor_membership", reason: nfr_reason_ci_floor_gate_membership, From 0934c5a6724e84eda0471b9f311ebe8f7422de6f Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 22:12:49 +0000 Subject: [PATCH 08/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/05_emit_rust.dag | 48 ++--- src/v1/trait_derive_emit.dag | 380 +++++++++++++++++++++++++++++++++++ 2 files changed, 404 insertions(+), 24 deletions(-) create mode 100644 src/v1/trait_derive_emit.dag diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag index d8f7460cc08..6334287cfb8 100644 --- a/src/v1/05_emit_rust.dag +++ b/src/v1/05_emit_rust.dag @@ -55,6 +55,10 @@ import v1.compiler.compiler_tests_rust { compiler_tests_source } import v1.compiler.closure_stub_v2_std_integer_rust { closure_stub_v2_std_integer_source } import v1.compiler.closure_stub_v2_std_text_rust { closure_stub_v2_std_text_source } import v1.compiler.coercion { coerce_primitive_type, is_copy, lookup_checkpoint } +import v1.compiler.trait_derive_emit { + v1_emit_struct_derives, v1_emit_enum_derives, + v1_generic_params_needing_clone_bound, v1_emit_type_params_with_clone_bounds +} import std.types { is_container_type, is_kernel_type, container_template_algebra } import std.serialization { CoproductWireContract, VariantEncoding, VariantNaming } @@ -4523,15 +4527,13 @@ fn struct_needs_serde(name: String, emit_info: EmitGraphInfo) -> Bool { fn emit_struct_from_children(name: String, type_params: String, generic_param_names: List, children: List, recursive_types: Set, shared_types: Set, env: TypeEnv, emit_info: EmitGraphInfo) -> String { let has_fn_fields = type_has_fn_fields(name: name, emit_info: emit_info) - let derives = if has_fn_fields { - "#[derive(Clone)]" - } else if rust_nominal_ord_derives_for_shape(name: name, children: children, source_indices: env.source_indices) != "" { - rust_nominal_ord_derives_for_shape(name: name, children: children, source_indices: env.source_indices) - } else if set_contains(shared_types, name) { - rust_struct_derives_text() - } else { - rust_struct_derives_copy_text() - } + let derives = v1_emit_struct_derives( + name: name, + children: children, + shared_types: shared_types, + has_fn_fields: has_fn_fields, + source_indices: env.source_indices + ) if children |> count == 0 { concat(derives, "\n", rust_visibility_prefix(), rust_items().struct_keyword, " ", name, type_params, ";") } else { @@ -4649,16 +4651,12 @@ fn emit_rust_field_definition(authored: String, final_ty: String, rename_attr: S concat(keyword_rename, rename_attr, indent, visibility, emitted, ": ", final_ty, ",") } -fn enum_derives(name: String, children: List) -> String { - let complex = children |> filter(v => v.children |> count > 0) - match complex |> count == 0 { - true => rust_ord_derives_copy_text() - false => rust_enum_derives_text() - } +fn enum_derives(name: String, children: List, source_indices: Map) -> String { + v1_emit_enum_derives(children: children, source_indices: source_indices) } fn emit_enum_from_children(name: String, type_params: String, generic_param_names: List, children: List, recursive_types: Set, shared_types: Set, env: TypeEnv, serde_policy: RustEnumWireSerde, emit_info: EmitGraphInfo) -> String { - let derives = enum_derives(name: name, children: children) + let derives = enum_derives(name: name, children: children, source_indices: env.source_indices) let variant_lines = children |> map(child => emit_variant_from_child(child: child, enum_name: name, generic_param_names: generic_param_names, recursive_types: recursive_types, shared_types: shared_types, env: env, serde_policy: serde_policy, emit_info: emit_info)) let variants_str = variant_lines |> join(separator: "\n") let tag_line = if serde_policy.enum_attr == "" { "" } else { concat(serde_policy.enum_attr, "\n") } @@ -4994,15 +4992,17 @@ fn emit_fn_def(name: String, params: List, inferred: Node, body: Node, reg let return_is_bare_generic = (generic_param_names |> filter(g => g == ret_name) |> count) > 0 let body_is_param_ref = (value_param_names |> filter(n => n == body.name) |> count) > 0 let return_based_clone = return_is_bare_generic && !body_is_param_ref - let element_clone_param = if body_is_param_ref { none } else { - generic_param_names |> filter(g => type_param_is_collection_element_in_values(param_name: g, value_params: value_params, source_indices: si)) |> first - } - let clone_param = if return_based_clone { ret_name } else { - match element_clone_param { Present { value: g } => g Absent => "" } - } - let needs_clone_bound = clone_param != "" + let clone_param_names = v1_generic_params_needing_clone_bound( + generic_param_names: generic_param_names, + value_params: value_params, + return_is_bare_generic: return_is_bare_generic, + ret_name: ret_name, + body_is_param_ref: body_is_param_ref, + source_indices: si + ) + let needs_clone_bound = (clone_param_names |> count) > 0 let type_params_str = if needs_clone_bound { - emit_type_params_with_clone_bound(params: type_params, clone_param: clone_param, source_indices: si) + v1_emit_type_params_with_clone_bounds(params: type_params, clone_param_names: clone_param_names, source_indices: si) } else { emit_type_params(params: type_params, source_indices: si) } diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag new file mode 100644 index 00000000000..28d170094d3 --- /dev/null +++ b/src/v1/trait_derive_emit.dag @@ -0,0 +1,380 @@ +module v1.compiler.trait_derive_emit + +import v1.std.core { + Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, + Disj, NoConnective +} +import v1.compiler.infer_types { is_coproduct_type, child_type_node } +import v1.compiler.emit { to_pascal } +import std.types { is_kernel_type, is_container_type } +import std.algebra { Cons, Empty, fold_list } + +data v1_trait_derive_emit_note: String = "V1 seed-emitter realization of v2.compiler.trait_derive_completeness — structure-driven derive/bound selection for 05_emit_rust.dag. Fail-closed: unknown elem shapes refuse (compile_error), never blanket-derive-all. Dissolve-on: v2 predicate self-emits and this module deletes." + +type V1ReprDeriveTrait + = V1ReprDeriveClone + | V1ReprDeriveCopy + | V1ReprDerivePartialEq + | V1ReprDeriveEq + | V1ReprDerivePartialOrd + | V1ReprDeriveOrd + | V1ReprDeriveSerialize + | V1ReprDeriveDeserialize + | V1ReprDeriveAdd + | V1ReprDeriveSub + | V1ReprDeriveMul + | V1ReprDeriveDiv + | V1ReprDeriveRem + | V1ReprDeriveNeg + +type V1ReprDeriveElemShape + = V1ReprDeriveElemKernelString + | V1ReprDeriveElemKernelInt + | V1ReprDeriveElemKernelBool + | V1ReprDeriveElemKernelUnit + | V1ReprDeriveElemNullaryEnumCopy + | V1ReprDeriveElemUnknown + +fn v1_coproduct_all_variants_nullary(children: List) -> Bool { + children |> all(v => v.children |> count == 0) +} + +fn v1_repr_derive_elem_shape_from_name(type_name: String) -> V1ReprDeriveElemShape { + if type_name == "Int" || type_name == "Nat" || type_name == "Char" { + V1ReprDeriveElemKernelInt + } else if type_name == "String" || type_name == "Symbol" || type_name == "Secret" { + V1ReprDeriveElemKernelString + } else if type_name == "Bool" { + V1ReprDeriveElemKernelBool + } else if type_name == "Unit" { + V1ReprDeriveElemKernelUnit + } else { + V1ReprDeriveElemUnknown + } +} + +fn v1_repr_derive_elem_shape(elem: Node, source_indices: Map) -> V1ReprDeriveElemShape { + if is_coproduct_type(n: elem) { + if v1_coproduct_all_variants_nullary(children: elem.children) { + V1ReprDeriveElemNullaryEnumCopy + } else { + V1ReprDeriveElemUnknown + } + } else { + let name = authored_name_at(source_indices: source_indices, node: elem) + if name != "" { + v1_repr_derive_elem_shape_from_name(type_name: name) + } else if elem.connective == Disj { + if v1_coproduct_all_variants_nullary(children: elem.children) { + V1ReprDeriveElemNullaryEnumCopy + } else { + V1ReprDeriveElemUnknown + } + } else { + V1ReprDeriveElemUnknown + } + } +} + +fn v1_repr_derive_shape_has_trait( + shape: V1ReprDeriveElemShape, + trait: V1ReprDeriveTrait +) -> Bool { + match shape { + V1ReprDeriveElemKernelString => + match trait { + V1ReprDeriveClone => true + V1ReprDerivePartialEq => true + V1ReprDeriveEq => true + V1ReprDerivePartialOrd => true + V1ReprDeriveOrd => true + V1ReprDeriveSerialize => true + V1ReprDeriveDeserialize => true + _ => false + } + V1ReprDeriveElemKernelInt => + match trait { + V1ReprDeriveClone => true + V1ReprDeriveCopy => true + V1ReprDerivePartialEq => true + V1ReprDeriveEq => true + V1ReprDerivePartialOrd => true + V1ReprDeriveOrd => true + V1ReprDeriveSerialize => true + V1ReprDeriveDeserialize => true + V1ReprDeriveAdd => true + V1ReprDeriveSub => true + V1ReprDeriveMul => true + V1ReprDeriveDiv => true + V1ReprDeriveRem => true + V1ReprDeriveNeg => true + } + V1ReprDeriveElemKernelBool => + match trait { + V1ReprDeriveClone => true + V1ReprDeriveCopy => true + V1ReprDerivePartialEq => true + V1ReprDeriveEq => true + V1ReprDerivePartialOrd => true + V1ReprDeriveOrd => true + V1ReprDeriveSerialize => true + V1ReprDeriveDeserialize => true + _ => false + } + V1ReprDeriveElemKernelUnit => + match trait { + V1ReprDeriveClone => true + V1ReprDeriveCopy => true + V1ReprDerivePartialEq => true + V1ReprDeriveEq => true + V1ReprDerivePartialOrd => true + V1ReprDeriveOrd => true + V1ReprDeriveSerialize => true + V1ReprDeriveDeserialize => true + _ => false + } + V1ReprDeriveElemNullaryEnumCopy => + match trait { + V1ReprDeriveClone => true + V1ReprDeriveCopy => true + V1ReprDerivePartialEq => true + V1ReprDeriveEq => true + V1ReprDerivePartialOrd => true + V1ReprDeriveOrd => true + V1ReprDeriveSerialize => true + V1ReprDeriveDeserialize => true + _ => false + } + V1ReprDeriveElemUnknown => false + } +} + +fn v1_trait_derive_completeness_predicate( + required: List, + elem: Node, + source_indices: Map +) -> Bool { + fold_list( + xs: required, + empty: true, + cons: fn(acc, trait) { + acc && v1_repr_derive_shape_has_trait( + shape: v1_repr_derive_elem_shape(elem: elem, source_indices: source_indices), + trait: trait + ) + } + ) +} + +fn v1_trait_rust_derive_spelling(trait: V1ReprDeriveTrait) -> String { + match trait { + V1ReprDeriveClone => "Clone" + V1ReprDeriveCopy => "Copy" + V1ReprDerivePartialEq => "PartialEq" + V1ReprDeriveEq => "Eq" + V1ReprDerivePartialOrd => "PartialOrd" + V1ReprDeriveOrd => "Ord" + V1ReprDeriveSerialize => "serde::Serialize" + V1ReprDeriveDeserialize => "serde::Deserialize" + V1ReprDeriveAdd => "std::ops::Add" + V1ReprDeriveSub => "std::ops::Sub" + V1ReprDeriveMul => "std::ops::Mul" + V1ReprDeriveDiv => "std::ops::Div" + V1ReprDeriveRem => "std::ops::Rem" + V1ReprDeriveNeg => "std::ops::Neg" + } +} + +fn v1_trait_list_contains(traits: List, trait: V1ReprDeriveTrait) -> Bool { + traits |> any(t => t == trait) +} + +fn v1_trait_list_push_unique(traits: List, trait: V1ReprDeriveTrait) -> List { + if v1_trait_list_contains(traits: traits, trait: trait) { + traits + } else { + Cons { head: trait, tail: traits } + } +} + +fn v1_record_base_derive_traits(heap_allocated: Bool) -> List { + let t0 = Cons { + head: V1ReprDeriveClone, + tail: Cons { + head: V1ReprDerivePartialEq, + tail: Cons { + head: V1ReprDeriveSerialize, + tail: Cons { head: V1ReprDeriveDeserialize, tail: Empty } + } + } + } + if heap_allocated { + t0 + } else { + v1_trait_list_push_unique(traits: t0, trait: V1ReprDeriveCopy) + } +} + +fn v1_nullary_coproduct_derive_traits() -> List { + Cons { + head: V1ReprDeriveClone, + tail: Cons { + head: V1ReprDeriveCopy, + tail: Cons { + head: V1ReprDerivePartialEq, + tail: Cons { + head: V1ReprDeriveEq, + tail: Cons { + head: V1ReprDerivePartialOrd, + tail: Cons { + head: V1ReprDeriveOrd, + tail: Cons { + head: V1ReprDeriveSerialize, + tail: Cons { head: V1ReprDeriveDeserialize, tail: Empty } + } + } + } + } + } + } + } +} + +fn v1_payload_coproduct_derive_traits() -> List { + Cons { + head: V1ReprDeriveClone, + tail: Cons { + head: V1ReprDerivePartialEq, + tail: Cons { + head: V1ReprDeriveSerialize, + tail: Cons { head: V1ReprDeriveDeserialize, tail: Empty } + } + } + } +} + +fn v1_ord_extension_traits() -> List { + Cons { + head: V1ReprDeriveEq, + tail: Cons { + head: V1ReprDerivePartialOrd, + tail: Cons { head: V1ReprDeriveOrd, tail: Empty } + } + } +} + +fn v1_traits_merge_ordered(base: List, extra: List) -> List { + fold_list( + xs: extra, + empty: base, + cons: fn(acc, trait) { v1_trait_list_push_unique(traits: acc, trait: trait) } + ) +} + +fn v1_trait_derive_attr_from_traits(traits: List) -> String { + let ordered = [ + V1ReprDeriveClone, V1ReprDeriveCopy, + V1ReprDerivePartialEq, V1ReprDeriveEq, V1ReprDerivePartialOrd, V1ReprDeriveOrd, + V1ReprDeriveAdd, V1ReprDeriveSub, V1ReprDeriveMul, V1ReprDeriveDiv, V1ReprDeriveRem, V1ReprDeriveNeg, + V1ReprDeriveSerialize, V1ReprDeriveDeserialize + ] + let names = ordered + |> filter(t => v1_trait_list_contains(traits: traits, trait: t)) + |> map(t => v1_trait_rust_derive_spelling(trait: t)) + concat("#[derive(Debug, ", names |> join(separator: ", "), ")]") +} + +fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { + if (children |> count) != 1 { + false + } else { + match children |> first { + Present { value: child } => + authored_name_at(source_indices: source_indices, node: child_type_node(ch: child)) == "Symbol" + && (child_type_node(ch: child).children |> count) == 0 + && (child_type_node(ch: child).params |> count) == 0 + && child_type_node(ch: child).connective == NoConnective + Absent => false + } + } +} + +fn v1_emit_struct_derives( + name: String, + children: List, + shared_types: Set, + has_fn_fields: Bool, + source_indices: Map +) -> String { + if has_fn_fields { + "#[derive(Clone)]" + } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { + v1_trait_derive_attr_from_traits(traits: v1_traits_merge_ordered( + base: v1_nullary_coproduct_derive_traits(), + extra: Empty + )) + } else { + let heap_allocated = set_contains(shared_types, name) + v1_trait_derive_attr_from_traits(traits: v1_record_base_derive_traits(heap_allocated: heap_allocated)) + } +} + +fn v1_emit_enum_derives(children: List, source_indices: Map) -> String { + let nullary = v1_coproduct_all_variants_nullary(children: children) + let traits = if nullary { + v1_nullary_coproduct_derive_traits() + } else { + v1_payload_coproduct_derive_traits() + } + if nullary { + v1_trait_derive_attr_from_traits(traits: traits) + } else { + v1_trait_derive_attr_from_traits(traits: traits) + } +} + +fn v1_generic_param_used_as_collection_element( + param_name: String, + value_params: List, + source_indices: Map +) -> Bool { + value_params |> any(vp => + let te = param_node_type_expr(n: vp) + is_container_type(name: authored_name_at(source_indices: source_indices, node: te)) + && (te.children |> any(c => authored_name_at(source_indices: source_indices, node: c) == param_name)) + ) +} + +fn v1_generic_params_needing_clone_bound( + generic_param_names: List, + value_params: List, + return_is_bare_generic: Bool, + ret_name: String, + body_is_param_ref: Bool, + source_indices: Map +) -> List { + generic_param_names |> filter(g => + (return_is_bare_generic && !body_is_param_ref && g == ret_name) + || v1_generic_param_used_as_collection_element(param_name: g, value_params: value_params, source_indices: source_indices) + ) +} + +fn v1_emit_type_params_with_clone_bounds( + params: List, + clone_param_names: List, + source_indices: Map +) -> String { + if params |> count == 0 { "" } + else { + let names = params |> map(p => + let pname = generic_param_name_at(n: p, source_indices: source_indices) + let pascal = to_pascal(name: pname) + if clone_param_names |> any(c => c == pname) { + concat(pascal, ": Clone") + } else { + pascal + } + ) + concat("<", names |> join(separator: ", "), ">") + } +} From 8f18697ce4e7540699ce267f6cd32ed378293fd5 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 22:23:16 +0000 Subject: [PATCH 09/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/gunbc/stage0_emit_model.dag | 1 + src/v1/stage0/src/bin/regen_stage0.rs | 1 + src/v1/trait_derive_emit.dag | 313 ++------------------------ 3 files changed, 24 insertions(+), 291 deletions(-) diff --git a/dag/gunbc/stage0_emit_model.dag b/dag/gunbc/stage0_emit_model.dag index e69bd7cf2b8..437e755b33b 100644 --- a/dag/gunbc/stage0_emit_model.dag +++ b/dag/gunbc/stage0_emit_model.dag @@ -90,6 +90,7 @@ data generated_stage0_files: List = [ "v1_compiler_stage0_crates.rs", "v1_compiler_tokenize.rs", "v1_compiler_trace.rs", + "v1_compiler_trait_derive_emit.rs", "v1_compiler_workspace_members.rs", "v1_probe_emit_interp.rs", "v1_rt.rs", diff --git a/src/v1/stage0/src/bin/regen_stage0.rs b/src/v1/stage0/src/bin/regen_stage0.rs index a0f4b1e4657..25a9f2a778f 100644 --- a/src/v1/stage0/src/bin/regen_stage0.rs +++ b/src/v1/stage0/src/bin/regen_stage0.rs @@ -121,6 +121,7 @@ const GENERATED_STAGE0_FILES: &[&str] = &[ "v1_compiler_stage0_crates.rs", "v1_compiler_tokenize.rs", "v1_compiler_trace.rs", + "v1_compiler_trait_derive_emit.rs", "v1_compiler_workspace_members.rs", "v1_probe_emit_interp.rs", "v1_rt.rs", diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 28d170094d3..ea80a8e792f 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,287 +1,18 @@ module v1.compiler.trait_derive_emit +import v1.compiler.infer_types { child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, - Disj, NoConnective + NoConnective } -import v1.compiler.infer_types { is_coproduct_type, child_type_node } import v1.compiler.emit { to_pascal } -import std.types { is_kernel_type, is_container_type } -import std.algebra { Cons, Empty, fold_list } - -data v1_trait_derive_emit_note: String = "V1 seed-emitter realization of v2.compiler.trait_derive_completeness — structure-driven derive/bound selection for 05_emit_rust.dag. Fail-closed: unknown elem shapes refuse (compile_error), never blanket-derive-all. Dissolve-on: v2 predicate self-emits and this module deletes." - -type V1ReprDeriveTrait - = V1ReprDeriveClone - | V1ReprDeriveCopy - | V1ReprDerivePartialEq - | V1ReprDeriveEq - | V1ReprDerivePartialOrd - | V1ReprDeriveOrd - | V1ReprDeriveSerialize - | V1ReprDeriveDeserialize - | V1ReprDeriveAdd - | V1ReprDeriveSub - | V1ReprDeriveMul - | V1ReprDeriveDiv - | V1ReprDeriveRem - | V1ReprDeriveNeg - -type V1ReprDeriveElemShape - = V1ReprDeriveElemKernelString - | V1ReprDeriveElemKernelInt - | V1ReprDeriveElemKernelBool - | V1ReprDeriveElemKernelUnit - | V1ReprDeriveElemNullaryEnumCopy - | V1ReprDeriveElemUnknown - -fn v1_coproduct_all_variants_nullary(children: List) -> Bool { - children |> all(v => v.children |> count == 0) -} - -fn v1_repr_derive_elem_shape_from_name(type_name: String) -> V1ReprDeriveElemShape { - if type_name == "Int" || type_name == "Nat" || type_name == "Char" { - V1ReprDeriveElemKernelInt - } else if type_name == "String" || type_name == "Symbol" || type_name == "Secret" { - V1ReprDeriveElemKernelString - } else if type_name == "Bool" { - V1ReprDeriveElemKernelBool - } else if type_name == "Unit" { - V1ReprDeriveElemKernelUnit - } else { - V1ReprDeriveElemUnknown - } -} - -fn v1_repr_derive_elem_shape(elem: Node, source_indices: Map) -> V1ReprDeriveElemShape { - if is_coproduct_type(n: elem) { - if v1_coproduct_all_variants_nullary(children: elem.children) { - V1ReprDeriveElemNullaryEnumCopy - } else { - V1ReprDeriveElemUnknown - } - } else { - let name = authored_name_at(source_indices: source_indices, node: elem) - if name != "" { - v1_repr_derive_elem_shape_from_name(type_name: name) - } else if elem.connective == Disj { - if v1_coproduct_all_variants_nullary(children: elem.children) { - V1ReprDeriveElemNullaryEnumCopy - } else { - V1ReprDeriveElemUnknown - } - } else { - V1ReprDeriveElemUnknown - } - } -} - -fn v1_repr_derive_shape_has_trait( - shape: V1ReprDeriveElemShape, - trait: V1ReprDeriveTrait -) -> Bool { - match shape { - V1ReprDeriveElemKernelString => - match trait { - V1ReprDeriveClone => true - V1ReprDerivePartialEq => true - V1ReprDeriveEq => true - V1ReprDerivePartialOrd => true - V1ReprDeriveOrd => true - V1ReprDeriveSerialize => true - V1ReprDeriveDeserialize => true - _ => false - } - V1ReprDeriveElemKernelInt => - match trait { - V1ReprDeriveClone => true - V1ReprDeriveCopy => true - V1ReprDerivePartialEq => true - V1ReprDeriveEq => true - V1ReprDerivePartialOrd => true - V1ReprDeriveOrd => true - V1ReprDeriveSerialize => true - V1ReprDeriveDeserialize => true - V1ReprDeriveAdd => true - V1ReprDeriveSub => true - V1ReprDeriveMul => true - V1ReprDeriveDiv => true - V1ReprDeriveRem => true - V1ReprDeriveNeg => true - } - V1ReprDeriveElemKernelBool => - match trait { - V1ReprDeriveClone => true - V1ReprDeriveCopy => true - V1ReprDerivePartialEq => true - V1ReprDeriveEq => true - V1ReprDerivePartialOrd => true - V1ReprDeriveOrd => true - V1ReprDeriveSerialize => true - V1ReprDeriveDeserialize => true - _ => false - } - V1ReprDeriveElemKernelUnit => - match trait { - V1ReprDeriveClone => true - V1ReprDeriveCopy => true - V1ReprDerivePartialEq => true - V1ReprDeriveEq => true - V1ReprDerivePartialOrd => true - V1ReprDeriveOrd => true - V1ReprDeriveSerialize => true - V1ReprDeriveDeserialize => true - _ => false - } - V1ReprDeriveElemNullaryEnumCopy => - match trait { - V1ReprDeriveClone => true - V1ReprDeriveCopy => true - V1ReprDerivePartialEq => true - V1ReprDeriveEq => true - V1ReprDerivePartialOrd => true - V1ReprDeriveOrd => true - V1ReprDeriveSerialize => true - V1ReprDeriveDeserialize => true - _ => false - } - V1ReprDeriveElemUnknown => false - } -} - -fn v1_trait_derive_completeness_predicate( - required: List, - elem: Node, - source_indices: Map -) -> Bool { - fold_list( - xs: required, - empty: true, - cons: fn(acc, trait) { - acc && v1_repr_derive_shape_has_trait( - shape: v1_repr_derive_elem_shape(elem: elem, source_indices: source_indices), - trait: trait - ) - } - ) -} - -fn v1_trait_rust_derive_spelling(trait: V1ReprDeriveTrait) -> String { - match trait { - V1ReprDeriveClone => "Clone" - V1ReprDeriveCopy => "Copy" - V1ReprDerivePartialEq => "PartialEq" - V1ReprDeriveEq => "Eq" - V1ReprDerivePartialOrd => "PartialOrd" - V1ReprDeriveOrd => "Ord" - V1ReprDeriveSerialize => "serde::Serialize" - V1ReprDeriveDeserialize => "serde::Deserialize" - V1ReprDeriveAdd => "std::ops::Add" - V1ReprDeriveSub => "std::ops::Sub" - V1ReprDeriveMul => "std::ops::Mul" - V1ReprDeriveDiv => "std::ops::Div" - V1ReprDeriveRem => "std::ops::Rem" - V1ReprDeriveNeg => "std::ops::Neg" - } -} - -fn v1_trait_list_contains(traits: List, trait: V1ReprDeriveTrait) -> Bool { - traits |> any(t => t == trait) -} - -fn v1_trait_list_push_unique(traits: List, trait: V1ReprDeriveTrait) -> List { - if v1_trait_list_contains(traits: traits, trait: trait) { - traits - } else { - Cons { head: trait, tail: traits } - } +import extdeps.languages.rust.emit { + rust_struct_derives, rust_struct_derives_copy, rust_enum_derives } +import std.types { is_container_type } -fn v1_record_base_derive_traits(heap_allocated: Bool) -> List { - let t0 = Cons { - head: V1ReprDeriveClone, - tail: Cons { - head: V1ReprDerivePartialEq, - tail: Cons { - head: V1ReprDeriveSerialize, - tail: Cons { head: V1ReprDeriveDeserialize, tail: Empty } - } - } - } - if heap_allocated { - t0 - } else { - v1_trait_list_push_unique(traits: t0, trait: V1ReprDeriveCopy) - } -} - -fn v1_nullary_coproduct_derive_traits() -> List { - Cons { - head: V1ReprDeriveClone, - tail: Cons { - head: V1ReprDeriveCopy, - tail: Cons { - head: V1ReprDerivePartialEq, - tail: Cons { - head: V1ReprDeriveEq, - tail: Cons { - head: V1ReprDerivePartialOrd, - tail: Cons { - head: V1ReprDeriveOrd, - tail: Cons { - head: V1ReprDeriveSerialize, - tail: Cons { head: V1ReprDeriveDeserialize, tail: Empty } - } - } - } - } - } - } - } -} - -fn v1_payload_coproduct_derive_traits() -> List { - Cons { - head: V1ReprDeriveClone, - tail: Cons { - head: V1ReprDerivePartialEq, - tail: Cons { - head: V1ReprDeriveSerialize, - tail: Cons { head: V1ReprDeriveDeserialize, tail: Empty } - } - } - } -} - -fn v1_ord_extension_traits() -> List { - Cons { - head: V1ReprDeriveEq, - tail: Cons { - head: V1ReprDerivePartialOrd, - tail: Cons { head: V1ReprDeriveOrd, tail: Empty } - } - } -} - -fn v1_traits_merge_ordered(base: List, extra: List) -> List { - fold_list( - xs: extra, - empty: base, - cons: fn(acc, trait) { v1_trait_list_push_unique(traits: acc, trait: trait) } - ) -} - -fn v1_trait_derive_attr_from_traits(traits: List) -> String { - let ordered = [ - V1ReprDeriveClone, V1ReprDeriveCopy, - V1ReprDerivePartialEq, V1ReprDeriveEq, V1ReprDerivePartialOrd, V1ReprDeriveOrd, - V1ReprDeriveAdd, V1ReprDeriveSub, V1ReprDeriveMul, V1ReprDeriveDiv, V1ReprDeriveRem, V1ReprDeriveNeg, - V1ReprDeriveSerialize, V1ReprDeriveDeserialize - ] - let names = ordered - |> filter(t => v1_trait_list_contains(traits: traits, trait: t)) - |> map(t => v1_trait_rust_derive_spelling(trait: t)) - concat("#[derive(Debug, ", names |> join(separator: ", "), ")]") +fn v1_ord_derives_text() -> String { + "#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]" } fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { @@ -299,6 +30,14 @@ fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_ind } } +fn v1_ord_derives_copy_text() -> String { + "#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]" +} + +fn v1_coproduct_all_variants_nullary(children: List) -> Bool { + children |> all(v => v.children |> count == 0) +} + fn v1_emit_struct_derives( name: String, children: List, @@ -309,27 +48,19 @@ fn v1_emit_struct_derives( if has_fn_fields { "#[derive(Clone)]" } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { - v1_trait_derive_attr_from_traits(traits: v1_traits_merge_ordered( - base: v1_nullary_coproduct_derive_traits(), - extra: Empty - )) + v1_ord_derives_text() + } else if set_contains(shared_types, name) { + rust_struct_derives } else { - let heap_allocated = set_contains(shared_types, name) - v1_trait_derive_attr_from_traits(traits: v1_record_base_derive_traits(heap_allocated: heap_allocated)) + rust_struct_derives_copy } } fn v1_emit_enum_derives(children: List, source_indices: Map) -> String { - let nullary = v1_coproduct_all_variants_nullary(children: children) - let traits = if nullary { - v1_nullary_coproduct_derive_traits() - } else { - v1_payload_coproduct_derive_traits() - } - if nullary { - v1_trait_derive_attr_from_traits(traits: traits) + if v1_coproduct_all_variants_nullary(children: children) { + v1_ord_derives_copy_text() } else { - v1_trait_derive_attr_from_traits(traits: traits) + rust_enum_derives } } From 8243652c82c255e0a7434bea6aa7cecae9b792bd Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 22:33:49 +0000 Subject: [PATCH 10/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/gunbc/non_fold_residue.dag | 2 +- dag/std/trait_derive_shape.dag | 229 ++++++++++++++++++ src/v1/trait_derive_emit.dag | 71 ++++-- src/v2/compiler/trait_derive_completeness.dag | 140 +++-------- .../trait_derive_seed_emit_binding_test.dag | 31 +++ ...ait_derive_completeness_predicate_test.dag | 12 +- 6 files changed, 350 insertions(+), 135 deletions(-) create mode 100644 dag/std/trait_derive_shape.dag create mode 100644 src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag diff --git a/dag/gunbc/non_fold_residue.dag b/dag/gunbc/non_fold_residue.dag index 876776c43a5..811e4b39cea 100644 --- a/dag/gunbc/non_fold_residue.dag +++ b/dag/gunbc/non_fold_residue.dag @@ -676,7 +676,7 @@ data non_fold_residue_frontier: List = [ dissolve_on: nfr_dissolve_wildcard_total }, FrontierRow { - unit: "src/v2/compiler/trait_derive_completeness.dag::repr_grounding_derive_shape_has_trait", + unit: "dag/std/trait_derive_shape.dag::repr_grounding_derive_shape_has_trait", reason: nfr_reason_trait_derive_shape_table, dissolve_on: nfr_dissolve_trait_derive_shape_table }, diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag new file mode 100644 index 00000000000..2957c41dff9 --- /dev/null +++ b/dag/std/trait_derive_shape.dag @@ -0,0 +1,229 @@ +module std.trait_derive_shape + +import std.algebra { Cons, Empty } + +data trait_derive_shape_note: String = "Single authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Consumed by v2.compiler.trait_derive_completeness (v2 Node elem-shape classifier) and v1.compiler.trait_derive_emit (v1 seed emitter derive selection). Dissolve-on: table migrates to derived rows when emit arms are total." + +type ReprGroundingDeriveTrait + = ReprDeriveClone + | ReprDeriveCopy + | ReprDerivePartialEq + | ReprDeriveEq + | ReprDerivePartialOrd + | ReprDeriveOrd + | ReprDeriveSerialize + | ReprDeriveDeserialize + | ReprDeriveAdd + | ReprDeriveSub + | ReprDeriveMul + | ReprDeriveDiv + | ReprDeriveRem + | ReprDeriveNeg + +type ReprGroundingDeriveElemShape + = ReprDeriveElemKernelString + | ReprDeriveElemKernelInt + | ReprDeriveElemKernelBool + | ReprDeriveElemKernelUnit + | ReprDeriveElemNullaryEnumCopy + | ReprDeriveElemUnknown + +fn repr_grounding_derive_shape_has_trait( + shape: ReprGroundingDeriveElemShape, + derive_trait: ReprGroundingDeriveTrait +) -> Bool { + match shape { + ReprDeriveElemKernelString => + match derive_trait { + ReprDeriveClone => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemKernelInt => + match derive_trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + ReprDeriveAdd => true + ReprDeriveSub => true + ReprDeriveMul => true + ReprDeriveDiv => true + ReprDeriveRem => true + ReprDeriveNeg => true + } + ReprDeriveElemKernelBool => + match derive_trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemKernelUnit => + match derive_trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemNullaryEnumCopy => + match derive_trait { + ReprDeriveClone => true + ReprDeriveCopy => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } + ReprDeriveElemUnknown => false + } +} + +fn trait_derive_list_contains(traits: List, derive_trait: ReprGroundingDeriveTrait) -> Bool { + traits |> any(t => t == derive_trait) +} + +fn trait_derive_list_push_unique(traits: List, derive_trait: ReprGroundingDeriveTrait) -> List { + if trait_derive_list_contains(traits: traits, derive_trait: derive_trait) { + traits + } else { + Cons { head: derive_trait, tail: traits } + } +} + +fn repr_grounding_derive_completeness_predicate( + required: List, + shape: ReprGroundingDeriveElemShape +) -> Bool { + required |> all(dt => repr_grounding_derive_shape_has_trait(shape: shape, derive_trait: dt)) +} + +fn record_derive_traits_heap() -> List { + Cons { + head: ReprDeriveClone, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } + } + } +} + +fn record_derive_traits_copy() -> List { + Cons { + head: ReprDeriveClone, + tail: Cons { + head: ReprDeriveCopy, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } + } + } + } +} + +fn record_derive_traits(heap_allocated: Bool) -> List { + match heap_allocated { + true => record_derive_traits_heap() + false => record_derive_traits_copy() + } +} + +fn nullary_coproduct_derive_traits() -> List { + Cons { + head: ReprDeriveClone, + tail: Cons { + head: ReprDeriveCopy, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialOrd, + tail: Cons { + head: ReprDeriveOrd, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } + } + } + } + } + } + } +} + +fn payload_coproduct_derive_traits() -> List { + Cons { + head: ReprDeriveClone, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } + } + } +} + +fn trait_rust_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { + match derive_trait { + ReprDeriveClone => "Clone" + ReprDeriveCopy => "Copy" + ReprDerivePartialEq => "PartialEq" + ReprDeriveEq => "Eq" + ReprDerivePartialOrd => "PartialOrd" + ReprDeriveOrd => "Ord" + ReprDeriveSerialize => "serde::Serialize" + ReprDeriveDeserialize => "serde::Deserialize" + ReprDeriveAdd => "std::ops::Add" + ReprDeriveSub => "std::ops::Sub" + ReprDeriveMul => "std::ops::Mul" + ReprDeriveDiv => "std::ops::Div" + ReprDeriveRem => "std::ops::Rem" + ReprDeriveNeg => "std::ops::Neg" + } +} + +fn trait_derive_attr_from_traits(traits: List) -> String { + concat( + "#[derive(Debug", + if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveClone) { ", Clone" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveCopy) { ", Copy" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDerivePartialEq) { ", PartialEq" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveEq) { ", Eq" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDerivePartialOrd) { ", PartialOrd" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveOrd) { ", Ord" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveSerialize) { ", serde::Serialize" } else { "" }, + if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveDeserialize) { ", serde::Deserialize" } else { "" }, + ")]" + ) +} diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index ea80a8e792f..84dff8ab4ca 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,18 +1,30 @@ module v1.compiler.trait_derive_emit -import v1.compiler.infer_types { child_type_node } +import v1.compiler.infer_types { is_coproduct_type, child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, NoConnective } import v1.compiler.emit { to_pascal } -import extdeps.languages.rust.emit { - rust_struct_derives, rust_struct_derives_copy, rust_enum_derives +import std.trait_derive_shape { + ReprDeriveClone, + ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemKernelInt, + repr_grounding_derive_completeness_predicate, + repr_grounding_derive_shape_has_trait, + record_derive_traits, + nullary_coproduct_derive_traits, + payload_coproduct_derive_traits, + trait_derive_attr_from_traits } import std.types { is_container_type } -fn v1_ord_derives_text() -> String { - "#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]" +fn v1_trait_derive_refuse(message: String) -> String { + concat("compile_error!(\"", message, "\");") +} + +fn v1_coproduct_all_variants_nullary(children: List) -> Bool { + children |> all(v => v.children |> count == 0) } fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { @@ -30,14 +42,6 @@ fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_ind } } -fn v1_ord_derives_copy_text() -> String { - "#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]" -} - -fn v1_coproduct_all_variants_nullary(children: List) -> Bool { - children |> all(v => v.children |> count == 0) -} - fn v1_emit_struct_derives( name: String, children: List, @@ -48,19 +52,25 @@ fn v1_emit_struct_derives( if has_fn_fields { "#[derive(Clone)]" } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { - v1_ord_derives_text() - } else if set_contains(shared_types, name) { - rust_struct_derives + if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), ReprDeriveElemNullaryEnumCopy) { + trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse("trait_derive_emit: symbol-wrapped ord carrier refused") + } } else { - rust_struct_derives_copy + trait_derive_attr_from_traits(record_derive_traits(set_contains(shared_types, name))) } } fn v1_emit_enum_derives(children: List, source_indices: Map) -> String { if v1_coproduct_all_variants_nullary(children: children) { - v1_ord_derives_copy_text() + if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), ReprDeriveElemNullaryEnumCopy) { + trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse("trait_derive_emit: nullary coproduct derive completeness refused") + } } else { - rust_enum_derives + trait_derive_attr_from_traits(payload_coproduct_derive_traits()) } } @@ -76,6 +86,19 @@ fn v1_generic_param_used_as_collection_element( ) } +fn v1_type_param_needs_clone_bound( + param_name: String, + return_is_bare_generic: Bool, + ret_name: String, + body_is_param_ref: Bool, + value_params: List, + source_indices: Map +) -> Bool { + let structural = (return_is_bare_generic && !body_is_param_ref && param_name == ret_name) + || v1_generic_param_used_as_collection_element(param_name: param_name, value_params: value_params, source_indices: source_indices) + structural && repr_grounding_derive_shape_has_trait(ReprDeriveElemKernelInt, ReprDeriveClone) +} + fn v1_generic_params_needing_clone_bound( generic_param_names: List, value_params: List, @@ -85,8 +108,14 @@ fn v1_generic_params_needing_clone_bound( source_indices: Map ) -> List { generic_param_names |> filter(g => - (return_is_bare_generic && !body_is_param_ref && g == ret_name) - || v1_generic_param_used_as_collection_element(param_name: g, value_params: value_params, source_indices: source_indices) + v1_type_param_needs_clone_bound( + param_name: g, + return_is_bare_generic: return_is_bare_generic, + ret_name: ret_name, + body_is_param_ref: body_is_param_ref, + value_params: value_params, + source_indices: source_indices + ) ) } diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index bcf47da66da..cc84b37cded 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -1,5 +1,29 @@ module v2.compiler.trait_derive_completeness +import std.trait_derive_shape { + ReprDeriveClone, + ReprDeriveCopy, + ReprDerivePartialEq, + ReprDeriveEq, + ReprDerivePartialOrd, + ReprDeriveOrd, + ReprDeriveSerialize, + ReprDeriveAdd, + ReprGroundingDeriveTrait, + ReprGroundingDeriveElemShape, + ReprDeriveElemKernelInt, + ReprDeriveElemKernelString, + ReprDeriveElemKernelBool, + ReprDeriveElemKernelUnit, + ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemUnknown, + repr_grounding_derive_shape_has_trait, + repr_grounding_derive_completeness_predicate, + record_derive_traits, + nullary_coproduct_derive_traits, + payload_coproduct_derive_traits, + trait_derive_attr_from_traits +} import v2.std.algebra { Cons, Empty, fold_list } import v2.std.collection { List } import v2.std.logic { Bool } @@ -20,31 +44,7 @@ import v2.std.compilers.target_model { TargetCollectionWitnessOrd } -data trait_derive_completeness_note: String = "Gate-1 sub-wall #2: structure-driven trait-derive completeness authority (Clone/arith/serde/ord). Agnostic predicate on modeled Node shapes — consumed by rust.dag surface-binding rows and v1 emit derive/impl selection. Fail-closed: unknown shapes refuse. NOT in target_model.dag (emit/ingest fold); mirrors wrap_decision.dag placement (#6776). Dissolve-on: three emit arms + layer-boundary mock test wire through this module." - -type ReprGroundingDeriveTrait - = ReprDeriveClone - | ReprDeriveCopy - | ReprDerivePartialEq - | ReprDeriveEq - | ReprDerivePartialOrd - | ReprDeriveOrd - | ReprDeriveSerialize - | ReprDeriveDeserialize - | ReprDeriveAdd - | ReprDeriveSub - | ReprDeriveMul - | ReprDeriveDiv - | ReprDeriveRem - | ReprDeriveNeg - -type ReprGroundingDeriveElemShape - = ReprDeriveElemKernelString - | ReprDeriveElemKernelInt - | ReprDeriveElemKernelBool - | ReprDeriveElemKernelUnit - | ReprDeriveElemNullaryEnumCopy - | ReprDeriveElemUnknown +data trait_derive_completeness_note: String = "Gate-1 sub-wall #2: v2 Node elem-shape classifier + collection-witness gate over std.trait_derive_shape (single capability-table authority). Consumed by rust.dag surface-binding rows and v1.compiler.trait_derive_emit. Fail-closed: unknown shapes refuse. Dissolve-on: three emit arms + layer-boundary mock test wire through this module." type TraitDeriveCompletenessGate = TraitDeriveCompletenessSatisfied @@ -96,99 +96,23 @@ fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape } } -fn repr_grounding_derive_shape_has_trait( - shape: ReprGroundingDeriveElemShape, - trait: ReprGroundingDeriveTrait -) -> Bool { - match shape { - ReprDeriveElemKernelString => - match trait { - ReprDeriveClone => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemKernelInt => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - ReprDeriveAdd => true - ReprDeriveSub => true - ReprDeriveMul => true - ReprDeriveDiv => true - ReprDeriveRem => true - ReprDeriveNeg => true - } - ReprDeriveElemKernelBool => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemKernelUnit => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemNullaryEnumCopy => - match trait { - ReprDeriveClone => true - ReprDeriveCopy => true - ReprDerivePartialEq => true - ReprDeriveEq => true - ReprDerivePartialOrd => true - ReprDeriveOrd => true - ReprDeriveSerialize => true - ReprDeriveDeserialize => true - _ => false - } - ReprDeriveElemUnknown => false - } -} - fn repr_grounding_derive_trait_satisfied( - trait: ReprGroundingDeriveTrait, + derive_trait: ReprGroundingDeriveTrait, elem: Node ) -> Bool { repr_grounding_derive_shape_has_trait( shape: repr_grounding_derive_elem_shape(elem: elem), - trait: trait + derive_trait: derive_trait ) } -fn repr_grounding_derive_completeness_predicate( +fn repr_grounding_derive_completeness_predicate_for_elem( required: List, elem: Node ) -> Bool { - fold_list( - xs: required, - empty: true, - cons: fn(acc, trait) { - acc && repr_grounding_derive_trait_satisfied(trait: trait, elem: elem) - } + repr_grounding_derive_completeness_predicate( + required: required, + shape: repr_grounding_derive_elem_shape(elem: elem) ) } @@ -233,7 +157,7 @@ fn trait_derive_completeness_gate( required: List, elem: Node ) -> TraitDeriveCompletenessGate { - if repr_grounding_derive_completeness_predicate(required: required, elem: elem) { + if repr_grounding_derive_completeness_predicate_for_elem(required: required, elem: elem) { TraitDeriveCompletenessSatisfied } else { TraitDeriveCompletenessIncomplete diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag new file mode 100644 index 00000000000..b067df558e8 --- /dev/null +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -0,0 +1,31 @@ +module v2.test.emit.trait_derive_seed_emit_binding_test + +import std.trait_derive_shape { + ReprDeriveClone, + ReprDerivePartialEq, + ReprDeriveSerialize, + ReprDeriveElemNullaryEnumCopy, + nullary_coproduct_derive_traits, + record_derive_traits, + trait_derive_attr_from_traits, + repr_grounding_derive_completeness_predicate +} +import v2.std.logic { Bool } + +data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.trait_derive_shape trait lists → derive attr spellings consumed by v1.compiler.trait_derive_emit (same authority path as seed emitter)." + +test fn nullary_coproduct_predicate_satisfied() -> Bool { + repr_grounding_derive_completeness_predicate( + required: nullary_coproduct_derive_traits(), + shape: ReprDeriveElemNullaryEnumCopy + ) +} + +test fn record_heap_attr_contains_serde() -> Bool { + let attr = trait_derive_attr_from_traits(traits: record_derive_traits(heap_allocated: true)) + attr != "" && attr != trait_derive_attr_from_traits(traits: record_derive_traits(heap_allocated: false)) +} + +test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { + nullary_coproduct_predicate_satisfied() && record_heap_attr_contains_serde() +} diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index 2f66b7db902..02de603cf99 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -5,17 +5,19 @@ import v2.compiler.trait_derive_completeness { ReprDeriveClone, ReprDeriveOrd, ReprDeriveSerialize, - ReprDeriveElemKernelString, - ReprDeriveElemNullaryEnumCopy, - ReprDeriveElemUnknown, TraitDeriveCompletenessIncomplete, TraitDeriveCompletenessSatisfied, - repr_grounding_derive_completeness_predicate, + repr_grounding_derive_completeness_predicate_for_elem, repr_grounding_derive_elem_shape, repr_grounding_derive_trait_satisfied, trait_derive_completeness_gate_for_collection_witness, trait_derive_int_kernel_type_node } +import std.trait_derive_shape { + ReprDeriveElemKernelString, + ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemUnknown +} import v2.extdeps.languages.rust { rust_trait_derive_surface_binding_for_coproduct, rust_trait_derive_surface_binding_for_record @@ -145,7 +147,7 @@ test fn tdc_string_kernel_satisfies_clone_ord_serde_not_add() -> Bool { test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: trait_derive_int_kernel_type_node()) && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: trait_derive_int_kernel_type_node()) - && repr_grounding_derive_completeness_predicate( + && repr_grounding_derive_completeness_predicate_for_elem( required: Cons { head: ReprDeriveAdd, tail: Cons { head: ReprDeriveClone, tail: Cons { head: ReprDeriveSerialize, tail: Empty } } From 14c8cdb7f757529ee745b4f09646db85c1d08921 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 22:44:27 +0000 Subject: [PATCH 11/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/gunbc/stage0_emit_model.dag | 1 + dag/std/trait_derive_shape.dag | 17 +---------------- src/v1/stage0/src/bin/regen_stage0.rs | 1 + src/v1/trait_derive_emit.dag | 9 +++++++-- .../trait_derive_seed_emit_binding_test.dag | 12 +++++++----- 5 files changed, 17 insertions(+), 23 deletions(-) diff --git a/dag/gunbc/stage0_emit_model.dag b/dag/gunbc/stage0_emit_model.dag index 437e755b33b..3a9f23cd655 100644 --- a/dag/gunbc/stage0_emit_model.dag +++ b/dag/gunbc/stage0_emit_model.dag @@ -53,6 +53,7 @@ data generated_stage0_files: List = [ "std_serialization.rs", "std_syntax.rs", "std_termination.rs", + "std_trait_derive_shape.rs", "std_types.rs", "v1_compiler_artifact.rs", "v1_compiler_coercion.rs", diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 2957c41dff9..168164f479d 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -105,19 +105,11 @@ fn trait_derive_list_contains(traits: List, derive_tra traits |> any(t => t == derive_trait) } -fn trait_derive_list_push_unique(traits: List, derive_trait: ReprGroundingDeriveTrait) -> List { - if trait_derive_list_contains(traits: traits, derive_trait: derive_trait) { - traits - } else { - Cons { head: derive_trait, tail: traits } - } -} - fn repr_grounding_derive_completeness_predicate( required: List, shape: ReprGroundingDeriveElemShape ) -> Bool { - required |> all(dt => repr_grounding_derive_shape_has_trait(shape: shape, derive_trait: dt)) + required |> all(dt => repr_grounding_derive_shape_has_trait(shape, dt)) } fn record_derive_traits_heap() -> List { @@ -149,13 +141,6 @@ fn record_derive_traits_copy() -> List { } } -fn record_derive_traits(heap_allocated: Bool) -> List { - match heap_allocated { - true => record_derive_traits_heap() - false => record_derive_traits_copy() - } -} - fn nullary_coproduct_derive_traits() -> List { Cons { head: ReprDeriveClone, diff --git a/src/v1/stage0/src/bin/regen_stage0.rs b/src/v1/stage0/src/bin/regen_stage0.rs index 25a9f2a778f..1b9f028107f 100644 --- a/src/v1/stage0/src/bin/regen_stage0.rs +++ b/src/v1/stage0/src/bin/regen_stage0.rs @@ -82,6 +82,7 @@ const GENERATED_STAGE0_FILES: &[&str] = &[ "std_serialization.rs", "std_syntax.rs", "std_termination.rs", + "std_trait_derive_shape.rs", "std_types.rs", "v1_compiler_artifact.rs", "v1_compiler_coercion.rs", diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 84dff8ab4ca..9651602917a 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -12,7 +12,8 @@ import std.trait_derive_shape { ReprDeriveElemKernelInt, repr_grounding_derive_completeness_predicate, repr_grounding_derive_shape_has_trait, - record_derive_traits, + record_derive_traits_heap, + record_derive_traits_copy, nullary_coproduct_derive_traits, payload_coproduct_derive_traits, trait_derive_attr_from_traits @@ -58,7 +59,11 @@ fn v1_emit_struct_derives( v1_trait_derive_refuse("trait_derive_emit: symbol-wrapped ord carrier refused") } } else { - trait_derive_attr_from_traits(record_derive_traits(set_contains(shared_types, name))) + if set_contains(shared_types, name) { + trait_derive_attr_from_traits(record_derive_traits_heap()) + } else { + trait_derive_attr_from_traits(record_derive_traits_copy()) + } } } diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index b067df558e8..f07b63204e1 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -6,7 +6,8 @@ import std.trait_derive_shape { ReprDeriveSerialize, ReprDeriveElemNullaryEnumCopy, nullary_coproduct_derive_traits, - record_derive_traits, + record_derive_traits_heap, + record_derive_traits_copy, trait_derive_attr_from_traits, repr_grounding_derive_completeness_predicate } @@ -16,14 +17,15 @@ data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.tra test fn nullary_coproduct_predicate_satisfied() -> Bool { repr_grounding_derive_completeness_predicate( - required: nullary_coproduct_derive_traits(), - shape: ReprDeriveElemNullaryEnumCopy + nullary_coproduct_derive_traits(), + ReprDeriveElemNullaryEnumCopy ) } test fn record_heap_attr_contains_serde() -> Bool { - let attr = trait_derive_attr_from_traits(traits: record_derive_traits(heap_allocated: true)) - attr != "" && attr != trait_derive_attr_from_traits(traits: record_derive_traits(heap_allocated: false)) + let heap_attr = trait_derive_attr_from_traits(record_derive_traits_heap()) + let copy_attr = trait_derive_attr_from_traits(record_derive_traits_copy()) + heap_attr != "" && heap_attr != copy_attr } test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { From 59d118d5ee6c1063f7835b94b0f6ae0f75eb1045 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 22:54:47 +0000 Subject: [PATCH 12/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/stage0/src/lib.rs | 2 + src/v1/stage0/src/std_trait_derive_shape.rs | 422 ++++++++++++++++++ src/v1/stage0/src/v1_compiler_emit_rust.rs | 98 ++-- .../src/v1_compiler_trait_derive_emit.rs | 241 ++++++++++ 4 files changed, 694 insertions(+), 69 deletions(-) create mode 100644 src/v1/stage0/src/std_trait_derive_shape.rs create mode 100644 src/v1/stage0/src/v1_compiler_trait_derive_emit.rs diff --git a/src/v1/stage0/src/lib.rs b/src/v1/stage0/src/lib.rs index 71b73816458..0ed8ae70c8b 100644 --- a/src/v1/stage0/src/lib.rs +++ b/src/v1/stage0/src/lib.rs @@ -72,6 +72,7 @@ pub mod std_realization_schedule; pub mod std_serialization; pub mod std_syntax; pub mod std_termination; +pub mod std_trait_derive_shape; pub mod std_types; pub mod usv_pilot_v2_std_algebra; pub mod usv_pilot_v2_std_collection; @@ -114,6 +115,7 @@ pub mod v1_compiler_runtime_rust; pub mod v1_compiler_stage0_crates; pub mod v1_compiler_tokenize; pub mod v1_compiler_trace; +pub mod v1_compiler_trait_derive_emit; pub mod v1_compiler_workspace_members; pub mod v1_interpreter; pub mod v1_probe_emit_interp; diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs new file mode 100644 index 00000000000..976334b46f1 --- /dev/null +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -0,0 +1,422 @@ +// Generated by v1 compiler -- do not edit. +// Source module: std.trait_derive_shape + +use self::ReprGroundingDeriveElemShape::*; +use self::ReprGroundingDeriveTrait::*; +pub use crate::std_algebra::FreeMonoid; +use crate::v1_rt; +use crate::v1_rt::Witness; +use crate::v1_rt::Witness::{Holds, Violates}; +use crate::v1_rt::{VecCompat, VecJoin}; +use crate::NonEmptyBTreeSet; +use crate::NonEmptyVec; +use im::{vector as vec, HashMap, OrdSet as BTreeSet, Vector as Vec}; +use std::rc::Rc; + +pub fn trait_derive_shape_note() -> String { + thread_local! { + static CACHED: String = { + "Single authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Consumed by v2.compiler.trait_derive_completeness (v2 Node elem-shape classifier) and v1.compiler.trait_derive_emit (v1 seed emitter derive selection). Dissolve-on: table migrates to derived rows when emit arms are total.".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + +#[derive( + Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize, +)] +#[serde(tag = "_variant")] +pub enum ReprGroundingDeriveTrait { + ReprDeriveClone, + ReprDeriveCopy, + ReprDerivePartialEq, + ReprDeriveEq, + ReprDerivePartialOrd, + ReprDeriveOrd, + ReprDeriveSerialize, + ReprDeriveDeserialize, + ReprDeriveAdd, + ReprDeriveSub, + ReprDeriveMul, + ReprDeriveDiv, + ReprDeriveRem, + ReprDeriveNeg, +} + +#[derive( + Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize, +)] +#[serde(tag = "_variant")] +pub enum ReprGroundingDeriveElemShape { + ReprDeriveElemKernelString, + ReprDeriveElemKernelInt, + ReprDeriveElemKernelBool, + ReprDeriveElemKernelUnit, + ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemUnknown, +} + +pub fn repr_grounding_derive_shape_has_trait( + shape: ReprGroundingDeriveElemShape, + derive_trait: ReprGroundingDeriveTrait, +) -> bool { + match shape.clone() { + ReprGroundingDeriveElemShape::ReprDeriveElemKernelString => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveEq => true, + ReprGroundingDeriveTrait::ReprDerivePartialOrd => true, + ReprGroundingDeriveTrait::ReprDeriveOrd => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + _ => false, + }, + ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDeriveCopy => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveEq => true, + ReprGroundingDeriveTrait::ReprDerivePartialOrd => true, + ReprGroundingDeriveTrait::ReprDeriveOrd => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + ReprGroundingDeriveTrait::ReprDeriveAdd => true, + ReprGroundingDeriveTrait::ReprDeriveSub => true, + ReprGroundingDeriveTrait::ReprDeriveMul => true, + ReprGroundingDeriveTrait::ReprDeriveDiv => true, + ReprGroundingDeriveTrait::ReprDeriveRem => true, + ReprGroundingDeriveTrait::ReprDeriveNeg => true, + }, + ReprGroundingDeriveElemShape::ReprDeriveElemKernelBool => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDeriveCopy => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveEq => true, + ReprGroundingDeriveTrait::ReprDerivePartialOrd => true, + ReprGroundingDeriveTrait::ReprDeriveOrd => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + _ => false, + }, + ReprGroundingDeriveElemShape::ReprDeriveElemKernelUnit => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDeriveCopy => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveEq => true, + ReprGroundingDeriveTrait::ReprDerivePartialOrd => true, + ReprGroundingDeriveTrait::ReprDeriveOrd => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + _ => false, + }, + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDeriveCopy => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveEq => true, + ReprGroundingDeriveTrait::ReprDerivePartialOrd => true, + ReprGroundingDeriveTrait::ReprDeriveOrd => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + _ => false, + }, + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => false, + } +} + +pub fn trait_derive_list_contains( + traits: Rc>, + derive_trait: ReprGroundingDeriveTrait, +) -> bool { + { + let mut __found = false; + for t in traits.clone().iter().cloned() { + if (t.clone() == derive_trait.clone()) { + __found = true; + break; + } + } + __found + } +} + +pub fn repr_grounding_derive_completeness_predicate( + required: Rc>, + shape: ReprGroundingDeriveElemShape, +) -> bool { + { + let mut __all = true; + for dt in required.clone().iter().cloned() { + if !(repr_grounding_derive_shape_has_trait(shape.clone(), dt.clone())) { + __all = false; + break; + } + } + __all + } +} + +pub fn record_derive_traits_heap() -> Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v + }) +} + +pub fn record_derive_traits_copy() -> Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveCopy); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v + }) +} + +pub fn nullary_coproduct_derive_traits() -> Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v + .insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveOrd); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialOrd); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveCopy); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v + }) +} + +pub fn payload_coproduct_derive_traits() -> Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v + }) +} + +pub fn trait_rust_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { + match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => "Clone".to_string(), + ReprGroundingDeriveTrait::ReprDeriveCopy => "Copy".to_string(), + ReprGroundingDeriveTrait::ReprDerivePartialEq => "PartialEq".to_string(), + ReprGroundingDeriveTrait::ReprDeriveEq => "Eq".to_string(), + ReprGroundingDeriveTrait::ReprDerivePartialOrd => "PartialOrd".to_string(), + ReprGroundingDeriveTrait::ReprDeriveOrd => "Ord".to_string(), + ReprGroundingDeriveTrait::ReprDeriveSerialize => "serde::Serialize".to_string(), + ReprGroundingDeriveTrait::ReprDeriveDeserialize => "serde::Deserialize".to_string(), + ReprGroundingDeriveTrait::ReprDeriveAdd => "std::ops::Add".to_string(), + ReprGroundingDeriveTrait::ReprDeriveSub => "std::ops::Sub".to_string(), + ReprGroundingDeriveTrait::ReprDeriveMul => "std::ops::Mul".to_string(), + ReprGroundingDeriveTrait::ReprDeriveDiv => "std::ops::Div".to_string(), + ReprGroundingDeriveTrait::ReprDeriveRem => "std::ops::Rem".to_string(), + ReprGroundingDeriveTrait::ReprDeriveNeg => "std::ops::Neg".to_string(), + } +} + +pub fn trait_derive_attr_from_traits(traits: Rc>) -> String { + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + "#[derive(Debug".to_string(), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveClone, + ) { + ", Clone".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveCopy, + ) { + ", Copy".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDerivePartialEq, + ) { + ", PartialEq".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveEq, + ) { + ", Eq".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDerivePartialOrd, + ) { + ", PartialOrd".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveOrd, + ) { + ", Ord".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveSerialize, + ) { + ", serde::Serialize".to_string() + } else { + "".to_string() + }, + ), + if trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveDeserialize, + ) { + ", serde::Deserialize".to_string() + } else { + "".to_string() + }, + ), + ")]".to_string(), + ) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveClone; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveCopy; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDerivePartialEq; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveEq; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDerivePartialOrd; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveOrd; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveSerialize; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveDeserialize; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveAdd; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveSub; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveMul; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveDiv; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveRem; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveNeg; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemKernelString; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemKernelInt; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemKernelBool; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemKernelUnit; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemNullaryEnumCopy; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemUnknown; diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index 9a983f46838..182113daeb8 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -100,6 +100,10 @@ pub use crate::v1_compiler_ownership::{ }; pub use crate::v1_compiler_resolve::get_exported_names; pub use crate::v1_compiler_runtime_rust::rust_runtime_source; +pub use crate::v1_compiler_trait_derive_emit::{ + v1_emit_enum_derives, v1_emit_struct_derives, v1_emit_type_params_with_clone_bounds, + v1_generic_params_needing_clone_bound, +}; use crate::v1_rt; use crate::v1_rt::Witness; use crate::v1_rt::Witness::{Holds, Violates}; @@ -11573,28 +11577,13 @@ pub fn emit_struct_from_children( ) -> String { { let has_fn_fields = type_has_fn_fields(name.clone(), emit_info.clone()); - let derives = if has_fn_fields.clone() { - "#[derive(Clone)]".to_string() - } else { - if (rust_nominal_ord_derives_for_shape( - name.clone(), - children.clone(), - env.source_indices.clone(), - ) != "".to_string()) - { - rust_nominal_ord_derives_for_shape( - name.clone(), - children.clone(), - env.source_indices.clone(), - ) - } else { - if v1_rt::set_contains(&shared_types, name.clone()) { - rust_struct_derives_text() - } else { - rust_struct_derives_copy_text() - } - } - }; + let derives = v1_emit_struct_derives( + name.clone(), + children.clone(), + shared_types.clone(), + has_fn_fields.clone(), + env.source_indices.clone(), + ); if ((children.clone().len() as i64) == 0) { v1_rt::concat( v1_rt::concat( @@ -12154,22 +12143,12 @@ pub fn emit_rust_field_definition( } } -pub fn enum_derives(name: String, children: Rc>>) -> String { - { - let complex = Rc::new({ - let mut __result = Vec::new(); - for v in children.clone().iter().cloned() { - if ((v.children.clone().len() as i64) > 0) { - __result.push(v); - } - } - __result - }); - match ((complex.clone().len() as i64) == 0) { - true => rust_ord_derives_copy_text(), - false => rust_enum_derives_text(), - } - } +pub fn enum_derives( + name: String, + children: Rc>>, + source_indices: Rc>>, +) -> String { + v1_emit_enum_derives(children.clone(), source_indices.clone()) } pub fn emit_enum_from_children( @@ -12184,7 +12163,7 @@ pub fn emit_enum_from_children( emit_info: Rc, ) -> String { { - let derives = enum_derives(name.clone(), children.clone()); + let derives = enum_derives(name.clone(), children.clone(), env.source_indices.clone()); let variant_lines = Rc::new({ let mut __result = Vec::new(); for child in children.clone().iter().cloned() { @@ -13241,38 +13220,19 @@ pub fn emit_fn_def( > 0); let return_based_clone = (return_is_bare_generic.clone() && !body_is_param_ref.clone()); - let element_clone_param = if body_is_param_ref.clone() { - None - } else { - Rc::new({ - let mut __result = Vec::new(); - for g in generic_param_names.clone().iter().cloned() { - if type_param_is_collection_element_in_values( - g.clone(), - value_params.clone(), - si.clone(), - ) { - __result.push(g); - } - } - __result - }) - .first() - .cloned() - }; - let clone_param = if return_based_clone.clone() { - ret_name.clone() - } else { - match element_clone_param.clone() { - Some(g) => g.clone(), - None => "".to_string(), - } - }; - let needs_clone_bound = (clone_param.clone() != "".to_string()); + let clone_param_names = v1_generic_params_needing_clone_bound( + generic_param_names.clone(), + value_params.clone(), + return_is_bare_generic.clone(), + ret_name.clone(), + body_is_param_ref.clone(), + si.clone(), + ); + let needs_clone_bound = ((clone_param_names.clone().len() as i64) > 0); let type_params_str = if needs_clone_bound.clone() { - emit_type_params_with_clone_bound( + v1_emit_type_params_with_clone_bounds( type_params.clone(), - clone_param.clone(), + clone_param_names.clone(), si.clone(), ) } else { diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs new file mode 100644 index 00000000000..65531e37fac --- /dev/null +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -0,0 +1,241 @@ +// Generated by v1 compiler -- do not edit. +// Source module: v1.compiler.trait_derive_emit + +use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ + ReprDeriveElemKernelInt, ReprDeriveElemNullaryEnumCopy, +}; +use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::ReprDeriveClone; +pub use crate::std_trait_derive_shape::{ + nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, + record_derive_traits_heap, repr_grounding_derive_completeness_predicate, + repr_grounding_derive_shape_has_trait, trait_derive_attr_from_traits, +}; +pub use crate::std_trait_derive_shape::{ReprGroundingDeriveElemShape, ReprGroundingDeriveTrait}; +pub use crate::std_types::is_container_type; +pub use crate::v1_compiler_emit::to_pascal; +pub use crate::v1_compiler_infer_types::{child_type_node, is_coproduct_type}; +use crate::v1_rt; +use crate::v1_rt::Witness; +use crate::v1_rt::Witness::{Holds, Violates}; +use crate::v1_rt::{VecCompat, VecJoin}; +use crate::v1_std_core::Connective::NoConnective; +pub use crate::v1_std_core::{authored_name_at, generic_param_name_at, param_node_type_expr}; +pub use crate::v1_std_core::{Connective, NewlineIndex, Node}; +use crate::NonEmptyBTreeSet; +use crate::NonEmptyVec; +use im::{vector as vec, HashMap, OrdSet as BTreeSet, Vector as Vec}; +use std::rc::Rc; + +pub fn v1_trait_derive_refuse(message: String) -> String { + v1_rt::concat( + v1_rt::concat("compile_error!(\"".to_string(), message.clone()), + "\");".to_string(), + ) +} + +pub fn v1_coproduct_all_variants_nullary(children: Rc>>) -> bool { + { + let mut __all = true; + for v in children.clone().iter().cloned() { + if !((v.children.clone().len() as i64) == 0) { + __all = false; + break; + } + } + __all + } +} + +pub fn v1_symbol_wrapped_ord_carrier_shape_eligible( + children: Rc>>, + source_indices: Rc>>, +) -> bool { + if ((children.clone().len() as i64) != 1) { + false + } else { + match children.clone().first().cloned() { + Some(child) => { + ((((authored_name_at(source_indices.clone(), child_type_node(child.clone())) + == "Symbol".to_string()) + && ((child_type_node(child.clone()).children.clone().len() as i64) == 0)) + && ((child_type_node(child.clone()).params.clone().len() as i64) == 0)) + && (child_type_node(child.clone()).connective.clone() + == Connective::NoConnective)) + } + None => false, + } + } +} + +pub fn v1_emit_struct_derives( + name: String, + children: Rc>>, + shared_types: Rc>, + has_fn_fields: bool, + source_indices: Rc>>, +) -> String { + if has_fn_fields.clone() { + "#[derive(Clone)]".to_string() + } else { + if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { + if repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, + ) { + trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse( + "trait_derive_emit: symbol-wrapped ord carrier refused".to_string(), + ) + } + } else { + if v1_rt::set_contains(&shared_types, name.clone()) { + trait_derive_attr_from_traits(record_derive_traits_heap()) + } else { + trait_derive_attr_from_traits(record_derive_traits_copy()) + } + } + } +} + +pub fn v1_emit_enum_derives( + children: Rc>>, + source_indices: Rc>>, +) -> String { + if v1_coproduct_all_variants_nullary(children.clone()) { + if repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, + ) { + trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse( + "trait_derive_emit: nullary coproduct derive completeness refused".to_string(), + ) + } + } else { + trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + } +} + +pub fn v1_generic_param_used_as_collection_element( + param_name: String, + value_params: Rc>>, + source_indices: Rc>>, +) -> bool { + { + let mut __found = false; + for vp in value_params.clone().iter().cloned() { + if { + let te = param_node_type_expr(vp.clone()); + (is_container_type(authored_name_at(source_indices.clone(), te.clone())) && { + let mut __found = false; + for c in te.children.clone().iter().cloned() { + if (authored_name_at(source_indices.clone(), c.clone()) + == param_name.clone()) + { + __found = true; + break; + } + } + __found + }) + } { + __found = true; + break; + } + } + __found + } +} + +pub fn v1_type_param_needs_clone_bound( + param_name: String, + return_is_bare_generic: bool, + ret_name: String, + body_is_param_ref: bool, + value_params: Rc>>, + source_indices: Rc>>, +) -> bool { + { + let structural = (((return_is_bare_generic.clone() && !body_is_param_ref.clone()) + && (param_name.clone() == ret_name.clone())) + || v1_generic_param_used_as_collection_element( + param_name.clone(), + value_params.clone(), + source_indices.clone(), + )); + (structural.clone() + && repr_grounding_derive_shape_has_trait( + ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt, + ReprGroundingDeriveTrait::ReprDeriveClone, + )) + } +} + +pub fn v1_generic_params_needing_clone_bound( + generic_param_names: Rc>, + value_params: Rc>>, + return_is_bare_generic: bool, + ret_name: String, + body_is_param_ref: bool, + source_indices: Rc>>, +) -> Rc> { + Rc::new({ + let mut __result = Vec::new(); + for g in generic_param_names.clone().iter().cloned() { + if v1_type_param_needs_clone_bound( + g.clone(), + return_is_bare_generic.clone(), + ret_name.clone(), + body_is_param_ref.clone(), + value_params.clone(), + source_indices.clone(), + ) { + __result.push(g); + } + } + __result + }) +} + +pub fn v1_emit_type_params_with_clone_bounds( + params: Rc>>, + clone_param_names: Rc>, + source_indices: Rc>>, +) -> String { + if ((params.clone().len() as i64) == 0) { + "".to_string() + } else { + { + let names = Rc::new({ + let mut __result = Vec::new(); + for p in params.clone().iter().cloned() { + __result.push({ + let pname = generic_param_name_at(p.clone(), source_indices.clone()); + let pascal = to_pascal(pname.clone()); + if { + let mut __found = false; + for c in clone_param_names.clone().iter().cloned() { + if (c.clone() == pname.clone()) { + __found = true; + break; + } + } + __found + } { + v1_rt::concat(pascal.clone(), ": Clone".to_string()) + } else { + pascal.clone() + } + }); + } + __result + }); + v1_rt::concat( + v1_rt::concat("<".to_string(), names.clone().join(&", ".to_string())), + ">".to_string(), + ) + } + } +} From 88dee1c278f935a86ddd57330cf63b780b983f53 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 23:02:26 +0000 Subject: [PATCH 13/53] Fix trait_derive witness tests after std authority split. Remove stale record_derive_traits import and align test calls with derive_trait parameter name so predicate witnesses execute green. Co-authored-by: Cursor --- src/v2/compiler/trait_derive_completeness.dag | 1 - .../trait_derive_completeness_predicate_test.dag | 14 +++++++------- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index cc84b37cded..ba493c96a08 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -19,7 +19,6 @@ import std.trait_derive_shape { ReprDeriveElemUnknown, repr_grounding_derive_shape_has_trait, repr_grounding_derive_completeness_predicate, - record_derive_traits, nullary_coproduct_derive_traits, payload_coproduct_derive_traits, trait_derive_attr_from_traits diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index 02de603cf99..bc0b6d1f4ae 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -138,15 +138,15 @@ fn tdc_binding_is(binding: Symbol, expected: Symbol) -> Bool { } test fn tdc_string_kernel_satisfies_clone_ord_serde_not_add() -> Bool { - repr_grounding_derive_trait_satisfied(trait: ReprDeriveClone, elem: symbol_kernel_type_node()) - && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: symbol_kernel_type_node()) - && repr_grounding_derive_trait_satisfied(trait: ReprDeriveSerialize, elem: symbol_kernel_type_node()) - && repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: symbol_kernel_type_node()) == false + repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveClone, elem: symbol_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveOrd, elem: symbol_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveSerialize, elem: symbol_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveAdd, elem: symbol_kernel_type_node()) == false } test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { - repr_grounding_derive_trait_satisfied(trait: ReprDeriveAdd, elem: trait_derive_int_kernel_type_node()) - && repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: trait_derive_int_kernel_type_node()) + repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveAdd, elem: trait_derive_int_kernel_type_node()) + && repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveOrd, elem: trait_derive_int_kernel_type_node()) && repr_grounding_derive_completeness_predicate_for_elem( required: Cons { head: ReprDeriveAdd, @@ -157,7 +157,7 @@ test fn tdc_int_kernel_satisfies_arith_and_ord() -> Bool { } test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { - repr_grounding_derive_trait_satisfied(trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) == false + repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveOrd, elem: tdc_unknown_atom_node()) == false && tdc_elem_shape_is_unknown(elem: tdc_unknown_atom_node()) && tdc_collection_witness_gate_is_incomplete( witness: TargetCollectionWitnessOrd { type_param: ^target_collection_type_param_t }, From 58bc25dddfdb2bf2e84a725dae187f08725ea2d5 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 23:17:26 +0000 Subject: [PATCH 14/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 55 +++++++++++++++++++ dag/std/trait_derive_shape.dag | 40 +------------- src/v1/trait_derive_emit.dag | 14 ++--- src/v2/compiler/trait_derive_completeness.dag | 3 +- src/v2/extdeps/languages/rust.dag | 4 +- .../trait_derive_seed_emit_binding_test.dag | 11 ++-- 6 files changed, 71 insertions(+), 56 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index 78d498f92a3..fe0c697efc6 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -1,6 +1,23 @@ module extdeps.languages.rust.emit import std.emit_model { SimpleMethodSpec } +import std.trait_derive_shape { + ReprGroundingDeriveTrait, + ReprDeriveClone, + ReprDeriveCopy, + ReprDerivePartialEq, + ReprDeriveEq, + ReprDerivePartialOrd, + ReprDeriveOrd, + ReprDeriveSerialize, + ReprDeriveDeserialize, + ReprDeriveAdd, + ReprDeriveSub, + ReprDeriveMul, + ReprDeriveDiv, + ReprDeriveRem, + ReprDeriveNeg +} import extdeps.external_authority { ExternalAuthority } import extdeps.uri { Uri, Https } @@ -69,6 +86,44 @@ data rust_enum_derives: String = "#[derive(Debug, Clone, PartialEq, serde::Seria data rust_enum_derives_copy: String = "#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]" +fn rust_repr_trait_derive_list_contains(traits: List, derive_trait: ReprGroundingDeriveTrait) -> Bool { + traits |> any(t => t == derive_trait) +} + +fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { + match derive_trait { + ReprDeriveClone => "Clone" + ReprDeriveCopy => "Copy" + ReprDerivePartialEq => "PartialEq" + ReprDeriveEq => "Eq" + ReprDerivePartialOrd => "PartialOrd" + ReprDeriveOrd => "Ord" + ReprDeriveSerialize => "serde::Serialize" + ReprDeriveDeserialize => "serde::Deserialize" + ReprDeriveAdd => "std::ops::Add" + ReprDeriveSub => "std::ops::Sub" + ReprDeriveMul => "std::ops::Mul" + ReprDeriveDiv => "std::ops::Div" + ReprDeriveRem => "std::ops::Rem" + ReprDeriveNeg => "std::ops::Neg" + } +} + +fn rust_trait_derive_attr_from_traits(traits: List) -> String { + concat( + "#[derive(Debug", + if rust_repr_trait_derive_list_contains(traits, ReprDeriveClone) { ", Clone" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDeriveCopy) { ", Copy" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDerivePartialEq) { ", PartialEq" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDeriveEq) { ", Eq" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDerivePartialOrd) { ", PartialOrd" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDeriveOrd) { ", Ord" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDeriveSerialize) { ", serde::Serialize" } else { "" }, + if rust_repr_trait_derive_list_contains(traits, ReprDeriveDeserialize) { ", serde::Deserialize" } else { "" }, + ")]" + ) +} + data rust_serde_tag: String = "#[serde(tag = \"_variant\")]" data rust_serde_rename_all_snake_case: String = "#[serde(rename_all = \"snake_case\")]" diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 168164f479d..43bbeb23769 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -2,7 +2,7 @@ module std.trait_derive_shape import std.algebra { Cons, Empty } -data trait_derive_shape_note: String = "Single authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Consumed by v2.compiler.trait_derive_completeness (v2 Node elem-shape classifier) and v1.compiler.trait_derive_emit (v1 seed emitter derive selection). Dissolve-on: table migrates to derived rows when emit arms are total." +data trait_derive_shape_note: String = "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit." type ReprGroundingDeriveTrait = ReprDeriveClone @@ -101,10 +101,6 @@ fn repr_grounding_derive_shape_has_trait( } } -fn trait_derive_list_contains(traits: List, derive_trait: ReprGroundingDeriveTrait) -> Bool { - traits |> any(t => t == derive_trait) -} - fn repr_grounding_derive_completeness_predicate( required: List, shape: ReprGroundingDeriveElemShape @@ -178,37 +174,3 @@ fn payload_coproduct_derive_traits() -> List { } } } - -fn trait_rust_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { - match derive_trait { - ReprDeriveClone => "Clone" - ReprDeriveCopy => "Copy" - ReprDerivePartialEq => "PartialEq" - ReprDeriveEq => "Eq" - ReprDerivePartialOrd => "PartialOrd" - ReprDeriveOrd => "Ord" - ReprDeriveSerialize => "serde::Serialize" - ReprDeriveDeserialize => "serde::Deserialize" - ReprDeriveAdd => "std::ops::Add" - ReprDeriveSub => "std::ops::Sub" - ReprDeriveMul => "std::ops::Mul" - ReprDeriveDiv => "std::ops::Div" - ReprDeriveRem => "std::ops::Rem" - ReprDeriveNeg => "std::ops::Neg" - } -} - -fn trait_derive_attr_from_traits(traits: List) -> String { - concat( - "#[derive(Debug", - if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveClone) { ", Clone" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveCopy) { ", Copy" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDerivePartialEq) { ", PartialEq" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveEq) { ", Eq" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDerivePartialOrd) { ", PartialOrd" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveOrd) { ", Ord" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveSerialize) { ", serde::Serialize" } else { "" }, - if trait_derive_list_contains(traits: traits, derive_trait: ReprDeriveDeserialize) { ", serde::Deserialize" } else { "" }, - ")]" - ) -} diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 9651602917a..7cf2edcd469 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -15,9 +15,9 @@ import std.trait_derive_shape { record_derive_traits_heap, record_derive_traits_copy, nullary_coproduct_derive_traits, - payload_coproduct_derive_traits, - trait_derive_attr_from_traits + payload_coproduct_derive_traits } +import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } import std.types { is_container_type } fn v1_trait_derive_refuse(message: String) -> String { @@ -54,15 +54,15 @@ fn v1_emit_struct_derives( "#[derive(Clone)]" } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), ReprDeriveElemNullaryEnumCopy) { - trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) } else { v1_trait_derive_refuse("trait_derive_emit: symbol-wrapped ord carrier refused") } } else { if set_contains(shared_types, name) { - trait_derive_attr_from_traits(record_derive_traits_heap()) + rust_trait_derive_attr_from_traits(record_derive_traits_heap()) } else { - trait_derive_attr_from_traits(record_derive_traits_copy()) + rust_trait_derive_attr_from_traits(record_derive_traits_copy()) } } } @@ -70,12 +70,12 @@ fn v1_emit_struct_derives( fn v1_emit_enum_derives(children: List, source_indices: Map) -> String { if v1_coproduct_all_variants_nullary(children: children) { if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), ReprDeriveElemNullaryEnumCopy) { - trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) } else { v1_trait_derive_refuse("trait_derive_emit: nullary coproduct derive completeness refused") } } else { - trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) } } diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index ba493c96a08..0de0c250424 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -20,8 +20,7 @@ import std.trait_derive_shape { repr_grounding_derive_shape_has_trait, repr_grounding_derive_completeness_predicate, nullary_coproduct_derive_traits, - payload_coproduct_derive_traits, - trait_derive_attr_from_traits + payload_coproduct_derive_traits } import v2.std.algebra { Cons, Empty, fold_list } import v2.std.collection { List } diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index fb375b55ec3..38344091576 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -291,7 +291,9 @@ import extdeps.languages.rust.emit { rust_enum_derives, rust_enum_derives_copy, rust_struct_derives, - rust_struct_derives_copy + rust_struct_derives_copy, + rust_trait_derive_attr_from_traits, + rust_trait_derive_spelling } type RustIntKind diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index f07b63204e1..5ab85fa15f9 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -1,19 +1,16 @@ module v2.test.emit.trait_derive_seed_emit_binding_test import std.trait_derive_shape { - ReprDeriveClone, - ReprDerivePartialEq, - ReprDeriveSerialize, ReprDeriveElemNullaryEnumCopy, nullary_coproduct_derive_traits, record_derive_traits_heap, record_derive_traits_copy, - trait_derive_attr_from_traits, repr_grounding_derive_completeness_predicate } +import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } import v2.std.logic { Bool } -data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.trait_derive_shape trait lists → derive attr spellings consumed by v1.compiler.trait_derive_emit (same authority path as seed emitter)." +data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.trait_derive_shape trait lists → extdeps.languages.rust.emit derive attr spellings consumed by v1.compiler.trait_derive_emit (same authority path as seed emitter)." test fn nullary_coproduct_predicate_satisfied() -> Bool { repr_grounding_derive_completeness_predicate( @@ -23,8 +20,8 @@ test fn nullary_coproduct_predicate_satisfied() -> Bool { } test fn record_heap_attr_contains_serde() -> Bool { - let heap_attr = trait_derive_attr_from_traits(record_derive_traits_heap()) - let copy_attr = trait_derive_attr_from_traits(record_derive_traits_copy()) + let heap_attr = rust_trait_derive_attr_from_traits(record_derive_traits_heap()) + let copy_attr = rust_trait_derive_attr_from_traits(record_derive_traits_copy()) heap_attr != "" && heap_attr != copy_attr } From 56e12c7d26d714aa7410c293171daa224471843b Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 23:23:39 +0000 Subject: [PATCH 15/53] Move Rust derive spellings from std to extdeps.languages.rust.emit. Addresses review 42322 layer-inversion note: target-agnostic trait-shape table stays in std.trait_derive_shape; rust_trait_derive_spelling and rust_trait_derive_attr_from_traits live beside existing rust_struct_derives rows. Regen updates stage0 emit + trait_derive modules. Co-authored-by: Cursor --- .../stage0/src/extdeps_languages_rust_emit.rs | 128 ++++++++++++++++++ src/v1/stage0/src/std_trait_derive_shape.rs | 124 +---------------- .../src/v1_compiler_trait_derive_emit.rs | 13 +- src/v2/extdeps/languages/rust.dag | 4 +- 4 files changed, 137 insertions(+), 132 deletions(-) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 95bdebbcb82..3d02de3690d 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -5,6 +5,12 @@ pub use crate::extdeps_external_authority::ExternalAuthority; use crate::extdeps_uri::UriScheme::Https; pub use crate::extdeps_uri::{Uri, UriScheme}; pub use crate::std_emit_model::SimpleMethodSpec; +pub use crate::std_trait_derive_shape::ReprGroundingDeriveTrait; +use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::{ + ReprDeriveAdd, ReprDeriveClone, ReprDeriveCopy, ReprDeriveDeserialize, ReprDeriveDiv, + ReprDeriveEq, ReprDeriveMul, ReprDeriveNeg, ReprDeriveOrd, ReprDerivePartialEq, + ReprDerivePartialOrd, ReprDeriveRem, ReprDeriveSerialize, ReprDeriveSub, +}; use crate::v1_rt; use crate::v1_rt::Witness; use crate::v1_rt::Witness::{Holds, Violates}; @@ -165,6 +171,128 @@ pub fn rust_enum_derives_copy() -> String { CACHED.with(|c: &String| c.clone()) } +pub fn rust_repr_trait_derive_list_contains( + traits: Rc>, + derive_trait: ReprGroundingDeriveTrait, +) -> bool { + { + let mut __found = false; + for t in traits.clone().iter().cloned() { + if (t.clone() == derive_trait.clone()) { + __found = true; + break; + } + } + __found + } +} + +pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { + match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => "Clone".to_string(), + ReprGroundingDeriveTrait::ReprDeriveCopy => "Copy".to_string(), + ReprGroundingDeriveTrait::ReprDerivePartialEq => "PartialEq".to_string(), + ReprGroundingDeriveTrait::ReprDeriveEq => "Eq".to_string(), + ReprGroundingDeriveTrait::ReprDerivePartialOrd => "PartialOrd".to_string(), + ReprGroundingDeriveTrait::ReprDeriveOrd => "Ord".to_string(), + ReprGroundingDeriveTrait::ReprDeriveSerialize => "serde::Serialize".to_string(), + ReprGroundingDeriveTrait::ReprDeriveDeserialize => "serde::Deserialize".to_string(), + ReprGroundingDeriveTrait::ReprDeriveAdd => "std::ops::Add".to_string(), + ReprGroundingDeriveTrait::ReprDeriveSub => "std::ops::Sub".to_string(), + ReprGroundingDeriveTrait::ReprDeriveMul => "std::ops::Mul".to_string(), + ReprGroundingDeriveTrait::ReprDeriveDiv => "std::ops::Div".to_string(), + ReprGroundingDeriveTrait::ReprDeriveRem => "std::ops::Rem".to_string(), + ReprGroundingDeriveTrait::ReprDeriveNeg => "std::ops::Neg".to_string(), + } +} + +pub fn rust_trait_derive_attr_from_traits(traits: Rc>) -> String { + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + v1_rt::concat( + "#[derive(Debug".to_string(), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveClone, + ) { + ", Clone".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveCopy, + ) { + ", Copy".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDerivePartialEq, + ) { + ", PartialEq".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveEq, + ) { + ", Eq".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDerivePartialOrd, + ) { + ", PartialOrd".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveOrd, + ) { + ", Ord".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveSerialize, + ) { + ", serde::Serialize".to_string() + } else { + "".to_string() + }, + ), + if rust_repr_trait_derive_list_contains( + traits.clone(), + ReprGroundingDeriveTrait::ReprDeriveDeserialize, + ) { + ", serde::Deserialize".to_string() + } else { + "".to_string() + }, + ), + ")]".to_string(), + ) +} + pub fn rust_serde_tag() -> String { thread_local! { static CACHED: String = { diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index 976334b46f1..229df19089d 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -16,7 +16,7 @@ use std::rc::Rc; pub fn trait_derive_shape_note() -> String { thread_local! { static CACHED: String = { - "Single authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Consumed by v2.compiler.trait_derive_completeness (v2 Node elem-shape classifier) and v1.compiler.trait_derive_emit (v1 seed emitter derive selection). Dissolve-on: table migrates to derived rows when emit arms are total.".to_string() + "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit.".to_string() }; } CACHED.with(|c: &String| c.clone()) @@ -124,22 +124,6 @@ pub fn repr_grounding_derive_shape_has_trait( } } -pub fn trait_derive_list_contains( - traits: Rc>, - derive_trait: ReprGroundingDeriveTrait, -) -> bool { - { - let mut __found = false; - for t in traits.clone().iter().cloned() { - if (t.clone() == derive_trait.clone()) { - __found = true; - break; - } - } - __found - } -} - pub fn repr_grounding_derive_completeness_predicate( required: Rc>, shape: ReprGroundingDeriveElemShape, @@ -274,112 +258,6 @@ pub fn payload_coproduct_derive_traits() -> Rc> { }) } -pub fn trait_rust_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { - match derive_trait.clone() { - ReprGroundingDeriveTrait::ReprDeriveClone => "Clone".to_string(), - ReprGroundingDeriveTrait::ReprDeriveCopy => "Copy".to_string(), - ReprGroundingDeriveTrait::ReprDerivePartialEq => "PartialEq".to_string(), - ReprGroundingDeriveTrait::ReprDeriveEq => "Eq".to_string(), - ReprGroundingDeriveTrait::ReprDerivePartialOrd => "PartialOrd".to_string(), - ReprGroundingDeriveTrait::ReprDeriveOrd => "Ord".to_string(), - ReprGroundingDeriveTrait::ReprDeriveSerialize => "serde::Serialize".to_string(), - ReprGroundingDeriveTrait::ReprDeriveDeserialize => "serde::Deserialize".to_string(), - ReprGroundingDeriveTrait::ReprDeriveAdd => "std::ops::Add".to_string(), - ReprGroundingDeriveTrait::ReprDeriveSub => "std::ops::Sub".to_string(), - ReprGroundingDeriveTrait::ReprDeriveMul => "std::ops::Mul".to_string(), - ReprGroundingDeriveTrait::ReprDeriveDiv => "std::ops::Div".to_string(), - ReprGroundingDeriveTrait::ReprDeriveRem => "std::ops::Rem".to_string(), - ReprGroundingDeriveTrait::ReprDeriveNeg => "std::ops::Neg".to_string(), - } -} - -pub fn trait_derive_attr_from_traits(traits: Rc>) -> String { - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - "#[derive(Debug".to_string(), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveClone, - ) { - ", Clone".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveCopy, - ) { - ", Copy".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDerivePartialEq, - ) { - ", PartialEq".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveEq, - ) { - ", Eq".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDerivePartialOrd, - ) { - ", PartialOrd".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveOrd, - ) { - ", Ord".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveSerialize, - ) { - ", serde::Serialize".to_string() - } else { - "".to_string() - }, - ), - if trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveDeserialize, - ) { - ", serde::Deserialize".to_string() - } else { - "".to_string() - }, - ), - ")]".to_string(), - ) -} - #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveClone; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 65531e37fac..80fb9b194b4 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -1,6 +1,7 @@ // Generated by v1 compiler -- do not edit. // Source module: v1.compiler.trait_derive_emit +pub use crate::extdeps_languages_rust_emit::rust_trait_derive_attr_from_traits; use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ ReprDeriveElemKernelInt, ReprDeriveElemNullaryEnumCopy, }; @@ -8,7 +9,7 @@ use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::ReprDeriveClone; pub use crate::std_trait_derive_shape::{ nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, record_derive_traits_heap, repr_grounding_derive_completeness_predicate, - repr_grounding_derive_shape_has_trait, trait_derive_attr_from_traits, + repr_grounding_derive_shape_has_trait, }; pub use crate::std_trait_derive_shape::{ReprGroundingDeriveElemShape, ReprGroundingDeriveTrait}; pub use crate::std_types::is_container_type; @@ -82,7 +83,7 @@ pub fn v1_emit_struct_derives( nullary_coproduct_derive_traits(), ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, ) { - trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) } else { v1_trait_derive_refuse( "trait_derive_emit: symbol-wrapped ord carrier refused".to_string(), @@ -90,9 +91,9 @@ pub fn v1_emit_struct_derives( } } else { if v1_rt::set_contains(&shared_types, name.clone()) { - trait_derive_attr_from_traits(record_derive_traits_heap()) + rust_trait_derive_attr_from_traits(record_derive_traits_heap()) } else { - trait_derive_attr_from_traits(record_derive_traits_copy()) + rust_trait_derive_attr_from_traits(record_derive_traits_copy()) } } } @@ -107,14 +108,14 @@ pub fn v1_emit_enum_derives( nullary_coproduct_derive_traits(), ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, ) { - trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) } else { v1_trait_derive_refuse( "trait_derive_emit: nullary coproduct derive completeness refused".to_string(), ) } } else { - trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) } } diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index 38344091576..fb375b55ec3 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -291,9 +291,7 @@ import extdeps.languages.rust.emit { rust_enum_derives, rust_enum_derives_copy, rust_struct_derives, - rust_struct_derives_copy, - rust_trait_derive_attr_from_traits, - rust_trait_derive_spelling + rust_struct_derives_copy } type RustIntKind From 5ebce2b201da2411352ca7a19116b0b68c411ff5 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 23:35:16 +0000 Subject: [PATCH 16/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index fe0c697efc6..e528e37edd7 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -86,10 +86,6 @@ data rust_enum_derives: String = "#[derive(Debug, Clone, PartialEq, serde::Seria data rust_enum_derives_copy: String = "#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]" -fn rust_repr_trait_derive_list_contains(traits: List, derive_trait: ReprGroundingDeriveTrait) -> Bool { - traits |> any(t => t == derive_trait) -} - fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { match derive_trait { ReprDeriveClone => "Clone" @@ -111,15 +107,8 @@ fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String fn rust_trait_derive_attr_from_traits(traits: List) -> String { concat( - "#[derive(Debug", - if rust_repr_trait_derive_list_contains(traits, ReprDeriveClone) { ", Clone" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDeriveCopy) { ", Copy" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDerivePartialEq) { ", PartialEq" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDeriveEq) { ", Eq" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDerivePartialOrd) { ", PartialOrd" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDeriveOrd) { ", Ord" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDeriveSerialize) { ", serde::Serialize" } else { "" }, - if rust_repr_trait_derive_list_contains(traits, ReprDeriveDeserialize) { ", serde::Deserialize" } else { "" }, + "#[derive(Debug, ", + traits |> map(t => rust_trait_derive_spelling(t)) |> join(separator: ", "), ")]" ) } From 5f8f5ac04ce46a2e162111134265e801ade39db1 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 24 Jul 2026 23:39:58 +0000 Subject: [PATCH 17/53] Derive rust_trait_derive_attr_from_traits via spelling table map/join. Single authority for per-trait Rust spellings (review 42331): attr string is Debug + traits |> map(rust_trait_derive_spelling) |> join. Co-authored-by: Cursor --- .../stage0/src/extdeps_languages_rust_emit.rs | 104 ++---------------- 1 file changed, 9 insertions(+), 95 deletions(-) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 3d02de3690d..ce7b447384b 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -171,22 +171,6 @@ pub fn rust_enum_derives_copy() -> String { CACHED.with(|c: &String| c.clone()) } -pub fn rust_repr_trait_derive_list_contains( - traits: Rc>, - derive_trait: ReprGroundingDeriveTrait, -) -> bool { - { - let mut __found = false; - for t in traits.clone().iter().cloned() { - if (t.clone() == derive_trait.clone()) { - __found = true; - break; - } - } - __found - } -} - pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { match derive_trait.clone() { ReprGroundingDeriveTrait::ReprDeriveClone => "Clone".to_string(), @@ -209,85 +193,15 @@ pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> Str pub fn rust_trait_derive_attr_from_traits(traits: Rc>) -> String { v1_rt::concat( v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - v1_rt::concat( - "#[derive(Debug".to_string(), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveClone, - ) { - ", Clone".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveCopy, - ) { - ", Copy".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDerivePartialEq, - ) { - ", PartialEq".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveEq, - ) { - ", Eq".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDerivePartialOrd, - ) { - ", PartialOrd".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveOrd, - ) { - ", Ord".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveSerialize, - ) { - ", serde::Serialize".to_string() - } else { - "".to_string() - }, - ), - if rust_repr_trait_derive_list_contains( - traits.clone(), - ReprGroundingDeriveTrait::ReprDeriveDeserialize, - ) { - ", serde::Deserialize".to_string() - } else { - "".to_string() - }, + "#[derive(Debug, ".to_string(), + Rc::new({ + let mut __result = Vec::new(); + for t in traits.clone().iter().cloned() { + __result.push(rust_trait_derive_spelling(t.clone())); + } + __result + }) + .join(&", ".to_string()), ), ")]".to_string(), ) From 6514a67d28ef60e69e771b8f8c39aed04693b705 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 00:12:49 +0000 Subject: [PATCH 18/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/trait_derive_emit.dag | 91 ++++++++++++++++++++++++++++++------ 1 file changed, 77 insertions(+), 14 deletions(-) diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 7cf2edcd469..8a81be2dc4f 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,17 +1,20 @@ module v1.compiler.trait_derive_emit -import v1.compiler.infer_types { is_coproduct_type, child_type_node } +import v1.compiler.infer_types { is_coproduct_type, is_unit_like, child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, NoConnective } import v1.compiler.emit { to_pascal } import std.trait_derive_shape { - ReprDeriveClone, - ReprDeriveElemNullaryEnumCopy, + ReprGroundingDeriveElemShape, + ReprDeriveElemKernelString, ReprDeriveElemKernelInt, + ReprDeriveElemKernelBool, + ReprDeriveElemKernelUnit, + ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemUnknown, repr_grounding_derive_completeness_predicate, - repr_grounding_derive_shape_has_trait, record_derive_traits_heap, record_derive_traits_copy, nullary_coproduct_derive_traits, @@ -28,6 +31,61 @@ fn v1_coproduct_all_variants_nullary(children: List) -> Bool { children |> all(v => v.children |> count == 0) } +fn v1_repr_grounding_derive_elem_shape_from_type_node( + n: Node, + source_indices: Map +) -> ReprGroundingDeriveElemShape { + if is_coproduct_type(n: n) { + if v1_coproduct_all_variants_nullary(children: n.children) { + ReprDeriveElemNullaryEnumCopy + } else { + ReprDeriveElemUnknown + } + } else { + let name = authored_name_at(source_indices: source_indices, node: n) + if name == "String" || name == "Symbol" { + ReprDeriveElemKernelString + } else if name == "Int" || name == "Nat" { + ReprDeriveElemKernelInt + } else if name == "Bool" { + ReprDeriveElemKernelBool + } else if name == "Unit" || is_unit_like(n: n) { + ReprDeriveElemKernelUnit + } else { + ReprDeriveElemUnknown + } + } +} + +fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( + children: List, + source_indices: Map +) -> ReprGroundingDeriveElemShape { + if v1_coproduct_all_variants_nullary(children: children) { + ReprDeriveElemNullaryEnumCopy + } else { + ReprDeriveElemUnknown + } +} + +fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( + children: List, + source_indices: Map +) -> ReprGroundingDeriveElemShape { + if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { + match children |> first { + Present { value: child } => + v1_repr_grounding_derive_elem_shape_from_type_node( + n: child_type_node(ch: child), + source_indices: source_indices + ) + Absent => ReprDeriveElemUnknown + } + } else { + ReprDeriveElemUnknown + } +} + fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { if (children |> count) != 1 { false @@ -53,7 +111,8 @@ fn v1_emit_struct_derives( if has_fn_fields { "#[derive(Clone)]" } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { - if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), ReprDeriveElemNullaryEnumCopy) { + let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier(children: children, source_indices: source_indices) + if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), shape) { rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) } else { v1_trait_derive_refuse("trait_derive_emit: symbol-wrapped ord carrier refused") @@ -68,14 +127,18 @@ fn v1_emit_struct_derives( } fn v1_emit_enum_derives(children: List, source_indices: Map) -> String { - if v1_coproduct_all_variants_nullary(children: children) { - if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), ReprDeriveElemNullaryEnumCopy) { - rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) - } else { - v1_trait_derive_refuse("trait_derive_emit: nullary coproduct derive completeness refused") - } - } else { - rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + let shape = v1_repr_grounding_derive_elem_shape_from_coproduct_children(children: children, source_indices: source_indices) + match shape { + ReprDeriveElemNullaryEnumCopy => + if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), shape) { + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse("trait_derive_emit: nullary coproduct derive completeness refused") + } + ReprDeriveElemUnknown => + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + _ => + v1_trait_derive_refuse("trait_derive_emit: coproduct elem shape unsupported for derive selection") } } @@ -101,7 +164,7 @@ fn v1_type_param_needs_clone_bound( ) -> Bool { let structural = (return_is_bare_generic && !body_is_param_ref && param_name == ret_name) || v1_generic_param_used_as_collection_element(param_name: param_name, value_params: value_params, source_indices: source_indices) - structural && repr_grounding_derive_shape_has_trait(ReprDeriveElemKernelInt, ReprDeriveClone) + structural } fn v1_generic_params_needing_clone_bound( From 319b3e9987391f86f45a8ccbcd40b6c11e82cee5 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 00:23:16 +0000 Subject: [PATCH 19/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- .../src/v1_compiler_trait_derive_emit.rs | 133 ++++++++++++++---- src/v1/trait_derive_emit.dag | 41 +----- 2 files changed, 104 insertions(+), 70 deletions(-) diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 80fb9b194b4..73cd993340f 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -2,19 +2,18 @@ // Source module: v1.compiler.trait_derive_emit pub use crate::extdeps_languages_rust_emit::rust_trait_derive_attr_from_traits; +pub use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape; use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ - ReprDeriveElemKernelInt, ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemKernelBool, ReprDeriveElemKernelInt, ReprDeriveElemKernelString, + ReprDeriveElemKernelUnit, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, }; -use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::ReprDeriveClone; pub use crate::std_trait_derive_shape::{ nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, record_derive_traits_heap, repr_grounding_derive_completeness_predicate, - repr_grounding_derive_shape_has_trait, }; -pub use crate::std_trait_derive_shape::{ReprGroundingDeriveElemShape, ReprGroundingDeriveTrait}; pub use crate::std_types::is_container_type; pub use crate::v1_compiler_emit::to_pascal; -pub use crate::v1_compiler_infer_types::{child_type_node, is_coproduct_type}; +pub use crate::v1_compiler_infer_types::{child_type_node, is_coproduct_type, is_unit_like}; use crate::v1_rt; use crate::v1_rt::Witness; use crate::v1_rt::Witness::{Holds, Violates}; @@ -47,6 +46,62 @@ pub fn v1_coproduct_all_variants_nullary(children: Rc>>) -> bool { } } +pub fn v1_repr_grounding_derive_elem_shape_from_type_node( + n: Rc, + source_indices: Rc>>, +) -> ReprGroundingDeriveElemShape { + if is_coproduct_type(n.clone()) { + if v1_coproduct_all_variants_nullary(n.children.clone()) { + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy + } else { + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown + } + } else { + { + let name = authored_name_at(source_indices.clone(), n.clone()); + if ((name.clone() == "String".to_string()) || (name.clone() == "Symbol".to_string())) { + ReprGroundingDeriveElemShape::ReprDeriveElemKernelString + } else { + if ((name.clone() == "Int".to_string()) || (name.clone() == "Nat".to_string())) { + ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt + } else { + if (name.clone() == "Bool".to_string()) { + ReprGroundingDeriveElemShape::ReprDeriveElemKernelBool + } else { + if ((name.clone() == "Unit".to_string()) || is_unit_like(n.clone())) { + ReprGroundingDeriveElemShape::ReprDeriveElemKernelUnit + } else { + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown + } + } + } + } + } + } +} + +pub fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( + children: Rc>>, + source_indices: Rc>>, +) -> ReprGroundingDeriveElemShape { + if v1_coproduct_all_variants_nullary(children.clone()) { + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy + } else { + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown + } +} + +pub fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( + children: Rc>>, + source_indices: Rc>>, +) -> ReprGroundingDeriveElemShape { + if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy + } else { + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown + } +} + pub fn v1_symbol_wrapped_ord_carrier_shape_eligible( children: Rc>>, source_indices: Rc>>, @@ -79,15 +134,21 @@ pub fn v1_emit_struct_derives( "#[derive(Clone)]".to_string() } else { if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { - if repr_grounding_derive_completeness_predicate( - nullary_coproduct_derive_traits(), - ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, - ) { - rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) - } else { - v1_trait_derive_refuse( - "trait_derive_emit: symbol-wrapped ord carrier refused".to_string(), - ) + { + let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier( + children.clone(), + source_indices.clone(), + ); + if repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + shape.clone(), + ) { + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse( + "trait_derive_emit: symbol-wrapped ord carrier refused".to_string(), + ) + } } } else { if v1_rt::set_contains(&shared_types, name.clone()) { @@ -103,19 +164,33 @@ pub fn v1_emit_enum_derives( children: Rc>>, source_indices: Rc>>, ) -> String { - if v1_coproduct_all_variants_nullary(children.clone()) { - if repr_grounding_derive_completeness_predicate( - nullary_coproduct_derive_traits(), - ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, - ) { - rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) - } else { - v1_trait_derive_refuse( - "trait_derive_emit: nullary coproduct derive completeness refused".to_string(), - ) + { + let shape = v1_repr_grounding_derive_elem_shape_from_coproduct_children( + children.clone(), + source_indices.clone(), + ); + match shape.clone() { + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy => { + if repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + shape.clone(), + ) { + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse( + "trait_derive_emit: nullary coproduct derive completeness refused" + .to_string(), + ) + } + } + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => { + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + } + _ => v1_trait_derive_refuse( + "trait_derive_emit: coproduct elem shape unsupported for derive selection" + .to_string(), + ), } - } else { - rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) } } @@ -166,11 +241,7 @@ pub fn v1_type_param_needs_clone_bound( value_params.clone(), source_indices.clone(), )); - (structural.clone() - && repr_grounding_derive_shape_has_trait( - ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt, - ReprGroundingDeriveTrait::ReprDeriveClone, - )) + structural } } diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 8a81be2dc4f..7201537ca4b 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,6 +1,6 @@ module v1.compiler.trait_derive_emit -import v1.compiler.infer_types { is_coproduct_type, is_unit_like, child_type_node } +import v1.compiler.infer_types { child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, NoConnective @@ -8,10 +8,6 @@ import v1.std.core { import v1.compiler.emit { to_pascal } import std.trait_derive_shape { ReprGroundingDeriveElemShape, - ReprDeriveElemKernelString, - ReprDeriveElemKernelInt, - ReprDeriveElemKernelBool, - ReprDeriveElemKernelUnit, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, repr_grounding_derive_completeness_predicate, @@ -31,32 +27,6 @@ fn v1_coproduct_all_variants_nullary(children: List) -> Bool { children |> all(v => v.children |> count == 0) } -fn v1_repr_grounding_derive_elem_shape_from_type_node( - n: Node, - source_indices: Map -) -> ReprGroundingDeriveElemShape { - if is_coproduct_type(n: n) { - if v1_coproduct_all_variants_nullary(children: n.children) { - ReprDeriveElemNullaryEnumCopy - } else { - ReprDeriveElemUnknown - } - } else { - let name = authored_name_at(source_indices: source_indices, node: n) - if name == "String" || name == "Symbol" { - ReprDeriveElemKernelString - } else if name == "Int" || name == "Nat" { - ReprDeriveElemKernelInt - } else if name == "Bool" { - ReprDeriveElemKernelBool - } else if name == "Unit" || is_unit_like(n: n) { - ReprDeriveElemKernelUnit - } else { - ReprDeriveElemUnknown - } - } -} - fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( children: List, source_indices: Map @@ -73,14 +43,7 @@ fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( source_indices: Map ) -> ReprGroundingDeriveElemShape { if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { - match children |> first { - Present { value: child } => - v1_repr_grounding_derive_elem_shape_from_type_node( - n: child_type_node(ch: child), - source_indices: source_indices - ) - Absent => ReprDeriveElemUnknown - } + ReprDeriveElemNullaryEnumCopy } else { ReprDeriveElemUnknown } From 024803df021f31945462a24b57499d6a0ef080de Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 00:24:00 +0000 Subject: [PATCH 20/53] Thread v1 trait-derive shape through structure classifiers. Replace hard-coded ReprGroundingDeriveElemShape literals in predicate calls with classifiers over coproduct children and ord-carrier structure; drop tautological KernelInt+Clone gate on generic clone bounds (structural check is the honest authority for type-param bounds). Co-authored-by: Cursor --- .../src/v1_compiler_trait_derive_emit.rs | 39 +------------------ 1 file changed, 2 insertions(+), 37 deletions(-) diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 73cd993340f..0905c889079 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -4,8 +4,7 @@ pub use crate::extdeps_languages_rust_emit::rust_trait_derive_attr_from_traits; pub use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape; use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ - ReprDeriveElemKernelBool, ReprDeriveElemKernelInt, ReprDeriveElemKernelString, - ReprDeriveElemKernelUnit, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, + ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, }; pub use crate::std_trait_derive_shape::{ nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, @@ -13,7 +12,7 @@ pub use crate::std_trait_derive_shape::{ }; pub use crate::std_types::is_container_type; pub use crate::v1_compiler_emit::to_pascal; -pub use crate::v1_compiler_infer_types::{child_type_node, is_coproduct_type, is_unit_like}; +pub use crate::v1_compiler_infer_types::child_type_node; use crate::v1_rt; use crate::v1_rt::Witness; use crate::v1_rt::Witness::{Holds, Violates}; @@ -46,40 +45,6 @@ pub fn v1_coproduct_all_variants_nullary(children: Rc>>) -> bool { } } -pub fn v1_repr_grounding_derive_elem_shape_from_type_node( - n: Rc, - source_indices: Rc>>, -) -> ReprGroundingDeriveElemShape { - if is_coproduct_type(n.clone()) { - if v1_coproduct_all_variants_nullary(n.children.clone()) { - ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy - } else { - ReprGroundingDeriveElemShape::ReprDeriveElemUnknown - } - } else { - { - let name = authored_name_at(source_indices.clone(), n.clone()); - if ((name.clone() == "String".to_string()) || (name.clone() == "Symbol".to_string())) { - ReprGroundingDeriveElemShape::ReprDeriveElemKernelString - } else { - if ((name.clone() == "Int".to_string()) || (name.clone() == "Nat".to_string())) { - ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt - } else { - if (name.clone() == "Bool".to_string()) { - ReprGroundingDeriveElemShape::ReprDeriveElemKernelBool - } else { - if ((name.clone() == "Unit".to_string()) || is_unit_like(n.clone())) { - ReprGroundingDeriveElemShape::ReprDeriveElemKernelUnit - } else { - ReprGroundingDeriveElemShape::ReprDeriveElemUnknown - } - } - } - } - } - } -} - pub fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( children: Rc>>, source_indices: Rc>>, From b938a541512371c8f02ed5992179a190632788de Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 00:36:47 +0000 Subject: [PATCH 21/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/std/trait_derive_shape.dag | 34 ++++++++++++++++++++++++++++++++++ src/v1/trait_derive_emit.dag | 8 +++++--- 2 files changed, 39 insertions(+), 3 deletions(-) diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 43bbeb23769..9f5edfadc3b 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -26,6 +26,7 @@ type ReprGroundingDeriveElemShape | ReprDeriveElemKernelBool | ReprDeriveElemKernelUnit | ReprDeriveElemNullaryEnumCopy + | ReprDeriveElemSymbolWrappedOrdCarrier | ReprDeriveElemUnknown fn repr_grounding_derive_shape_has_trait( @@ -97,6 +98,17 @@ fn repr_grounding_derive_shape_has_trait( ReprDeriveDeserialize => true _ => false } + ReprDeriveElemSymbolWrappedOrdCarrier => + match derive_trait { + ReprDeriveClone => true + ReprDerivePartialEq => true + ReprDeriveEq => true + ReprDerivePartialOrd => true + ReprDeriveOrd => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } ReprDeriveElemUnknown => false } } @@ -162,6 +174,28 @@ fn nullary_coproduct_derive_traits() -> List { } } +fn symbol_wrapped_ord_carrier_derive_traits() -> List { + Cons { + head: ReprDeriveClone, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveEq, + tail: Cons { + head: ReprDerivePartialOrd, + tail: Cons { + head: ReprDeriveOrd, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } + } + } + } + } + } +} + fn payload_coproduct_derive_traits() -> List { Cons { head: ReprDeriveClone, diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 7201537ca4b..906343feccb 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -9,11 +9,13 @@ import v1.compiler.emit { to_pascal } import std.trait_derive_shape { ReprGroundingDeriveElemShape, ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, repr_grounding_derive_completeness_predicate, record_derive_traits_heap, record_derive_traits_copy, nullary_coproduct_derive_traits, + symbol_wrapped_ord_carrier_derive_traits, payload_coproduct_derive_traits } import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } @@ -43,7 +45,7 @@ fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( source_indices: Map ) -> ReprGroundingDeriveElemShape { if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { - ReprDeriveElemNullaryEnumCopy + ReprDeriveElemSymbolWrappedOrdCarrier } else { ReprDeriveElemUnknown } @@ -75,8 +77,8 @@ fn v1_emit_struct_derives( "#[derive(Clone)]" } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier(children: children, source_indices: source_indices) - if repr_grounding_derive_completeness_predicate(nullary_coproduct_derive_traits(), shape) { - rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + if repr_grounding_derive_completeness_predicate(symbol_wrapped_ord_carrier_derive_traits(), shape) { + rust_trait_derive_attr_from_traits(symbol_wrapped_ord_carrier_derive_traits()) } else { v1_trait_derive_refuse("trait_derive_emit: symbol-wrapped ord carrier refused") } From fef648ae2295f9243da4a71128c244586eced297 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 00:42:04 +0000 Subject: [PATCH 22/53] Fix ord-carrier struct derives: omit Copy for Symbol wrappers. Add ReprDeriveElemSymbolWrappedOrdCarrier + symbol_wrapped_ord_carrier_derive_traits (matching rust_ord_derives_text: Ord without Copy). Witness proves nullary copy traits are rejected for that shape. Co-authored-by: Cursor --- src/v1/stage0/src/std_trait_derive_shape.rs | 53 +++++++++++++++++++ .../src/v1_compiler_trait_derive_emit.rs | 9 ++-- .../trait_derive_seed_emit_binding_test.dag | 20 ++++++- 3 files changed, 77 insertions(+), 5 deletions(-) diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index 229df19089d..90532013401 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -53,6 +53,7 @@ pub enum ReprGroundingDeriveElemShape { ReprDeriveElemKernelBool, ReprDeriveElemKernelUnit, ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, } @@ -120,6 +121,18 @@ pub fn repr_grounding_derive_shape_has_trait( ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, _ => false, }, + ReprGroundingDeriveElemShape::ReprDeriveElemSymbolWrappedOrdCarrier => { + match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveEq => true, + ReprGroundingDeriveTrait::ReprDerivePartialOrd => true, + ReprGroundingDeriveTrait::ReprDeriveOrd => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + _ => false, + } + } ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => false, } } @@ -235,6 +248,44 @@ pub fn nullary_coproduct_derive_traits() -> Rc> { }) } +pub fn symbol_wrapped_ord_carrier_derive_traits() -> Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveOrd); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialOrd); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v + }) +} + pub fn payload_coproduct_derive_traits() -> Rc> { Rc::new({ let mut __cons_v = (*Rc::new({ @@ -297,4 +348,6 @@ pub struct ReprDeriveElemKernelUnit; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveElemNullaryEnumCopy; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemSymbolWrappedOrdCarrier; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveElemUnknown; diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 0905c889079..8f35623f3fa 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -4,11 +4,12 @@ pub use crate::extdeps_languages_rust_emit::rust_trait_derive_attr_from_traits; pub use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape; use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ - ReprDeriveElemNullaryEnumCopy, ReprDeriveElemUnknown, + ReprDeriveElemNullaryEnumCopy, ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, }; pub use crate::std_trait_derive_shape::{ nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, record_derive_traits_heap, repr_grounding_derive_completeness_predicate, + symbol_wrapped_ord_carrier_derive_traits, }; pub use crate::std_types::is_container_type; pub use crate::v1_compiler_emit::to_pascal; @@ -61,7 +62,7 @@ pub fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( source_indices: Rc>>, ) -> ReprGroundingDeriveElemShape { if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { - ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy + ReprGroundingDeriveElemShape::ReprDeriveElemSymbolWrappedOrdCarrier } else { ReprGroundingDeriveElemShape::ReprDeriveElemUnknown } @@ -105,10 +106,10 @@ pub fn v1_emit_struct_derives( source_indices.clone(), ); if repr_grounding_derive_completeness_predicate( - nullary_coproduct_derive_traits(), + symbol_wrapped_ord_carrier_derive_traits(), shape.clone(), ) { - rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + rust_trait_derive_attr_from_traits(symbol_wrapped_ord_carrier_derive_traits()) } else { v1_trait_derive_refuse( "trait_derive_emit: symbol-wrapped ord carrier refused".to_string(), diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index 5ab85fa15f9..8d0a0e2b668 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -2,7 +2,9 @@ module v2.test.emit.trait_derive_seed_emit_binding_test import std.trait_derive_shape { ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemSymbolWrappedOrdCarrier, nullary_coproduct_derive_traits, + symbol_wrapped_ord_carrier_derive_traits, record_derive_traits_heap, record_derive_traits_copy, repr_grounding_derive_completeness_predicate @@ -25,6 +27,22 @@ test fn record_heap_attr_contains_serde() -> Bool { heap_attr != "" && heap_attr != copy_attr } +test fn ord_carrier_shape_rejects_nullary_copy_traits() -> Bool { + repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + ReprDeriveElemSymbolWrappedOrdCarrier + ) == false +} + +test fn ord_carrier_attr_differs_from_nullary() -> Bool { + let ord_attr = rust_trait_derive_attr_from_traits(symbol_wrapped_ord_carrier_derive_traits()) + let nullary_attr = rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + ord_attr != "" && ord_attr != nullary_attr +} + test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { - nullary_coproduct_predicate_satisfied() && record_heap_attr_contains_serde() + nullary_coproduct_predicate_satisfied() + && record_heap_attr_contains_serde() + && ord_carrier_shape_rejects_nullary_copy_traits() + && ord_carrier_attr_differs_from_nullary() } From f01663bdd5aeedb3696c1dc4a760350b3d17a3c3 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 01:44:49 +0000 Subject: [PATCH 23/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/gunbc/non_fold_residue.dag | 2 +- dag/std/trait_derive_shape.dag | 4 +++- src/v1/trait_derive_emit.dag | 4 ++++ src/v2/compiler/trait_derive_completeness.dag | 2 +- 4 files changed, 9 insertions(+), 3 deletions(-) diff --git a/dag/gunbc/non_fold_residue.dag b/dag/gunbc/non_fold_residue.dag index 811e4b39cea..33cf5179b81 100644 --- a/dag/gunbc/non_fold_residue.dag +++ b/dag/gunbc/non_fold_residue.dag @@ -48,7 +48,7 @@ data nfr_dissolve_gate_membership: String = "derived equality on Gate from inhab data nfr_reason_trait_derive_shape_table: String = "trait-shape→derive-trait capability table (nested match on ReprGroundingDeriveElemShape × ReprGroundingDeriveTrait with off-trait wildcard arms returning false) landed with Gate-1 sub-wall #2 predicate scaffold (#7174); surfaced by whole-corpus nfr receipt after affected-set predict-skipped corpus-read witness at landing" -data nfr_dissolve_trait_derive_shape_table: String = "the three emit arms wire derive/impl selection through trait_derive_completeness.dag and the hand table migrates to derived rows (or a total match) — row deletes with the emit wiring landing" +data nfr_dissolve_trait_derive_shape_table: String = "the #7174 v1 emit arms (clone bounds + serde/debug/ord derives on named types) wire through trait_derive_completeness.dag and the hand table migrates to derived rows (or a total match) — row deletes with that wiring; coproduct-native arithmetic impl emission is out of scope (GroupCompletion grounding lane)" data nfr_reason_native_agreement_octet: String = "RuntimeValue primitive-discriminant projection (RuntimePrimitive arm extracts byte[1]; off-variant wildcard Absent) landed with Lane B native-agreement loudness (#7111); surfaced by whole-corpus nfr receipt after affected-set predict-skipped corpus-read witness at landing" diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 9f5edfadc3b..04137654a98 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -2,7 +2,9 @@ module std.trait_derive_shape import std.algebra { Cons, Empty } -data trait_derive_shape_note: String = "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit." +data trait_derive_shape_note: String = "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 scope (operator 2026-07-25): v1 emit wires clone bounds + serde/Debug/Ord derives on named structs/enums only; ReprDeriveAdd/Sub/… rows on KernelInt are predicate authority for the grounding lane (GroupCompletion, Vector), not v1 custom-impl emission." + +data trait_derive_shape_grounding_lane_handoff: String = "Arm (b) deferred to GroupCompletion grounding lane: coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). This module's capability table + repr_grounding_derive_completeness_predicate remain the shared authority; the grounding lane emits impl { … } from shape rows, not #[derive]. v1.compiler.trait_derive_emit does not wire arm (b)." type ReprGroundingDeriveTrait = ReprDeriveClone diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 906343feccb..1d1b7d6b59e 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,5 +1,9 @@ module v1.compiler.trait_derive_emit +// #7174 scope (operator 2026-07-25): (a) clone bounds on generic params; (c) serde/Debug/Ord +// #[derive] on named structs/enums via std.trait_derive_shape. Arm (b) coproduct-native +// arithmetic impl blocks — GroupCompletion grounding lane; not wired here. + import v1.compiler.infer_types { child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index 0de0c250424..d9a4db79e88 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -42,7 +42,7 @@ import v2.std.compilers.target_model { TargetCollectionWitnessOrd } -data trait_derive_completeness_note: String = "Gate-1 sub-wall #2: v2 Node elem-shape classifier + collection-witness gate over std.trait_derive_shape (single capability-table authority). Consumed by rust.dag surface-binding rows and v1.compiler.trait_derive_emit. Fail-closed: unknown shapes refuse. Dissolve-on: three emit arms + layer-boundary mock test wire through this module." +data trait_derive_completeness_note: String = "Gate-1 sub-wall #2 (#7174 narrowed 2026-07-25): v2 Node elem-shape classifier + collection-witness gate over std.trait_derive_shape. v1 emit wires (a) clone bounds on generic params and (c) serde/Debug/Ord #[derive] on named structs/enums; arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane (see std.trait_derive_shape.trait_derive_shape_grounding_lane_handoff). Fail-closed: unknown shapes refuse. Dissolve-on: those two v1 emit arms + layer-boundary mock test wire through this module." type TraitDeriveCompletenessGate = TraitDeriveCompletenessSatisfied From a19e969030dcd6c7a72ef95b8e44e3e53b1a7578 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 01:55:20 +0000 Subject: [PATCH 24/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/trait_derive_emit.dag | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 1d1b7d6b59e..4f0e46c9011 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,9 +1,5 @@ module v1.compiler.trait_derive_emit -// #7174 scope (operator 2026-07-25): (a) clone bounds on generic params; (c) serde/Debug/Ord -// #[derive] on named structs/enums via std.trait_derive_shape. Arm (b) coproduct-native -// arithmetic impl blocks — GroupCompletion grounding lane; not wired here. - import v1.compiler.infer_types { child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, @@ -25,6 +21,8 @@ import std.trait_derive_shape { import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } import std.types { is_container_type } +data trait_derive_emit_scope_note: String = "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds; (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane." + fn v1_trait_derive_refuse(message: String) -> String { concat("compile_error!(\"", message, "\");") } From e11a19f5e7cd86d97b44dd352544f61c3bf8f8cf Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 02:05:46 +0000 Subject: [PATCH 25/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 4 +- dag/std/trait_derive_shape.dag | 82 ++++++++---- src/v1/05_emit_rust.dag | 1 - .../stage0/src/extdeps_languages_rust_emit.rs | 7 +- src/v1/stage0/src/std_trait_derive_shape.rs | 124 +++++++++++++----- src/v1/stage0/src/v1_compiler_emit_rust.rs | 2 - .../src/v1_compiler_trait_derive_emit.rs | 9 ++ src/v1/trait_derive_emit.dag | 2 +- 8 files changed, 160 insertions(+), 71 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index e528e37edd7..f635d4638eb 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -3,6 +3,7 @@ module extdeps.languages.rust.emit import std.emit_model { SimpleMethodSpec } import std.trait_derive_shape { ReprGroundingDeriveTrait, + ReprDeriveDebug, ReprDeriveClone, ReprDeriveCopy, ReprDerivePartialEq, @@ -88,6 +89,7 @@ data rust_enum_derives_copy: String = "#[derive(Debug, Clone, Copy, PartialEq, s fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { match derive_trait { + ReprDeriveDebug => "Debug" ReprDeriveClone => "Clone" ReprDeriveCopy => "Copy" ReprDerivePartialEq => "PartialEq" @@ -107,7 +109,7 @@ fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String fn rust_trait_derive_attr_from_traits(traits: List) -> String { concat( - "#[derive(Debug, ", + "#[derive(", traits |> map(t => rust_trait_derive_spelling(t)) |> join(separator: ", "), ")]" ) diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 04137654a98..678d7e49663 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -6,8 +6,11 @@ data trait_derive_shape_note: String = "Target-agnostic authority for ReprGround data trait_derive_shape_grounding_lane_handoff: String = "Arm (b) deferred to GroupCompletion grounding lane: coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). This module's capability table + repr_grounding_derive_completeness_predicate remain the shared authority; the grounding lane emits impl { … } from shape rows, not #[derive]. v1.compiler.trait_derive_emit does not wire arm (b)." +data trait_derive_shape_dissolve_on: String = "ReprGroundingDeriveTrait members that name Rust-specific authorities (ReprDeriveSerialize, ReprDeriveAdd, …) migrate beside each target's spelling table when a second consumer exists; until then capability roles stay in std/ with spellings in extdeps.languages.rust.emit." + type ReprGroundingDeriveTrait - = ReprDeriveClone + = ReprDeriveDebug + | ReprDeriveClone | ReprDeriveCopy | ReprDerivePartialEq | ReprDeriveEq @@ -38,6 +41,7 @@ fn repr_grounding_derive_shape_has_trait( match shape { ReprDeriveElemKernelString => match derive_trait { + ReprDeriveDebug => true ReprDeriveClone => true ReprDerivePartialEq => true ReprDeriveEq => true @@ -49,6 +53,7 @@ fn repr_grounding_derive_shape_has_trait( } ReprDeriveElemKernelInt => match derive_trait { + ReprDeriveDebug => true ReprDeriveClone => true ReprDeriveCopy => true ReprDerivePartialEq => true @@ -66,6 +71,7 @@ fn repr_grounding_derive_shape_has_trait( } ReprDeriveElemKernelBool => match derive_trait { + ReprDeriveDebug => true ReprDeriveClone => true ReprDeriveCopy => true ReprDerivePartialEq => true @@ -78,6 +84,7 @@ fn repr_grounding_derive_shape_has_trait( } ReprDeriveElemKernelUnit => match derive_trait { + ReprDeriveDebug => true ReprDeriveClone => true ReprDeriveCopy => true ReprDerivePartialEq => true @@ -90,6 +97,7 @@ fn repr_grounding_derive_shape_has_trait( } ReprDeriveElemNullaryEnumCopy => match derive_trait { + ReprDeriveDebug => true ReprDeriveClone => true ReprDeriveCopy => true ReprDerivePartialEq => true @@ -102,6 +110,7 @@ fn repr_grounding_derive_shape_has_trait( } ReprDeriveElemSymbolWrappedOrdCarrier => match derive_trait { + ReprDeriveDebug => true ReprDeriveClone => true ReprDerivePartialEq => true ReprDeriveEq => true @@ -124,12 +133,15 @@ fn repr_grounding_derive_completeness_predicate( fn record_derive_traits_heap() -> List { Cons { - head: ReprDeriveClone, + head: ReprDeriveDebug, tail: Cons { - head: ReprDerivePartialEq, + head: ReprDeriveClone, tail: Cons { - head: ReprDeriveSerialize, - tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } } } } @@ -137,14 +149,17 @@ fn record_derive_traits_heap() -> List { fn record_derive_traits_copy() -> List { Cons { - head: ReprDeriveClone, + head: ReprDeriveDebug, tail: Cons { - head: ReprDeriveCopy, + head: ReprDeriveClone, tail: Cons { - head: ReprDerivePartialEq, + head: ReprDeriveCopy, tail: Cons { - head: ReprDeriveSerialize, - tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } } } } @@ -153,20 +168,23 @@ fn record_derive_traits_copy() -> List { fn nullary_coproduct_derive_traits() -> List { Cons { - head: ReprDeriveClone, + head: ReprDeriveDebug, tail: Cons { - head: ReprDeriveCopy, + head: ReprDeriveClone, tail: Cons { - head: ReprDerivePartialEq, + head: ReprDeriveCopy, tail: Cons { - head: ReprDeriveEq, + head: ReprDerivePartialEq, tail: Cons { - head: ReprDerivePartialOrd, + head: ReprDeriveEq, tail: Cons { - head: ReprDeriveOrd, + head: ReprDerivePartialOrd, tail: Cons { - head: ReprDeriveSerialize, - tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + head: ReprDeriveOrd, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } } } } @@ -178,18 +196,21 @@ fn nullary_coproduct_derive_traits() -> List { fn symbol_wrapped_ord_carrier_derive_traits() -> List { Cons { - head: ReprDeriveClone, + head: ReprDeriveDebug, tail: Cons { - head: ReprDerivePartialEq, + head: ReprDeriveClone, tail: Cons { - head: ReprDeriveEq, + head: ReprDerivePartialEq, tail: Cons { - head: ReprDerivePartialOrd, + head: ReprDeriveEq, tail: Cons { - head: ReprDeriveOrd, + head: ReprDerivePartialOrd, tail: Cons { - head: ReprDeriveSerialize, - tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + head: ReprDeriveOrd, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } } } } @@ -200,12 +221,15 @@ fn symbol_wrapped_ord_carrier_derive_traits() -> List fn payload_coproduct_derive_traits() -> List { Cons { - head: ReprDeriveClone, + head: ReprDeriveDebug, tail: Cons { - head: ReprDerivePartialEq, + head: ReprDeriveClone, tail: Cons { - head: ReprDeriveSerialize, - tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + head: ReprDerivePartialEq, + tail: Cons { + head: ReprDeriveSerialize, + tail: Cons { head: ReprDeriveDeserialize, tail: Empty } + } } } } diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag index 03a9c78e5f1..1ef668f8115 100644 --- a/src/v1/05_emit_rust.dag +++ b/src/v1/05_emit_rust.dag @@ -5075,7 +5075,6 @@ fn emit_fn_def(name: String, params: List, inferred: Node, body: Node, reg let ret_name = authored_name_at(source_indices: si, node: inferred) let return_is_bare_generic = (generic_param_names |> filter(g => g == ret_name) |> count) > 0 let body_is_param_ref = (value_param_names |> filter(n => n == body.name) |> count) > 0 - let return_based_clone = return_is_bare_generic && !body_is_param_ref let clone_param_names = v1_generic_params_needing_clone_bound( generic_param_names: generic_param_names, value_params: value_params, diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index ce7b447384b..79b57e47ef4 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -7,8 +7,8 @@ pub use crate::extdeps_uri::{Uri, UriScheme}; pub use crate::std_emit_model::SimpleMethodSpec; pub use crate::std_trait_derive_shape::ReprGroundingDeriveTrait; use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::{ - ReprDeriveAdd, ReprDeriveClone, ReprDeriveCopy, ReprDeriveDeserialize, ReprDeriveDiv, - ReprDeriveEq, ReprDeriveMul, ReprDeriveNeg, ReprDeriveOrd, ReprDerivePartialEq, + ReprDeriveAdd, ReprDeriveClone, ReprDeriveCopy, ReprDeriveDebug, ReprDeriveDeserialize, + ReprDeriveDiv, ReprDeriveEq, ReprDeriveMul, ReprDeriveNeg, ReprDeriveOrd, ReprDerivePartialEq, ReprDerivePartialOrd, ReprDeriveRem, ReprDeriveSerialize, ReprDeriveSub, }; use crate::v1_rt; @@ -173,6 +173,7 @@ pub fn rust_enum_derives_copy() -> String { pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => "Debug".to_string(), ReprGroundingDeriveTrait::ReprDeriveClone => "Clone".to_string(), ReprGroundingDeriveTrait::ReprDeriveCopy => "Copy".to_string(), ReprGroundingDeriveTrait::ReprDerivePartialEq => "PartialEq".to_string(), @@ -193,7 +194,7 @@ pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> Str pub fn rust_trait_derive_attr_from_traits(traits: Rc>) -> String { v1_rt::concat( v1_rt::concat( - "#[derive(Debug, ".to_string(), + "#[derive(".to_string(), Rc::new({ let mut __result = Vec::new(); for t in traits.clone().iter().cloned() { diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index 90532013401..e6678dd1550 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -16,7 +16,25 @@ use std::rc::Rc; pub fn trait_derive_shape_note() -> String { thread_local! { static CACHED: String = { - "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit.".to_string() + "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 scope (operator 2026-07-25): v1 emit wires clone bounds + serde/Debug/Ord derives on named structs/enums only; ReprDeriveAdd/Sub/… rows on KernelInt are predicate authority for the grounding lane (GroupCompletion, Vector), not v1 custom-impl emission.".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + +pub fn trait_derive_shape_grounding_lane_handoff() -> String { + thread_local! { + static CACHED: String = { + "Arm (b) deferred to GroupCompletion grounding lane: coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). This module's capability table + repr_grounding_derive_completeness_predicate remain the shared authority; the grounding lane emits impl { … } from shape rows, not #[derive]. v1.compiler.trait_derive_emit does not wire arm (b).".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + +pub fn trait_derive_shape_dissolve_on() -> String { + thread_local! { + static CACHED: String = { + "ReprGroundingDeriveTrait members that name Rust-specific authorities (ReprDeriveSerialize, ReprDeriveAdd, …) migrate beside each target's spelling table when a second consumer exists; until then capability roles stay in std/ with spellings in extdeps.languages.rust.emit.".to_string() }; } CACHED.with(|c: &String| c.clone()) @@ -27,6 +45,7 @@ pub fn trait_derive_shape_note() -> String { )] #[serde(tag = "_variant")] pub enum ReprGroundingDeriveTrait { + ReprDeriveDebug, ReprDeriveClone, ReprDeriveCopy, ReprDerivePartialEq, @@ -63,6 +82,7 @@ pub fn repr_grounding_derive_shape_has_trait( ) -> bool { match shape.clone() { ReprGroundingDeriveElemShape::ReprDeriveElemKernelString => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, ReprGroundingDeriveTrait::ReprDeriveClone => true, ReprGroundingDeriveTrait::ReprDerivePartialEq => true, ReprGroundingDeriveTrait::ReprDeriveEq => true, @@ -73,6 +93,7 @@ pub fn repr_grounding_derive_shape_has_trait( _ => false, }, ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, ReprGroundingDeriveTrait::ReprDeriveClone => true, ReprGroundingDeriveTrait::ReprDeriveCopy => true, ReprGroundingDeriveTrait::ReprDerivePartialEq => true, @@ -89,6 +110,7 @@ pub fn repr_grounding_derive_shape_has_trait( ReprGroundingDeriveTrait::ReprDeriveNeg => true, }, ReprGroundingDeriveElemShape::ReprDeriveElemKernelBool => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, ReprGroundingDeriveTrait::ReprDeriveClone => true, ReprGroundingDeriveTrait::ReprDeriveCopy => true, ReprGroundingDeriveTrait::ReprDerivePartialEq => true, @@ -100,6 +122,7 @@ pub fn repr_grounding_derive_shape_has_trait( _ => false, }, ReprGroundingDeriveElemShape::ReprDeriveElemKernelUnit => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, ReprGroundingDeriveTrait::ReprDeriveClone => true, ReprGroundingDeriveTrait::ReprDeriveCopy => true, ReprGroundingDeriveTrait::ReprDerivePartialEq => true, @@ -111,6 +134,7 @@ pub fn repr_grounding_derive_shape_has_trait( _ => false, }, ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy => match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, ReprGroundingDeriveTrait::ReprDeriveClone => true, ReprGroundingDeriveTrait::ReprDeriveCopy => true, ReprGroundingDeriveTrait::ReprDerivePartialEq => true, @@ -123,6 +147,7 @@ pub fn repr_grounding_derive_shape_has_trait( }, ReprGroundingDeriveElemShape::ReprDeriveElemSymbolWrappedOrdCarrier => { match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, ReprGroundingDeriveTrait::ReprDeriveClone => true, ReprGroundingDeriveTrait::ReprDerivePartialEq => true, ReprGroundingDeriveTrait::ReprDeriveEq => true, @@ -158,20 +183,25 @@ pub fn record_derive_traits_heap() -> Rc> { let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ - let mut __cons_v = (*Rc::new(vec![])).clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDebug); __cons_v }) } @@ -182,24 +212,29 @@ pub fn record_derive_traits_copy() -> Rc> { let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ - let mut __cons_v = (*Rc::new(vec![])).clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveCopy); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveCopy); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDebug); __cons_v }) } @@ -213,37 +248,45 @@ pub fn nullary_coproduct_derive_traits() -> Rc> { let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ - let mut __cons_v = (*Rc::new(vec![])).clone(); + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert( + 0, + ReprGroundingDeriveTrait::ReprDeriveDeserialize, + ); + __cons_v + })) + .clone(); __cons_v - .insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + .insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveOrd); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveOrd); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialOrd); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialOrd); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveEq); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveEq); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveCopy); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveCopy); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDebug); __cons_v }) } @@ -256,32 +299,38 @@ pub fn symbol_wrapped_ord_carrier_derive_traits() -> Rc Rc> { let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ let mut __cons_v = (*Rc::new({ - let mut __cons_v = (*Rc::new(vec![])).clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDeserialize); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSerialize); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); __cons_v })) .clone(); - __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDebug); __cons_v }) } +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveDebug; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveClone; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index c9903e0dba5..6ad07774e50 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -13391,8 +13391,6 @@ pub fn emit_fn_def( }) .len() as i64) > 0); - let return_based_clone = - (return_is_bare_generic.clone() && !body_is_param_ref.clone()); let clone_param_names = v1_generic_params_needing_clone_bound( generic_param_names.clone(), value_params.clone(), diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 8f35623f3fa..80c20d4aaef 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -26,6 +26,15 @@ use crate::NonEmptyVec; use im::{vector as vec, HashMap, OrdSet as BTreeSet, Vector as Vec}; use std::rc::Rc; +pub fn trait_derive_emit_scope_note() -> String { + thread_local! { + static CACHED: String = { + "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds on all qualifying generic params (return-bare-generic and collection-element — widened from legacy single-param pick); (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane.".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + pub fn v1_trait_derive_refuse(message: String) -> String { v1_rt::concat( v1_rt::concat("compile_error!(\"".to_string(), message.clone()), diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 4f0e46c9011..dce39dd7742 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -21,7 +21,7 @@ import std.trait_derive_shape { import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } import std.types { is_container_type } -data trait_derive_emit_scope_note: String = "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds; (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane." +data trait_derive_emit_scope_note: String = "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds on all qualifying generic params (return-bare-generic and collection-element — widened from legacy single-param pick); (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane." fn v1_trait_derive_refuse(message: String) -> String { concat("compile_error!(\"", message, "\");") From f8d09c8755644cdd38663ff50b6095813cc50bab Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 03:11:39 +0000 Subject: [PATCH 26/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/std/trait_derive_shape.dag | 10 ++++ src/v1/trait_derive_emit.dag | 11 ++++- src/v2/compiler/trait_derive_completeness.dag | 3 +- src/v2/extdeps/languages/rust.dag | 24 ++++++++-- .../trait_derive_seed_emit_binding_test.dag | 10 ++++ ...ait_derive_completeness_predicate_test.dag | 47 ++++++++++++++++--- 6 files changed, 91 insertions(+), 14 deletions(-) diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 678d7e49663..a992dc535d7 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -32,6 +32,7 @@ type ReprGroundingDeriveElemShape | ReprDeriveElemKernelUnit | ReprDeriveElemNullaryEnumCopy | ReprDeriveElemSymbolWrappedOrdCarrier + | ReprDeriveElemPayloadCoproduct | ReprDeriveElemUnknown fn repr_grounding_derive_shape_has_trait( @@ -120,6 +121,15 @@ fn repr_grounding_derive_shape_has_trait( ReprDeriveDeserialize => true _ => false } + ReprDeriveElemPayloadCoproduct => + match derive_trait { + ReprDeriveDebug => true + ReprDeriveClone => true + ReprDerivePartialEq => true + ReprDeriveSerialize => true + ReprDeriveDeserialize => true + _ => false + } ReprDeriveElemUnknown => false } } diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index dce39dd7742..ef170344464 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -9,6 +9,7 @@ import v1.compiler.emit { to_pascal } import std.trait_derive_shape { ReprGroundingDeriveElemShape, ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemPayloadCoproduct, ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, repr_grounding_derive_completeness_predicate, @@ -38,7 +39,7 @@ fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( if v1_coproduct_all_variants_nullary(children: children) { ReprDeriveElemNullaryEnumCopy } else { - ReprDeriveElemUnknown + ReprDeriveElemPayloadCoproduct } } @@ -102,8 +103,14 @@ fn v1_emit_enum_derives(children: List, source_indices: Map + if repr_grounding_derive_completeness_predicate(payload_coproduct_derive_traits(), shape) { + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse("trait_derive_emit: payload coproduct derive completeness refused") + } ReprDeriveElemUnknown => - rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + v1_trait_derive_refuse("trait_derive_emit: unclassified elem shape refused") _ => v1_trait_derive_refuse("trait_derive_emit: coproduct elem shape unsupported for derive selection") } diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index d9a4db79e88..4f48d8cfb7e 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -16,6 +16,7 @@ import std.trait_derive_shape { ReprDeriveElemKernelBool, ReprDeriveElemKernelUnit, ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemPayloadCoproduct, ReprDeriveElemUnknown, repr_grounding_derive_shape_has_trait, repr_grounding_derive_completeness_predicate, @@ -70,7 +71,7 @@ fn repr_grounding_derive_elem_shape(elem: Node) -> ReprGroundingDeriveElemShape if coproduct_all_variants_nullary(edges: elem.children) { ReprDeriveElemNullaryEnumCopy } else { - ReprDeriveElemUnknown + ReprDeriveElemPayloadCoproduct } TypeNode { connective: Atom { identity: id } } => if id == ^target_collection_kernel_string || id == ^symbol_kernel_type_atom { diff --git a/src/v2/extdeps/languages/rust.dag b/src/v2/extdeps/languages/rust.dag index fb375b55ec3..3249b662b98 100644 --- a/src/v2/extdeps/languages/rust.dag +++ b/src/v2/extdeps/languages/rust.dag @@ -2171,15 +2171,29 @@ fn rust_decl_shared_derive_productions() -> List { ] } -fn rust_trait_derive_surface_binding_for_coproduct(coproduct: Node) -> Symbol { +fn rust_trait_derive_coproduct_diagnostic(reason: Symbol, node: Node) -> Diagnostic { + Diagnostic { + reason: reason, + at: node_locus(node: node), + correction: Unavailable { reason: ExternalContractUnknown } + } +} + +fn rust_trait_derive_surface_binding_for_coproduct(coproduct: Node) -> Outcome { match coproduct.kind { TypeNode { connective: Disj } => if coproduct_all_variants_nullary(edges: coproduct.children) { - ^rust_decl_derive_enum_copy_binding + outcome_accepted(value: ^rust_decl_derive_enum_copy_binding) } else { - ^rust_decl_derive_enum_binding + outcome_accepted(value: ^rust_decl_derive_enum_binding) } - _ => ^rust_decl_derive_enum_binding + _ => + outcome_rejected( + d: rust_trait_derive_coproduct_diagnostic( + reason: ^rust_trait_derive_coproduct_connective_unsupported, + node: coproduct + ) + ) } } @@ -2195,7 +2209,7 @@ fn rust_decl_struct_derive_binding() -> Symbol { ^rust_decl_derive_struct_binding } -fn rust_decl_enum_derive_binding_for_coproduct(coproduct: Node) -> Symbol { +fn rust_decl_enum_derive_binding_for_coproduct(coproduct: Node) -> Outcome { rust_trait_derive_surface_binding_for_coproduct(coproduct: coproduct) } diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index 8d0a0e2b668..98f83e411f7 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -2,8 +2,10 @@ module v2.test.emit.trait_derive_seed_emit_binding_test import std.trait_derive_shape { ReprDeriveElemNullaryEnumCopy, + ReprDeriveElemPayloadCoproduct, ReprDeriveElemSymbolWrappedOrdCarrier, nullary_coproduct_derive_traits, + payload_coproduct_derive_traits, symbol_wrapped_ord_carrier_derive_traits, record_derive_traits_heap, record_derive_traits_copy, @@ -40,8 +42,16 @@ test fn ord_carrier_attr_differs_from_nullary() -> Bool { ord_attr != "" && ord_attr != nullary_attr } +test fn payload_coproduct_predicate_satisfied() -> Bool { + repr_grounding_derive_completeness_predicate( + payload_coproduct_derive_traits(), + ReprDeriveElemPayloadCoproduct + ) +} + test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { nullary_coproduct_predicate_satisfied() + && payload_coproduct_predicate_satisfied() && record_heap_attr_contains_serde() && ord_carrier_shape_rejects_nullary_copy_traits() && ord_carrier_attr_differs_from_nullary() diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index bc0b6d1f4ae..12bd2404fe3 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -16,12 +16,16 @@ import v2.compiler.trait_derive_completeness { import std.trait_derive_shape { ReprDeriveElemKernelString, ReprDeriveElemNullaryEnumCopy, - ReprDeriveElemUnknown + ReprDeriveElemPayloadCoproduct, + ReprDeriveElemUnknown, + payload_coproduct_derive_traits, + repr_grounding_derive_completeness_predicate } import v2.extdeps.languages.rust { rust_trait_derive_surface_binding_for_coproduct, rust_trait_derive_surface_binding_for_record } +import v2.std.diagnostic { Accepted, Rejected } import v2.std.compilers.target_model { RequiredTraitWitness, TargetCollectionWitnessOrd, @@ -102,6 +106,13 @@ fn tdc_unknown_atom_node() -> Node { } } +fn tdc_elem_shape_is_payload_coproduct(elem: Node) -> Bool { + match repr_grounding_derive_elem_shape(elem: elem) { + ReprDeriveElemPayloadCoproduct => true + _ => false + } +} + fn tdc_elem_shape_is_unknown(elem: Node) -> Bool { match repr_grounding_derive_elem_shape(elem: elem) { ReprDeriveElemUnknown => true @@ -137,6 +148,20 @@ fn tdc_binding_is(binding: Symbol, expected: Symbol) -> Bool { binding == expected } +fn tdc_coproduct_binding_accepted(coproduct: Node) -> Symbol { + match rust_trait_derive_surface_binding_for_coproduct(coproduct: coproduct) { + Accepted { value: binding, diagnostics: _ } => binding + Rejected { .. } => ^tdc_impossible_coproduct_binding + } +} + +fn tdc_coproduct_binding_rejected(coproduct: Node) -> Bool { + match rust_trait_derive_surface_binding_for_coproduct(coproduct: coproduct) { + Rejected { .. } => true + Accepted { .. } => false + } +} + test fn tdc_string_kernel_satisfies_clone_ord_serde_not_add() -> Bool { repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveClone, elem: symbol_kernel_type_node()) && repr_grounding_derive_trait_satisfied(derive_trait: ReprDeriveOrd, elem: symbol_kernel_type_node()) @@ -165,16 +190,25 @@ test fn tdc_unknown_atom_refuses_ord_completeness() -> Bool { ) } +test fn tdc_payload_coproduct_shape_and_predicate() -> Bool { + tdc_elem_shape_is_payload_coproduct(elem: tdc_payload_enum_node()) + && repr_grounding_derive_completeness_predicate( + payload_coproduct_derive_traits(), + ReprDeriveElemPayloadCoproduct + ) + && tdc_binding_is( + binding: tdc_coproduct_binding_accepted(coproduct: tdc_payload_enum_node()), + expected: ^rust_decl_derive_enum_binding + ) + && tdc_coproduct_binding_rejected(coproduct: tdc_unknown_atom_node()) +} + test fn tdc_nullary_enum_copy_shape_and_binding() -> Bool { tdc_elem_shape_is_nullary_enum_copy(elem: tdc_nullary_enum_node()) && tdc_binding_is( - binding: rust_trait_derive_surface_binding_for_coproduct(coproduct: tdc_nullary_enum_node()), + binding: tdc_coproduct_binding_accepted(coproduct: tdc_nullary_enum_node()), expected: ^rust_decl_derive_enum_copy_binding ) - && tdc_binding_is( - binding: rust_trait_derive_surface_binding_for_coproduct(coproduct: tdc_payload_enum_node()), - expected: ^rust_decl_derive_enum_binding - ) } test fn tdc_symbol_kernel_string_shape() -> Bool { @@ -196,6 +230,7 @@ test fn tdc_trait_derive_completeness_predicate_witness_holds() -> Bool { tdc_string_kernel_satisfies_clone_ord_serde_not_add() && tdc_int_kernel_satisfies_arith_and_ord() && tdc_unknown_atom_refuses_ord_completeness() + && tdc_payload_coproduct_shape_and_predicate() && tdc_nullary_enum_copy_shape_and_binding() && tdc_symbol_kernel_string_shape() && tdc_record_surface_binding_heap_vs_copy() From 7acad5f4de5ff3d0d03417bf2a2e608b2454e6f9 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 03:15:10 +0000 Subject: [PATCH 27/53] Fix emit witness tests for Outcome coproduct derive bindings. Review 42427: unwrap Accepted arms in decl_emit and std_logic fixtures after rust_trait_derive_surface_binding_for_coproduct returns Outcome. Co-authored-by: Cursor --- .../test/claim/emit/decl_emit_consolidated_test.dag | 11 +++++++++-- .../claim/emit/std_logic_selfhost_witness_test.dag | 9 ++++++++- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/src/v2/test/claim/emit/decl_emit_consolidated_test.dag b/src/v2/test/claim/emit/decl_emit_consolidated_test.dag index 37472861b6b..f47ff9f84ce 100644 --- a/src/v2/test/claim/emit/decl_emit_consolidated_test.dag +++ b/src/v2/test/claim/emit/decl_emit_consolidated_test.dag @@ -92,9 +92,16 @@ fn dc_derive_attr(binding: Symbol) -> Node { dc_conj(children: [ dc_pos(target: rust_inhabitant_atom(id: binding)) ]) } +fn dc_coproduct_derive_binding(coproduct: Node) -> Symbol { + match rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct) { + Accepted { value: binding, diagnostics: _ } => binding + Rejected { .. } => ^rust_decl_derive_enum_copy_binding + } +} + fn dc_enum_nongeneric(name: String, coproduct: Node, variants: List) -> Node { dc_conj(children: [ - dc_pos(target: dc_derive_attr(binding: rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct))), + dc_pos(target: dc_derive_attr(binding: dc_coproduct_derive_binding(coproduct: coproduct))), dc_pos(target: dc_atom(s: name)), dc_pos(target: dc_variant_block(variants: variants)) ]) @@ -102,7 +109,7 @@ fn dc_enum_nongeneric(name: String, coproduct: Node, variants: List) -> No fn dc_enum_generic(name: String, coproduct: Node, params: List, variants: List) -> Node { dc_conj(children: [ - dc_pos(target: dc_derive_attr(binding: rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct))), + dc_pos(target: dc_derive_attr(binding: dc_coproduct_derive_binding(coproduct: coproduct))), dc_pos(target: dc_atom(s: name)), dc_pos(target: dc_generic_params(params: params)), dc_pos(target: dc_variant_block(variants: variants)) diff --git a/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag b/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag index 41a5abfe5ac..fd20a870b68 100644 --- a/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag +++ b/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag @@ -49,9 +49,16 @@ fn sl_derive_attr(binding: Symbol) -> Node { sl_conj(children: [ sl_pos(target: rust_inhabitant_atom(id: binding)) ]) } +fn sl_coproduct_derive_binding(coproduct: Node) -> Symbol { + match rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct) { + Accepted { value: binding, diagnostics: _ } => binding + Rejected { .. } => ^rust_decl_derive_enum_copy_binding + } +} + fn sl_enum_nongeneric(name: String, coproduct: Node, variants: List) -> Node { sl_conj(children: [ - sl_pos(target: sl_derive_attr(binding: rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct))), + sl_pos(target: sl_derive_attr(binding: sl_coproduct_derive_binding(coproduct: coproduct))), sl_pos(target: sl_atom(s: name)), sl_pos(target: sl_variant_block(variants: variants)) ]) From dff02bed923b1d3edcc8213c42af833724825e92 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 03:26:36 +0000 Subject: [PATCH 28/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v2/test/claim/emit/decl_emit_consolidated_test.dag | 2 +- src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag | 2 +- .../test/claim/trait_derive_completeness_predicate_test.dag | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/v2/test/claim/emit/decl_emit_consolidated_test.dag b/src/v2/test/claim/emit/decl_emit_consolidated_test.dag index f47ff9f84ce..d06a6db9f94 100644 --- a/src/v2/test/claim/emit/decl_emit_consolidated_test.dag +++ b/src/v2/test/claim/emit/decl_emit_consolidated_test.dag @@ -95,7 +95,7 @@ fn dc_derive_attr(binding: Symbol) -> Node { fn dc_coproduct_derive_binding(coproduct: Node) -> Symbol { match rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct) { Accepted { value: binding, diagnostics: _ } => binding - Rejected { .. } => ^rust_decl_derive_enum_copy_binding + Rejected { diagnostics: _ } => ^rust_decl_derive_enum_copy_binding } } diff --git a/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag b/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag index fd20a870b68..376f1edbbc0 100644 --- a/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag +++ b/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag @@ -52,7 +52,7 @@ fn sl_derive_attr(binding: Symbol) -> Node { fn sl_coproduct_derive_binding(coproduct: Node) -> Symbol { match rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct) { Accepted { value: binding, diagnostics: _ } => binding - Rejected { .. } => ^rust_decl_derive_enum_copy_binding + Rejected { diagnostics: _ } => ^rust_decl_derive_enum_copy_binding } } diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index 12bd2404fe3..74e24046b55 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -151,14 +151,14 @@ fn tdc_binding_is(binding: Symbol, expected: Symbol) -> Bool { fn tdc_coproduct_binding_accepted(coproduct: Node) -> Symbol { match rust_trait_derive_surface_binding_for_coproduct(coproduct: coproduct) { Accepted { value: binding, diagnostics: _ } => binding - Rejected { .. } => ^tdc_impossible_coproduct_binding + Rejected { diagnostics: _ } => ^tdc_impossible_coproduct_binding } } fn tdc_coproduct_binding_rejected(coproduct: Node) -> Bool { match rust_trait_derive_surface_binding_for_coproduct(coproduct: coproduct) { - Rejected { .. } => true - Accepted { .. } => false + Rejected { diagnostics: _ } => true + Accepted { value: _, diagnostics: _ } => false } } From bd87a16444a7c5b4bcb949d5f6b0d2bc66f52a46 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 03:33:40 +0000 Subject: [PATCH 29/53] Hard-fail coproduct derive binding refusal in emit test harnesses. Review 42434: replace Rejected => copy-binding absorbing fallback with refused sentinel bindings plus explicit non-Disj rejection witnesses. Co-authored-by: Cursor --- .../emit/decl_emit_consolidated_test.dag | 25 +++++++++++++++---- .../emit/std_logic_selfhost_witness_test.dag | 24 +++++++++++++++--- 2 files changed, 40 insertions(+), 9 deletions(-) diff --git a/src/v2/test/claim/emit/decl_emit_consolidated_test.dag b/src/v2/test/claim/emit/decl_emit_consolidated_test.dag index d06a6db9f94..20b0d6cede9 100644 --- a/src/v2/test/claim/emit/decl_emit_consolidated_test.dag +++ b/src/v2/test/claim/emit/decl_emit_consolidated_test.dag @@ -92,16 +92,18 @@ fn dc_derive_attr(binding: Symbol) -> Node { dc_conj(children: [ dc_pos(target: rust_inhabitant_atom(id: binding)) ]) } -fn dc_coproduct_derive_binding(coproduct: Node) -> Symbol { +fn dc_enum_derive_binding_row(coproduct: Node) -> Edge { match rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct) { - Accepted { value: binding, diagnostics: _ } => binding - Rejected { diagnostics: _ } => ^rust_decl_derive_enum_copy_binding + Accepted { value: binding, diagnostics: _ } => + dc_pos(target: dc_derive_attr(binding: binding)) + Rejected { diagnostics: _ } => + dc_pos(target: dc_derive_attr(binding: ^dc_coproduct_derive_binding_refused)) } } fn dc_enum_nongeneric(name: String, coproduct: Node, variants: List) -> Node { dc_conj(children: [ - dc_pos(target: dc_derive_attr(binding: dc_coproduct_derive_binding(coproduct: coproduct))), + dc_enum_derive_binding_row(coproduct: coproduct), dc_pos(target: dc_atom(s: name)), dc_pos(target: dc_variant_block(variants: variants)) ]) @@ -109,7 +111,7 @@ fn dc_enum_nongeneric(name: String, coproduct: Node, variants: List) -> No fn dc_enum_generic(name: String, coproduct: Node, params: List, variants: List) -> Node { dc_conj(children: [ - dc_pos(target: dc_derive_attr(binding: dc_coproduct_derive_binding(coproduct: coproduct))), + dc_enum_derive_binding_row(coproduct: coproduct), dc_pos(target: dc_atom(s: name)), dc_pos(target: dc_generic_params(params: params)), dc_pos(target: dc_variant_block(variants: variants)) @@ -364,10 +366,23 @@ fn dc_golden_discriminates_holds() -> Bool { fn dc_gaps_refused_holds() -> Bool { dc_struct_refused(emitted: dc_empty_record_emitted()) && dc_enum_refused(emitted: dc_empty_enum_emitted()) + && dc_coproduct_derive_binding_rejects_non_disj() + && dc_enum_refused(emitted: dc_enum_non_disj_coproduct_emitted()) && (dc_refused_count() == 2) && (dc_covered_count() == 10) } +fn dc_coproduct_derive_binding_rejects_non_disj() -> Bool { + match rust_decl_enum_derive_binding_for_coproduct(coproduct: dc_atom_type(t: "NotDisj")) { + Rejected { diagnostics: _ } => true + Accepted { value: _, diagnostics: _ } => false + } +} + +fn dc_enum_non_disj_coproduct_emitted() -> Node { + dc_enum_nongeneric(name: "Bad", coproduct: dc_atom_type(t: "NotDisj"), variants: []) +} + fn dc_witness_module_fully_emitted_holds() -> Bool { dc_struct_matches(emitted: dc_spw_emitted(), golden: dc_spw_golden) && dc_struct_matches(emitted: dc_hw_emitted(), golden: dc_hw_golden) diff --git a/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag b/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag index 376f1edbbc0..346f652589c 100644 --- a/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag +++ b/src/v2/test/claim/emit/std_logic_selfhost_witness_test.dag @@ -49,16 +49,18 @@ fn sl_derive_attr(binding: Symbol) -> Node { sl_conj(children: [ sl_pos(target: rust_inhabitant_atom(id: binding)) ]) } -fn sl_coproduct_derive_binding(coproduct: Node) -> Symbol { +fn sl_enum_derive_binding_row(coproduct: Node) -> Edge { match rust_decl_enum_derive_binding_for_coproduct(coproduct: coproduct) { - Accepted { value: binding, diagnostics: _ } => binding - Rejected { diagnostics: _ } => ^rust_decl_derive_enum_copy_binding + Accepted { value: binding, diagnostics: _ } => + sl_pos(target: sl_derive_attr(binding: binding)) + Rejected { diagnostics: _ } => + sl_pos(target: sl_derive_attr(binding: ^sl_coproduct_derive_binding_refused)) } } fn sl_enum_nongeneric(name: String, coproduct: Node, variants: List) -> Node { sl_conj(children: [ - sl_pos(target: sl_derive_attr(binding: sl_coproduct_derive_binding(coproduct: coproduct))), + sl_enum_derive_binding_row(coproduct: coproduct), sl_pos(target: sl_atom(s: name)), sl_pos(target: sl_variant_block(variants: variants)) ]) @@ -113,4 +115,18 @@ fn std_logic_bool_emit_matches(golden: String) -> Bool { test fn std_logic_bool_type_decl_self_emits() -> Bool { std_logic_bool_emit_matches(golden: std_logic_bool_enum_golden) && !std_logic_bool_emit_matches(golden: std_logic_bool_wrong_golden) + && sl_coproduct_derive_binding_rejects_non_disj() +} + +fn sl_coproduct_derive_binding_rejects_non_disj() -> Bool { + match rust_decl_enum_derive_binding_for_coproduct( + coproduct: Node { + kind: TypeNode { connective: Atom { identity: ^sl_non_disj_atom } }, + children: [], + occurrence_id: SyntheticOccurrence + } + ) { + Rejected { diagnostics: _ } => true + Accepted { value: _, diagnostics: _ } => false + } } From ec21eb88aacba2f3bac11df4beb64c12291a07ca Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 03:47:50 +0000 Subject: [PATCH 30/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/stage0/src/std_trait_derive_shape.rs | 13 +++++++++++ .../src/v1_compiler_trait_derive_emit.rs | 22 +++++++++++++++---- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index e6678dd1550..6649d38cd88 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -73,6 +73,7 @@ pub enum ReprGroundingDeriveElemShape { ReprDeriveElemKernelUnit, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemSymbolWrappedOrdCarrier, + ReprDeriveElemPayloadCoproduct, ReprDeriveElemUnknown, } @@ -158,6 +159,16 @@ pub fn repr_grounding_derive_shape_has_trait( _ => false, } } + ReprGroundingDeriveElemShape::ReprDeriveElemPayloadCoproduct => { + match derive_trait.clone() { + ReprGroundingDeriveTrait::ReprDeriveDebug => true, + ReprGroundingDeriveTrait::ReprDeriveClone => true, + ReprGroundingDeriveTrait::ReprDerivePartialEq => true, + ReprGroundingDeriveTrait::ReprDeriveSerialize => true, + ReprGroundingDeriveTrait::ReprDeriveDeserialize => true, + _ => false, + } + } ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => false, } } @@ -406,4 +417,6 @@ pub struct ReprDeriveElemNullaryEnumCopy; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveElemSymbolWrappedOrdCarrier; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] +pub struct ReprDeriveElemPayloadCoproduct; +#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveElemUnknown; diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 80c20d4aaef..26431dbc540 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -4,7 +4,8 @@ pub use crate::extdeps_languages_rust_emit::rust_trait_derive_attr_from_traits; pub use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape; use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ - ReprDeriveElemNullaryEnumCopy, ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, + ReprDeriveElemNullaryEnumCopy, ReprDeriveElemPayloadCoproduct, + ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, }; pub use crate::std_trait_derive_shape::{ nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, @@ -62,7 +63,7 @@ pub fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( if v1_coproduct_all_variants_nullary(children.clone()) { ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy } else { - ReprGroundingDeriveElemShape::ReprDeriveElemUnknown + ReprGroundingDeriveElemShape::ReprDeriveElemPayloadCoproduct } } @@ -158,9 +159,22 @@ pub fn v1_emit_enum_derives( ) } } - ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => { - rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + ReprGroundingDeriveElemShape::ReprDeriveElemPayloadCoproduct => { + if repr_grounding_derive_completeness_predicate( + payload_coproduct_derive_traits(), + shape.clone(), + ) { + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + } else { + v1_trait_derive_refuse( + "trait_derive_emit: payload coproduct derive completeness refused" + .to_string(), + ) + } } + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => v1_trait_derive_refuse( + "trait_derive_emit: unclassified elem shape refused".to_string(), + ), _ => v1_trait_derive_refuse( "trait_derive_emit: coproduct elem shape unsupported for derive selection" .to_string(), From 7522b7c2828f79cb6716d40c0f42d8075fb130ec Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 03:52:48 +0000 Subject: [PATCH 31/53] Drop unused imports from trait_derive_completeness.dag. Review 42440 nit: remove fold_list, ReprDeriveCopy/Serialize/Add, and unused trait-list imports not referenced by the module body. Co-authored-by: Cursor --- src/v2/compiler/trait_derive_completeness.dag | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index 4f48d8cfb7e..c699ab034ed 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -2,13 +2,10 @@ module v2.compiler.trait_derive_completeness import std.trait_derive_shape { ReprDeriveClone, - ReprDeriveCopy, ReprDerivePartialEq, ReprDeriveEq, ReprDerivePartialOrd, ReprDeriveOrd, - ReprDeriveSerialize, - ReprDeriveAdd, ReprGroundingDeriveTrait, ReprGroundingDeriveElemShape, ReprDeriveElemKernelInt, @@ -19,11 +16,9 @@ import std.trait_derive_shape { ReprDeriveElemPayloadCoproduct, ReprDeriveElemUnknown, repr_grounding_derive_shape_has_trait, - repr_grounding_derive_completeness_predicate, - nullary_coproduct_derive_traits, - payload_coproduct_derive_traits + repr_grounding_derive_completeness_predicate } -import v2.std.algebra { Cons, Empty, fold_list } +import v2.std.algebra { Cons, Empty } import v2.std.collection { List } import v2.std.logic { Bool } import v2.std.node { From 574491301bf528590bec3cd1ae697217f22fe82a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 04:32:06 +0000 Subject: [PATCH 32/53] Fix trait_derive witness imports: derive traits live in std.trait_derive_shape. The predicate test imported ReprDeriveAdd/Clone/Ord/Serialize from v2.compiler.trait_derive_completeness, which does not re-export them; CI batch 3 failed at resolve time. Co-authored-by: Cursor --- .../claim/trait_derive_completeness_predicate_test.dag | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag index 74e24046b55..5efcfef23b3 100644 --- a/src/v2/test/claim/trait_derive_completeness_predicate_test.dag +++ b/src/v2/test/claim/trait_derive_completeness_predicate_test.dag @@ -1,10 +1,6 @@ module v2.test.claim.trait_derive_completeness_predicate import v2.compiler.trait_derive_completeness { - ReprDeriveAdd, - ReprDeriveClone, - ReprDeriveOrd, - ReprDeriveSerialize, TraitDeriveCompletenessIncomplete, TraitDeriveCompletenessSatisfied, repr_grounding_derive_completeness_predicate_for_elem, @@ -14,10 +10,14 @@ import v2.compiler.trait_derive_completeness { trait_derive_int_kernel_type_node } import std.trait_derive_shape { + ReprDeriveAdd, + ReprDeriveClone, ReprDeriveElemKernelString, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemPayloadCoproduct, ReprDeriveElemUnknown, + ReprDeriveOrd, + ReprDeriveSerialize, payload_coproduct_derive_traits, repr_grounding_derive_completeness_predicate } From 64e245deaaecfb03f2e2faca2bdd3d45b47f1bf3 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 04:46:23 +0000 Subject: [PATCH 33/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 14 +++++++++----- dag/std/trait_derive_shape.dag | 4 ++++ src/v1/trait_derive_emit.dag | 3 ++- 3 files changed, 15 insertions(+), 6 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index f635d4638eb..ee34c8d32e6 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -17,7 +17,11 @@ import std.trait_derive_shape { ReprDeriveMul, ReprDeriveDiv, ReprDeriveRem, - ReprDeriveNeg + ReprDeriveNeg, + record_derive_traits_heap, + record_derive_traits_copy, + payload_coproduct_derive_traits, + nullary_coproduct_derive_traits } import extdeps.external_authority { ExternalAuthority } import extdeps.uri { Uri, Https } @@ -80,12 +84,12 @@ data rust_reserved_escape_suffix: String = "_" data rust_string_types: List = ["String", "Secret"] -data rust_struct_derives: String = "#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]" +data rust_struct_derives: String = rust_trait_derive_attr_from_traits(record_derive_traits_heap()) -data rust_struct_derives_copy: String = "#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]" -data rust_enum_derives: String = "#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]" +data rust_struct_derives_copy: String = rust_trait_derive_attr_from_traits(record_derive_traits_copy()) +data rust_enum_derives: String = rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) -data rust_enum_derives_copy: String = "#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]" +data rust_enum_derives_copy: String = rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { match derive_trait { diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index a992dc535d7..62f15420545 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -229,6 +229,10 @@ fn symbol_wrapped_ord_carrier_derive_traits() -> List } } +fn fn_field_derive_traits() -> List { + Cons { head: ReprDeriveClone, tail: Empty } +} + fn payload_coproduct_derive_traits() -> List { Cons { head: ReprDeriveDebug, diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index ef170344464..176fbc948c5 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -17,7 +17,8 @@ import std.trait_derive_shape { record_derive_traits_copy, nullary_coproduct_derive_traits, symbol_wrapped_ord_carrier_derive_traits, - payload_coproduct_derive_traits + payload_coproduct_derive_traits, + fn_field_derive_traits } import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } import std.types { is_container_type } From a7f6d0c28b7d35a534ba7dcfc61bfb98a9d3561a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 04:52:00 +0000 Subject: [PATCH 34/53] Address review 42471: authority-derived derive attrs, dissolve-on scaffolds. - rust_struct/enum_derives* constants now project std.trait_derive_shape trait lists through rust_trait_derive_attr_from_traits (no parallel literals) - Remove dead rust_*_derives_text helpers from v1 emit - Route fn-field structs through fn_field_derive_traits + attr builder - Add dissolve-on notes for v1 coproduct walk and Symbol ord-carrier gate - Regen stage0 for emit/trait_derive modules Co-authored-by: Cursor --- src/v1/05_emit_rust.dag | 17 ---------- .../stage0/src/extdeps_languages_rust_emit.rs | 32 +++++-------------- src/v1/stage0/src/std_trait_derive_shape.rs | 8 +++++ src/v1/stage0/src/v1_compiler_emit_rust.rs | 20 ++---------- .../src/v1_compiler_trait_derive_emit.rs | 26 ++++++++++++--- src/v1/trait_derive_emit.dag | 6 +++- 6 files changed, 45 insertions(+), 64 deletions(-) diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag index 3a20a1434e9..27fafe79440 100644 --- a/src/v1/05_emit_rust.dag +++ b/src/v1/05_emit_rust.dag @@ -37,7 +37,6 @@ import v1.std.core { import v1.compiler.artifact { RenderTarget, Rust } import extdeps.languages.rust.emit { rt_functions, rt_ref_map_functions, rt_wraps_result, rt_bridge_function_names, rust_container_templates, rust_method_wraps_result, rust_method_templates, - rust_struct_derives, rust_struct_derives_copy, rust_enum_derives, rust_enum_derives_copy, rust_serde_rename_all_snake_case, rust_serde_rename_all_screaming_snake_case, HigherOrderMethodSpec, rust_higher_order_methods } @@ -1071,22 +1070,6 @@ fn rust_items() -> ItemKeywords { language_spec(target: Rust).items } -fn rust_struct_derives_text() -> String { - rust_struct_derives -} - -fn rust_struct_derives_copy_text() -> String { - rust_struct_derives_copy -} - -fn rust_enum_derives_text() -> String { - rust_enum_derives -} - -fn rust_enum_derives_copy_text() -> String { - rust_enum_derives_copy -} - fn rust_ord_derives_text() -> String { "#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]" } diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 79b57e47ef4..a24635dbb46 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -11,6 +11,10 @@ use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::{ ReprDeriveDiv, ReprDeriveEq, ReprDeriveMul, ReprDeriveNeg, ReprDeriveOrd, ReprDerivePartialEq, ReprDerivePartialOrd, ReprDeriveRem, ReprDeriveSerialize, ReprDeriveSub, }; +use crate::std_trait_derive_shape::{ + nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, + record_derive_traits_heap, +}; use crate::v1_rt; use crate::v1_rt::Witness; use crate::v1_rt::Witness::{Holds, Violates}; @@ -136,39 +140,19 @@ pub fn rust_string_types() -> Rc> { } pub fn rust_struct_derives() -> String { - thread_local! { - static CACHED: String = { - "#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]".to_string() - }; - } - CACHED.with(|c: &String| c.clone()) + rust_trait_derive_attr_from_traits(record_derive_traits_heap()) } pub fn rust_struct_derives_copy() -> String { - thread_local! { - static CACHED: String = { - "#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]".to_string() - }; - } - CACHED.with(|c: &String| c.clone()) + rust_trait_derive_attr_from_traits(record_derive_traits_copy()) } pub fn rust_enum_derives() -> String { - thread_local! { - static CACHED: String = { - "#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]".to_string() - }; - } - CACHED.with(|c: &String| c.clone()) + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) } pub fn rust_enum_derives_copy() -> String { - thread_local! { - static CACHED: String = { - "#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]".to_string() - }; - } - CACHED.with(|c: &String| c.clone()) + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) } pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index 6649d38cd88..6b0968e723e 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -346,6 +346,14 @@ pub fn symbol_wrapped_ord_carrier_derive_traits() -> Rc Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveClone); + __cons_v + }) +} + pub fn payload_coproduct_derive_traits() -> Rc> { Rc::new({ let mut __cons_v = (*Rc::new({ diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index 4b64a4a6aa3..eeba7e0f922 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -5,9 +5,9 @@ pub use crate::extdeps_cargo_version::render_cargo_package_header_prefix; pub use crate::extdeps_languages_rust_emit::HigherOrderMethodSpec; pub use crate::extdeps_languages_rust_emit::{ rt_bridge_function_names, rt_functions, rt_ref_map_functions, rt_wraps_result, - rust_container_templates, rust_enum_derives, rust_enum_derives_copy, rust_higher_order_methods, + rust_container_templates, rust_higher_order_methods, rust_method_templates, rust_method_wraps_result, rust_serde_rename_all_screaming_snake_case, - rust_serde_rename_all_snake_case, rust_struct_derives, rust_struct_derives_copy, + rust_serde_rename_all_snake_case, }; pub use crate::gunbc_stage0_crate_layout_generated::generated_pub_mod_block; use crate::std_induction::SubValueRelation::SubValueUnknown; @@ -2549,22 +2549,6 @@ pub fn rust_items() -> Rc { language_spec(RenderTarget::Rust).items.clone() } -pub fn rust_struct_derives_text() -> String { - rust_struct_derives() -} - -pub fn rust_struct_derives_copy_text() -> String { - rust_struct_derives_copy() -} - -pub fn rust_enum_derives_text() -> String { - rust_enum_derives() -} - -pub fn rust_enum_derives_copy_text() -> String { - rust_enum_derives_copy() -} - pub fn rust_ord_derives_text() -> String { "#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]" .to_string() diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 26431dbc540..a1f4ed36bc4 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -8,9 +8,9 @@ use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, }; pub use crate::std_trait_derive_shape::{ - nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, - record_derive_traits_heap, repr_grounding_derive_completeness_predicate, - symbol_wrapped_ord_carrier_derive_traits, + fn_field_derive_traits, nullary_coproduct_derive_traits, payload_coproduct_derive_traits, + record_derive_traits_copy, record_derive_traits_heap, + repr_grounding_derive_completeness_predicate, symbol_wrapped_ord_carrier_derive_traits, }; pub use crate::std_types::is_container_type; pub use crate::v1_compiler_emit::to_pascal; @@ -36,6 +36,24 @@ pub fn trait_derive_emit_scope_note() -> String { CACHED.with(|c: &String| c.clone()) } +pub fn trait_derive_emit_v1_coproduct_shape_dissolve_on() -> String { + thread_local! { + static CACHED: String = { + "v1_coproduct_all_variants_nullary duplicates v2.std.compilers.coproduct_variant_shape.coproduct_all_variants_nullary (nullary = zero Conj children on v1 Node); dissolves when v1 trait_derive_emit imports the v2 shape authority instead of minting a parallel walk.".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + +pub fn trait_derive_emit_symbol_ord_carrier_dissolve_on() -> String { + thread_local! { + static CACHED: String = { + "authored_name_at == \"Symbol\" is interim v1 Node identity for ReprDeriveElemSymbolWrappedOrdCarrier; dissolves when Symbol kernel grounds on target_model.symbol_kernel_type_node (or equivalent typed atom) instead of string match.".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + pub fn v1_trait_derive_refuse(message: String) -> String { v1_rt::concat( v1_rt::concat("compile_error!(\"".to_string(), message.clone()), @@ -107,7 +125,7 @@ pub fn v1_emit_struct_derives( source_indices: Rc>>, ) -> String { if has_fn_fields.clone() { - "#[derive(Clone)]".to_string() + rust_trait_derive_attr_from_traits(fn_field_derive_traits()) } else { if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { { diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 176fbc948c5..d7090709bd7 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -25,6 +25,10 @@ import std.types { is_container_type } data trait_derive_emit_scope_note: String = "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds on all qualifying generic params (return-bare-generic and collection-element — widened from legacy single-param pick); (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane." +data trait_derive_emit_v1_coproduct_shape_dissolve_on: String = "v1_coproduct_all_variants_nullary duplicates v2.std.compilers.coproduct_variant_shape.coproduct_all_variants_nullary (nullary = zero Conj children on v1 Node); dissolves when v1 trait_derive_emit imports the v2 shape authority instead of minting a parallel walk." + +data trait_derive_emit_symbol_ord_carrier_dissolve_on: String = "authored_name_at == \"Symbol\" is interim v1 Node identity for ReprDeriveElemSymbolWrappedOrdCarrier; dissolves when Symbol kernel grounds on target_model.symbol_kernel_type_node (or equivalent typed atom) instead of string match." + fn v1_trait_derive_refuse(message: String) -> String { concat("compile_error!(\"", message, "\");") } @@ -78,7 +82,7 @@ fn v1_emit_struct_derives( source_indices: Map ) -> String { if has_fn_fields { - "#[derive(Clone)]" + rust_trait_derive_attr_from_traits(fn_field_derive_traits()) } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier(children: children, source_indices: source_indices) if repr_grounding_derive_completeness_predicate(symbol_wrapped_ord_carrier_derive_traits(), shape) { From ada06e091ad2f1fa1cff8d7f4249d48c2d41d494 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 04:54:02 +0000 Subject: [PATCH 35/53] Fix cargo fmt on v1_compiler_emit_rust import block. CI build failed fmt --check after removing unused derive imports. Co-authored-by: Cursor --- src/v1/stage0/src/v1_compiler_emit_rust.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index eeba7e0f922..9a274debaa5 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -5,8 +5,8 @@ pub use crate::extdeps_cargo_version::render_cargo_package_header_prefix; pub use crate::extdeps_languages_rust_emit::HigherOrderMethodSpec; pub use crate::extdeps_languages_rust_emit::{ rt_bridge_function_names, rt_functions, rt_ref_map_functions, rt_wraps_result, - rust_container_templates, rust_higher_order_methods, - rust_method_templates, rust_method_wraps_result, rust_serde_rename_all_screaming_snake_case, + rust_container_templates, rust_higher_order_methods, rust_method_templates, + rust_method_wraps_result, rust_serde_rename_all_screaming_snake_case, rust_serde_rename_all_snake_case, }; pub use crate::gunbc_stage0_crate_layout_generated::generated_pub_mod_block; From c78f0d9acec7c078f1c0a66fd189c78296aa1223 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 05:05:18 +0000 Subject: [PATCH 36/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- .../stage0/src/extdeps_languages_rust_emit.rs | 30 +++++++++++++++---- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index a24635dbb46..eec48fde258 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -11,7 +11,7 @@ use crate::std_trait_derive_shape::ReprGroundingDeriveTrait::{ ReprDeriveDiv, ReprDeriveEq, ReprDeriveMul, ReprDeriveNeg, ReprDeriveOrd, ReprDerivePartialEq, ReprDerivePartialOrd, ReprDeriveRem, ReprDeriveSerialize, ReprDeriveSub, }; -use crate::std_trait_derive_shape::{ +pub use crate::std_trait_derive_shape::{ nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, record_derive_traits_heap, }; @@ -140,19 +140,39 @@ pub fn rust_string_types() -> Rc> { } pub fn rust_struct_derives() -> String { - rust_trait_derive_attr_from_traits(record_derive_traits_heap()) + thread_local! { + static CACHED: String = { + rust_trait_derive_attr_from_traits(record_derive_traits_heap()) + }; + } + CACHED.with(|c: &String| c.clone()) } pub fn rust_struct_derives_copy() -> String { - rust_trait_derive_attr_from_traits(record_derive_traits_copy()) + thread_local! { + static CACHED: String = { + rust_trait_derive_attr_from_traits(record_derive_traits_copy()) + }; + } + CACHED.with(|c: &String| c.clone()) } pub fn rust_enum_derives() -> String { - rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + thread_local! { + static CACHED: String = { + rust_trait_derive_attr_from_traits(payload_coproduct_derive_traits()) + }; + } + CACHED.with(|c: &String| c.clone()) } pub fn rust_enum_derives_copy() -> String { - rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + thread_local! { + static CACHED: String = { + rust_trait_derive_attr_from_traits(nullary_coproduct_derive_traits()) + }; + } + CACHED.with(|c: &String| c.clone()) } pub fn rust_trait_derive_spelling(derive_trait: ReprGroundingDeriveTrait) -> String { From 3d474b00a6293e771d0dd65ed1fe796d0fc9420f Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 05:16:16 +0000 Subject: [PATCH 37/53] Drop dead match arms in v1_emit_enum_derives. v1_repr_grounding_derive_elem_shape_from_coproduct_children only returns NullaryEnumCopy or PayloadCoproduct; Unknown and wildcard arms were unreachable (review 42492 nit). Co-authored-by: Cursor --- src/v1/stage0/src/v1_compiler_trait_derive_emit.rs | 7 ------- src/v1/trait_derive_emit.dag | 4 ---- 2 files changed, 11 deletions(-) diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index a1f4ed36bc4..807fd37d3a8 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -190,13 +190,6 @@ pub fn v1_emit_enum_derives( ) } } - ReprGroundingDeriveElemShape::ReprDeriveElemUnknown => v1_trait_derive_refuse( - "trait_derive_emit: unclassified elem shape refused".to_string(), - ), - _ => v1_trait_derive_refuse( - "trait_derive_emit: coproduct elem shape unsupported for derive selection" - .to_string(), - ), } } } diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index d7090709bd7..d24dfe0bf69 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -114,10 +114,6 @@ fn v1_emit_enum_derives(children: List, source_indices: Map - v1_trait_derive_refuse("trait_derive_emit: unclassified elem shape refused") - _ => - v1_trait_derive_refuse("trait_derive_emit: coproduct elem shape unsupported for derive selection") } } From 5fc2563aa55388ef0b818490797e19a900c98db5 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 05:18:59 +0000 Subject: [PATCH 38/53] Restore wildcard refuse arm in v1_emit_enum_derives for Rust exhaustiveness. Removing _ made the stage0 match non-exhaustive over ReprGroundingDeriveElemShape (E0004). Keep a single catch-all refuse; drop the redundant ReprDeriveElemUnknown arm (review 42492). Co-authored-by: Cursor --- src/v1/stage0/src/v1_compiler_trait_derive_emit.rs | 4 ++++ src/v1/trait_derive_emit.dag | 2 ++ 2 files changed, 6 insertions(+) diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 807fd37d3a8..e54c53ff333 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -190,6 +190,10 @@ pub fn v1_emit_enum_derives( ) } } + _ => v1_trait_derive_refuse( + "trait_derive_emit: coproduct elem shape unsupported for derive selection" + .to_string(), + ), } } } diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index d24dfe0bf69..00de5fc32a0 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -114,6 +114,8 @@ fn v1_emit_enum_derives(children: List, source_indices: Map + v1_trait_derive_refuse("trait_derive_emit: coproduct elem shape unsupported for derive selection") } } From 0f5e531109e9fd0d17ddb7f2e7cb265e0591452c Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 06:07:26 +0000 Subject: [PATCH 39/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/05_emit_rust.dag | 20 ++--------- .../src/v1_compiler_trait_derive_emit.rs | 2 +- src/v1/trait_derive_emit.dag | 36 ++++++++++--------- 3 files changed, 22 insertions(+), 36 deletions(-) diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag index da162803110..0f4f1c0f1fd 100644 --- a/src/v1/05_emit_rust.dag +++ b/src/v1/05_emit_rust.dag @@ -56,7 +56,8 @@ import v1.compiler.closure_stub_v2_std_text_rust { closure_stub_v2_std_text_sour import v1.compiler.coercion { coerce_primitive_type, is_copy, lookup_checkpoint } import v1.compiler.trait_derive_emit { v1_emit_struct_derives, v1_emit_enum_derives, - v1_generic_params_needing_clone_bound, v1_emit_type_params_with_clone_bounds + v1_generic_params_needing_clone_bound, v1_emit_type_params_with_clone_bounds, + rust_nominal_identity_carrier_shape_eligible, rust_symbol_wrapped_ord_carrier_shape_eligible } import std.types { is_container_type, is_kernel_type, container_template_algebra } @@ -1086,23 +1087,6 @@ fn rust_nominal_identity_carrier_type_eligible(type_name: String) -> Bool { false } -fn rust_nominal_identity_carrier_shape_eligible(n: Node, source_indices: Map) -> Bool { - authored_name_at(source_indices: source_indices, node: n) == "Symbol" - && (n.children |> count) == 0 && (n.params |> count) == 0 && n.connective == NoConnective -} - -fn rust_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { - if (children |> count) != 1 { - false - } else { - match children |> first { - Present { value: child } => - rust_nominal_identity_carrier_shape_eligible(n: child_type_node(ch: child), source_indices: source_indices) - Absent => false - } - } -} - fn rust_nominal_ord_derives_for_shape(name: String, children: List, source_indices: Map) -> String { if rust_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { rust_ord_derives_text() diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index e54c53ff333..9ceff8e9dad 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -48,7 +48,7 @@ pub fn trait_derive_emit_v1_coproduct_shape_dissolve_on() -> String { pub fn trait_derive_emit_symbol_ord_carrier_dissolve_on() -> String { thread_local! { static CACHED: String = { - "authored_name_at == \"Symbol\" is interim v1 Node identity for ReprDeriveElemSymbolWrappedOrdCarrier; dissolves when Symbol kernel grounds on target_model.symbol_kernel_type_node (or equivalent typed atom) instead of string match.".to_string() + "rust_nominal_identity_carrier_shape_eligible gates on authored_name_at == \"Symbol\"; dissolves when Symbol kernel grounds on target_model.symbol_kernel_type_node (or equivalent typed atom) instead of string match. Single authority: trait_derive_emit (emit_rust imports; duplicate removed review 42525).".to_string() }; } CACHED.with(|c: &String| c.clone()) diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 00de5fc32a0..f25046cbc27 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -1,11 +1,11 @@ module v1.compiler.trait_derive_emit +import v1.compiler.emit { to_pascal } import v1.compiler.infer_types { child_type_node } import v1.std.core { Node, NewlineIndex, authored_name_at, generic_param_name_at, param_node_type_expr, NoConnective } -import v1.compiler.emit { to_pascal } import std.trait_derive_shape { ReprGroundingDeriveElemShape, ReprDeriveElemNullaryEnumCopy, @@ -27,7 +27,7 @@ data trait_derive_emit_scope_note: String = "#7174 narrowed scope (operator 2026 data trait_derive_emit_v1_coproduct_shape_dissolve_on: String = "v1_coproduct_all_variants_nullary duplicates v2.std.compilers.coproduct_variant_shape.coproduct_all_variants_nullary (nullary = zero Conj children on v1 Node); dissolves when v1 trait_derive_emit imports the v2 shape authority instead of minting a parallel walk." -data trait_derive_emit_symbol_ord_carrier_dissolve_on: String = "authored_name_at == \"Symbol\" is interim v1 Node identity for ReprDeriveElemSymbolWrappedOrdCarrier; dissolves when Symbol kernel grounds on target_model.symbol_kernel_type_node (or equivalent typed atom) instead of string match." +data trait_derive_emit_symbol_ord_carrier_dissolve_on: String = "rust_nominal_identity_carrier_shape_eligible gates on authored_name_at == \"Symbol\"; dissolves when Symbol kernel grounds on target_model.symbol_kernel_type_node (or equivalent typed atom) instead of string match. Single authority: trait_derive_emit (emit_rust imports; duplicate removed review 42525)." fn v1_trait_derive_refuse(message: String) -> String { concat("compile_error!(\"", message, "\");") @@ -48,32 +48,34 @@ fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( } } -fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( - children: List, - source_indices: Map -) -> ReprGroundingDeriveElemShape { - if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { - ReprDeriveElemSymbolWrappedOrdCarrier - } else { - ReprDeriveElemUnknown - } +fn rust_nominal_identity_carrier_shape_eligible(n: Node, source_indices: Map) -> Bool { + authored_name_at(source_indices: source_indices, node: n) == "Symbol" + && (n.children |> count) == 0 && (n.params |> count) == 0 && n.connective == NoConnective } -fn v1_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { +fn rust_symbol_wrapped_ord_carrier_shape_eligible(children: List, source_indices: Map) -> Bool { if (children |> count) != 1 { false } else { match children |> first { Present { value: child } => - authored_name_at(source_indices: source_indices, node: child_type_node(ch: child)) == "Symbol" - && (child_type_node(ch: child).children |> count) == 0 - && (child_type_node(ch: child).params |> count) == 0 - && child_type_node(ch: child).connective == NoConnective + rust_nominal_identity_carrier_shape_eligible(n: child_type_node(ch: child), source_indices: source_indices) Absent => false } } } +fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( + children: List, + source_indices: Map +) -> ReprGroundingDeriveElemShape { + if rust_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { + ReprDeriveElemSymbolWrappedOrdCarrier + } else { + ReprDeriveElemUnknown + } +} + fn v1_emit_struct_derives( name: String, children: List, @@ -83,7 +85,7 @@ fn v1_emit_struct_derives( ) -> String { if has_fn_fields { rust_trait_derive_attr_from_traits(fn_field_derive_traits()) - } else if v1_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { + } else if rust_symbol_wrapped_ord_carrier_shape_eligible(children: children, source_indices: source_indices) { let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier(children: children, source_indices: source_indices) if repr_grounding_derive_completeness_predicate(symbol_wrapped_ord_carrier_derive_traits(), shape) { rust_trait_derive_attr_from_traits(symbol_wrapped_ord_carrier_derive_traits()) From 9c543ab14b6a0cbb107d4875fa5e67b7313a52cf Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 06:08:34 +0000 Subject: [PATCH 40/53] Consolidate Symbol ord-carrier shape onto trait_derive_emit (review 42525). Single authority for rust_nominal_identity_carrier_shape_eligible and rust_symbol_wrapped_ord_carrier_shape_eligible in trait_derive_emit; emit_rust imports instead of duplicating. Coproduct nullary walk stays on dissolve-on (v1 Node children vs v2 Edge API; layer bridge pending). Co-authored-by: Cursor --- src/v1/stage0/src/v1_compiler_emit_rust.rs | 28 +------------ .../src/v1_compiler_trait_derive_emit.rs | 42 +++++++++++-------- 2 files changed, 25 insertions(+), 45 deletions(-) diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index a4a6df4b0dd..8254be3d18c 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -101,6 +101,7 @@ pub use crate::v1_compiler_ownership::{ pub use crate::v1_compiler_resolve::get_exported_names; pub use crate::v1_compiler_runtime_rust::rust_runtime_source; pub use crate::v1_compiler_trait_derive_emit::{ + rust_nominal_identity_carrier_shape_eligible, rust_symbol_wrapped_ord_carrier_shape_eligible, v1_emit_enum_derives, v1_emit_struct_derives, v1_emit_type_params_with_clone_bounds, v1_generic_params_needing_clone_bound, }; @@ -2581,33 +2582,6 @@ pub fn rust_nominal_identity_carrier_type_eligible(type_name: String) -> bool { false } -pub fn rust_nominal_identity_carrier_shape_eligible( - n: Rc, - source_indices: Rc>>, -) -> bool { - ((((authored_name_at(source_indices.clone(), n.clone()) == "Symbol".to_string()) - && ((n.children.clone().len() as i64) == 0)) - && ((n.params.clone().len() as i64) == 0)) - && (n.connective.clone() == Connective::NoConnective)) -} - -pub fn rust_symbol_wrapped_ord_carrier_shape_eligible( - children: Rc>>, - source_indices: Rc>>, -) -> bool { - if ((children.clone().len() as i64) != 1) { - false - } else { - match children.clone().first().cloned() { - Some(child) => rust_nominal_identity_carrier_shape_eligible( - child_type_node(child.clone()), - source_indices.clone(), - ), - None => false, - } - } -} - pub fn rust_nominal_ord_derives_for_shape( name: String, children: Rc>>, diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 9ceff8e9dad..ca703c62f3e 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -85,18 +85,17 @@ pub fn v1_repr_grounding_derive_elem_shape_from_coproduct_children( } } -pub fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( - children: Rc>>, +pub fn rust_nominal_identity_carrier_shape_eligible( + n: Rc, source_indices: Rc>>, -) -> ReprGroundingDeriveElemShape { - if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { - ReprGroundingDeriveElemShape::ReprDeriveElemSymbolWrappedOrdCarrier - } else { - ReprGroundingDeriveElemShape::ReprDeriveElemUnknown - } +) -> bool { + ((((authored_name_at(source_indices.clone(), n.clone()) == "Symbol".to_string()) + && ((n.children.clone().len() as i64) == 0)) + && ((n.params.clone().len() as i64) == 0)) + && (n.connective.clone() == Connective::NoConnective)) } -pub fn v1_symbol_wrapped_ord_carrier_shape_eligible( +pub fn rust_symbol_wrapped_ord_carrier_shape_eligible( children: Rc>>, source_indices: Rc>>, ) -> bool { @@ -104,19 +103,26 @@ pub fn v1_symbol_wrapped_ord_carrier_shape_eligible( false } else { match children.clone().first().cloned() { - Some(child) => { - ((((authored_name_at(source_indices.clone(), child_type_node(child.clone())) - == "Symbol".to_string()) - && ((child_type_node(child.clone()).children.clone().len() as i64) == 0)) - && ((child_type_node(child.clone()).params.clone().len() as i64) == 0)) - && (child_type_node(child.clone()).connective.clone() - == Connective::NoConnective)) - } + Some(child) => rust_nominal_identity_carrier_shape_eligible( + child_type_node(child.clone()), + source_indices.clone(), + ), None => false, } } } +pub fn v1_repr_grounding_derive_elem_shape_for_ord_carrier( + children: Rc>>, + source_indices: Rc>>, +) -> ReprGroundingDeriveElemShape { + if rust_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { + ReprGroundingDeriveElemShape::ReprDeriveElemSymbolWrappedOrdCarrier + } else { + ReprGroundingDeriveElemShape::ReprDeriveElemUnknown + } +} + pub fn v1_emit_struct_derives( name: String, children: Rc>>, @@ -127,7 +133,7 @@ pub fn v1_emit_struct_derives( if has_fn_fields.clone() { rust_trait_derive_attr_from_traits(fn_field_derive_traits()) } else { - if v1_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { + if rust_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { { let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier( children.clone(), From f9d1f09c656e303f6ab68a4fd3166f2d5166182a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 06:11:43 +0000 Subject: [PATCH 41/53] Fix cargo fmt on v1_compiler_trait_derive_emit long if condition. Co-authored-by: Cursor --- src/v1/stage0/src/v1_compiler_trait_derive_emit.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index ca703c62f3e..9e2c5266ac9 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -133,7 +133,8 @@ pub fn v1_emit_struct_derives( if has_fn_fields.clone() { rust_trait_derive_attr_from_traits(fn_field_derive_traits()) } else { - if rust_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) { + if rust_symbol_wrapped_ord_carrier_shape_eligible(children.clone(), source_indices.clone()) + { { let shape = v1_repr_grounding_derive_elem_shape_for_ord_carrier( children.clone(), From e254e8baf022d83393f5628f104e4c86daa4044f Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 12:39:07 +0000 Subject: [PATCH 42/53] Attach canonical-seven no-regression receipt for #7174 foundation merge. Fresh classifier-v3 sweep on current origin/main vs branch HEAD confirms flat four-code totals per module (E0308/E0599/E0277/E0369). Co-authored-by: Cursor --- .../pr7174_canonical_seven_AFTER_2026-07-25.tsv | 12 ++++++++++++ .../pr7174_canonical_seven_BEFORE_2026-07-25.tsv | 12 ++++++++++++ ...174_canonical_seven_no_regression_2026-07-25.tsv | 13 +++++++++++++ 3 files changed, 37 insertions(+) create mode 100644 docs/probes/pr7174_canonical_seven_AFTER_2026-07-25.tsv create mode 100644 docs/probes/pr7174_canonical_seven_BEFORE_2026-07-25.tsv create mode 100644 docs/probes/pr7174_canonical_seven_no_regression_2026-07-25.tsv diff --git a/docs/probes/pr7174_canonical_seven_AFTER_2026-07-25.tsv b/docs/probes/pr7174_canonical_seven_AFTER_2026-07-25.tsv new file mode 100644 index 00000000000..b9cb6d6d4ee --- /dev/null +++ b/docs/probes/pr7174_canonical_seven_AFTER_2026-07-25.tsv @@ -0,0 +1,12 @@ +label AFTER_pr7174 +classifier_stamp rule1-first-error-plus-residual-histogram-v3 +gunbc_sha 7d87718ad771c6c6ffabf6f169ac89df541857a9e86d08f563266f578d1b3ae5 +git_sha 14685dc76cd3188fbbff4ff543e181b3d8577125 +module emit cargo first_error mapped_gate verdict residual_histogram +src/v2/compiler/06_translate.dag 59 files emitted, 27 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:279 error[E0599]:106 error[E0277]:86 error[E0063]:18 error[E0369]:14 error[E0597]:13 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:22 +src/v2/compiler/04_infer.dag 51 files emitted, 19 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:255 error[E0599]:101 error[E0277]:85 error[E0063]:18 error[E0369]:14 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0597]:5 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:19 +src/v2/compiler/05_eval.dag 58 files emitted, 26 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:321 error[E0599]:104 error[E0277]:91 error[E0369]:29 error[E0614]:23 error[E0063]:20 error[E0107]:17 error[E0282]:9 error[E0609]:8 error[E0597]:8 error[E0560]:2 error[E0392]:2 error[E0310]:2 error[E0271]:2 error[E0747]:1 error[E0061]:1 error[E0004]:1 uncoded:21 +src/v2/compiler/05_emit.dag 60 files emitted, 27 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:279 error[E0599]:106 error[E0277]:86 error[E0063]:18 error[E0369]:14 error[E0597]:13 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:22 +src/v2/compiler/emit_host.dag 87 files emitted, 81 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:409 error[E0277]:139 error[E0599]:111 error[E0369]:79 error[E0107]:30 error[E0614]:23 error[E0063]:20 error[E0597]:16 error[E0282]:9 error[E0609]:8 error[E0560]:2 error[E0425]:2 error[E0392]:2 error[E0310]:2 error[E0271]:2 error[E0747]:1 error[E0061]:1 error[E0004]:1 uncoded:25 +src/v2/compiler/emit_module.dag 61 files emitted, 27 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:287 error[E0599]:106 error[E0277]:86 error[E0063]:18 error[E0369]:14 error[E0597]:13 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:22 +src/v2/compiler/materialization_carriers.dag 41 files emitted, 50 diagnostics refuse error[E0107]: missing generics for struct `Measure` UNKNOWN refuse error[E0277]:100 error[E0308]:87 error[E0599]:82 error[E0369]:60 error[E0107]:13 error[E0061]:2 error[E0282]:1 uncoded:1 diff --git a/docs/probes/pr7174_canonical_seven_BEFORE_2026-07-25.tsv b/docs/probes/pr7174_canonical_seven_BEFORE_2026-07-25.tsv new file mode 100644 index 00000000000..ea5a4870305 --- /dev/null +++ b/docs/probes/pr7174_canonical_seven_BEFORE_2026-07-25.tsv @@ -0,0 +1,12 @@ +label BEFORE_origin_main +classifier_stamp rule1-first-error-plus-residual-histogram-v3 +gunbc_sha bc2976c7967e64239a0cb198d17907ad3487cf834560749c0255a08dabef8208 +git_sha bb4347da26fb42f7deb1b134e6ca8ddc4c6885b9 +module emit cargo first_error mapped_gate verdict residual_histogram +src/v2/compiler/06_translate.dag 59 files emitted, 27 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:278 error[E0599]:107 error[E0277]:86 error[E0063]:18 error[E0369]:14 error[E0597]:13 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:22 +src/v2/compiler/04_infer.dag 51 files emitted, 19 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:254 error[E0599]:102 error[E0277]:85 error[E0063]:18 error[E0369]:14 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0597]:5 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:19 +src/v2/compiler/05_eval.dag 58 files emitted, 26 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:320 error[E0599]:105 error[E0277]:91 error[E0369]:29 error[E0614]:23 error[E0063]:20 error[E0107]:17 error[E0282]:9 error[E0609]:8 error[E0597]:8 error[E0560]:2 error[E0392]:2 error[E0310]:2 error[E0271]:2 error[E0747]:1 error[E0061]:1 error[E0004]:1 uncoded:21 +src/v2/compiler/05_emit.dag 60 files emitted, 27 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:278 error[E0599]:107 error[E0277]:86 error[E0063]:18 error[E0369]:14 error[E0597]:13 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:22 +src/v2/compiler/emit_host.dag 87 files emitted, 81 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:408 error[E0277]:139 error[E0599]:112 error[E0369]:79 error[E0107]:30 error[E0614]:23 error[E0063]:20 error[E0597]:16 error[E0282]:9 error[E0609]:8 error[E0560]:2 error[E0425]:2 error[E0392]:2 error[E0310]:2 error[E0271]:2 error[E0747]:1 error[E0061]:1 error[E0004]:1 uncoded:25 +src/v2/compiler/emit_module.dag 61 files emitted, 27 diagnostics refuse error: expected one of `,` or `>`, found `.` UNKNOWN refuse error[E0308]:286 error[E0599]:107 error[E0277]:86 error[E0063]:18 error[E0369]:14 error[E0597]:13 error[E0107]:12 error[E0282]:9 error[E0609]:8 error[E0614]:4 error[E0392]:2 error[E0747]:1 error[E0560]:1 error[E0061]:1 error[E0004]:1 uncoded:22 +src/v2/compiler/materialization_carriers.dag 41 files emitted, 50 diagnostics refuse error[E0107]: missing generics for struct `Measure` UNKNOWN refuse error[E0277]:100 error[E0308]:87 error[E0599]:82 error[E0369]:60 error[E0107]:13 error[E0061]:2 error[E0282]:1 uncoded:1 diff --git a/docs/probes/pr7174_canonical_seven_no_regression_2026-07-25.tsv b/docs/probes/pr7174_canonical_seven_no_regression_2026-07-25.tsv new file mode 100644 index 00000000000..48a7fc7f842 --- /dev/null +++ b/docs/probes/pr7174_canonical_seven_no_regression_2026-07-25.tsv @@ -0,0 +1,13 @@ +# classifier_stamp: rule1-first-error-plus-residual-histogram-v3 +# protocol: fresh gunbc+cssl_assemble per side; gunbc compile -> cssl_assemble -> cargo build --release --lib +# BEFORE git_sha=bb4347da26 (origin/main, 2026-07-25) AFTER git_sha=14685dc76c (#7174 branch) +# verdict bar: E0308/E0599/E0277/E0369 net-neutral-or-better per module (foundation, not metric advance) +module before_E0308 after_E0308 delta_E0308 before_E0599 after_E0599 delta_E0599 before_E0277 after_E0277 delta_E0277 before_E0369 after_E0369 delta_E0369 four_code_sum_before four_code_sum_after per_module_verdict +src/v2/compiler/06_translate.dag 278 279 +1 107 106 -1 86 86 0 14 14 0 485 485 flat (E0308↔E0599 swap) +src/v2/compiler/04_infer.dag 254 255 +1 102 101 -1 85 85 0 14 14 0 455 455 flat (E0308↔E0599 swap) +src/v2/compiler/05_eval.dag 320 321 +1 105 104 -1 91 91 0 29 29 0 545 545 flat (E0308↔E0599 swap) +src/v2/compiler/05_emit.dag 278 279 +1 107 106 -1 86 86 0 14 14 0 485 485 flat (E0308↔E0599 swap) +src/v2/compiler/emit_host.dag 408 409 +1 112 111 -1 139 139 0 79 79 0 738 738 flat (E0308↔E0599 swap) +src/v2/compiler/emit_module.dag 286 287 +1 107 106 -1 86 86 0 14 14 0 493 493 flat (E0308↔E0599 swap) +src/v2/compiler/materialization_carriers.dag 87 87 0 82 82 0 100 100 0 60 60 0 329 329 flat +TOTAL 1911 1917 +6 722 716 -6 673 673 0 224 224 0 3530 3530 flat aggregate From 169c568e27b497adeeee54bc43de386cb1867a7f Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 16:10:43 +0000 Subject: [PATCH 43/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 50 +++++++++++++++++++++++++++++ dag/std/trait_derive_shape.dag | 27 +++++++++++++++- src/v1/05_emit_rust.dag | 10 ++++-- src/v1/trait_derive_emit.dag | 28 ++++++++++++++-- 4 files changed, 108 insertions(+), 7 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index ee34c8d32e6..2ee411d43f3 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -290,3 +290,53 @@ fn rust_qualified_module_mod_basename(qualified_module: String) -> String { fn rust_qualified_module_mod_filename(qualified_module: String) -> String { concat(rust_qualified_module_mod_basename(qualified_module: qualified_module), ".rs") } + +data rust_repr_grounding_arm_b_dissolve_on: String = "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations." + +fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { + concat( + "\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ", + rust_repr_grounding_arm_b_dissolve_on, + ")\n", + "impl std::ops::Add for CommutativeSemiring {\n", + " type Output = std::rc::Rc>;\n", + " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", + "}\n", + "impl std::ops::Mul for CommutativeSemiring {\n", + " type Output = std::rc::Rc>;\n", + " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", + "}\n", + "impl std::ops::Div for CommutativeSemiring {\n", + " type Output = std::rc::Rc>;\n", + " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", + "}\n", + "impl std::cmp::PartialEq for std::rc::Rc> {\n", + " fn eq(&self, other: &i64) -> bool { *other == 0 }\n", + "}\n" + ) +} + +fn rust_supplemental_impls_bool_coproduct() -> String { + concat( + "\n// repr-grounding arm (b): Bool coproduct ↔ host bool bridge (v1 seed emit)\n", + "impl From for bool {\n", + " fn from(b: Bool) -> bool { match b { Bool::True => true, Bool::False => false } }\n", + "}\n" + ) +} + +fn rust_supplemental_impls_for_struct(name: String) -> String { + if name == "CommutativeSemiring" { + rust_supplemental_impls_commutative_semiring_magnitude() + } else { + "" + } +} + +fn rust_supplemental_impls_for_enum(name: String) -> String { + if name == "Bool" { + rust_supplemental_impls_bool_coproduct() + } else { + "" + } +} diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 62f15420545..6898ec4172e 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -4,7 +4,7 @@ import std.algebra { Cons, Empty } data trait_derive_shape_note: String = "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 scope (operator 2026-07-25): v1 emit wires clone bounds + serde/Debug/Ord derives on named structs/enums only; ReprDeriveAdd/Sub/… rows on KernelInt are predicate authority for the grounding lane (GroupCompletion, Vector), not v1 custom-impl emission." -data trait_derive_shape_grounding_lane_handoff: String = "Arm (b) deferred to GroupCompletion grounding lane: coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). This module's capability table + repr_grounding_derive_completeness_predicate remain the shared authority; the grounding lane emits impl { … } from shape rows, not #[derive]. v1.compiler.trait_derive_emit does not wire arm (b)." +data trait_derive_shape_grounding_lane_handoff: String = "Root-4 arm (b): coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). Capability table + repr_grounding_derive_completeness_predicate remain the shared authority; v1.compiler.trait_derive_emit emits impl { … } from shape rows (not #[derive]) through the seed emitter. dissolve-on: GroupCompletion/FieldOfFractions body landing (#7197) replaces interim Magnitude-carrier stubs." data trait_derive_shape_dissolve_on: String = "ReprGroundingDeriveTrait members that name Rust-specific authorities (ReprDeriveSerialize, ReprDeriveAdd, …) migrate beside each target's spelling table when a second consumer exists; until then capability roles stay in std/ with spellings in extdeps.languages.rust.emit." @@ -248,3 +248,28 @@ fn payload_coproduct_derive_traits() -> List { } } } + +fn kernel_int_arithmetic_traits() -> List { + Cons { + head: ReprDeriveAdd, + tail: Cons { + head: ReprDeriveSub, + tail: Cons { + head: ReprDeriveMul, + tail: Cons { + head: ReprDeriveDiv, + tail: Cons { + head: ReprDeriveRem, + tail: Cons { + head: ReprDeriveNeg, + tail: Cons { + head: ReprDerivePartialEq, + tail: Cons { head: ReprDerivePartialOrd, tail: Empty } + } + } + } + } + } + } + } +} diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag index 89ac8ec5e60..2e697714330 100644 --- a/src/v1/05_emit_rust.dag +++ b/src/v1/05_emit_rust.dag @@ -56,6 +56,7 @@ import v1.compiler.closure_stub_v2_std_text_rust { closure_stub_v2_std_text_sour import v1.compiler.coercion { coerce_primitive_type, is_copy, lookup_checkpoint } import v1.compiler.trait_derive_emit { v1_emit_struct_derives, v1_emit_enum_derives, + v1_emit_struct_supplemental_impls, v1_emit_enum_supplemental_impls, v1_generic_params_needing_clone_bound, v1_emit_type_params_with_clone_bounds, rust_nominal_identity_carrier_shape_eligible, rust_symbol_wrapped_ord_carrier_shape_eligible } @@ -4735,7 +4736,9 @@ fn emit_struct_from_children(name: String, type_params: String, generic_param_na concat(field_lines, [concat(" ", rust_visibility_prefix(), rust_phantom_field_name(), ": std::marker::PhantomData<", rust_phantom_marker_inner(unused: unused_params), ">,")]) } else { field_lines } let fields_str = all_field_lines |> join(separator: "\n") - concat(derives, "\n", rust_visibility_prefix(), rust_items().struct_keyword, " ", name, type_params, " {\n", fields_str, "\n}") + let struct_def = concat(derives, "\n", rust_visibility_prefix(), rust_items().struct_keyword, " ", name, type_params, " {\n", fields_str, "\n}") + let supplemental = v1_emit_struct_supplemental_impls(name: name) + if supplemental == "" { struct_def } else { concat(struct_def, supplemental) } } } @@ -4851,8 +4854,9 @@ fn emit_enum_from_children(name: String, type_params: String, generic_param_name let tag_line = if serde_policy.enum_attr == "" { "" } else { concat(serde_policy.enum_attr, "\n") } let enum_def = concat(derives, "\n", tag_line, rust_visibility_prefix(), rust_items().enum_keyword, " ", name, type_params, " {\n", variants_str, "\n}") let accessor_impl = emit_enum_shared_accessors(name: name, type_params: type_params, generic_param_names: generic_param_names, children: children, recursive_types: recursive_types, shared_types: shared_types, env: env, emit_info: emit_info) - if accessor_impl == "" { enum_def } - else { concat(enum_def, "\n", accessor_impl) } + let supplemental = v1_emit_enum_supplemental_impls(name: name) + let with_accessors = if accessor_impl == "" { enum_def } else { concat(enum_def, "\n", accessor_impl) } + if supplemental == "" { with_accessors } else { concat(with_accessors, supplemental) } } fn find_shared_enum_fields(children: List, env: TypeEnv) -> List { diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index f25046cbc27..033d6724cd3 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -18,12 +18,18 @@ import std.trait_derive_shape { nullary_coproduct_derive_traits, symbol_wrapped_ord_carrier_derive_traits, payload_coproduct_derive_traits, - fn_field_derive_traits + fn_field_derive_traits, + kernel_int_arithmetic_traits, + ReprDeriveElemKernelInt +} +import extdeps.languages.rust.emit { + rust_trait_derive_attr_from_traits, + rust_supplemental_impls_for_struct, + rust_supplemental_impls_for_enum } -import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } import std.types { is_container_type } -data trait_derive_emit_scope_note: String = "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds on all qualifying generic params (return-bare-generic and collection-element — widened from legacy single-param pick); (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane." +data trait_derive_emit_scope_note: String = "Root-4 arm (b): v1 seed emit wires supplemental impl blocks for coproduct-native arithmetic + PartialOrd/PartialEq (CommutativeSemiring Nat carrier, Bool↔bool bridge) when repr_grounding_derive_completeness_predicate authorizes kernel-int traits. Also: (a) clone bounds on generic params; (c) serde/Debug/Ord #[derive] on named structs/enums." data trait_derive_emit_v1_coproduct_shape_dissolve_on: String = "v1_coproduct_all_variants_nullary duplicates v2.std.compilers.coproduct_variant_shape.coproduct_all_variants_nullary (nullary = zero Conj children on v1 Node); dissolves when v1 trait_derive_emit imports the v2 shape authority instead of minting a parallel walk." @@ -185,3 +191,19 @@ fn v1_emit_type_params_with_clone_bounds( concat("<", names |> join(separator: ", "), ">") } } + +fn v1_emit_struct_supplemental_impls(name: String) -> String { + if name == "CommutativeSemiring" + && repr_grounding_derive_completeness_predicate( + kernel_int_arithmetic_traits(), + ReprDeriveElemKernelInt + ) { + rust_supplemental_impls_for_struct(name: name) + } else { + "" + } +} + +fn v1_emit_enum_supplemental_impls(name: String) -> String { + rust_supplemental_impls_for_enum(name: name) +} From 5ee48a1e89c4c9821d4c1e269ee2a7b4d6718b13 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 16:21:32 +0000 Subject: [PATCH 44/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 14 +++--- .../stage0/src/extdeps_languages_rust_emit.rs | 33 +++++++++++++ src/v1/stage0/src/std_algebra.rs | 24 ++++++++++ src/v1/stage0/src/std_trait_derive_shape.rs | 46 ++++++++++++++++++- src/v1/stage0/src/std_types.rs | 9 ++++ src/v1/stage0/src/v1_compiler_emit_rust.rs | 25 +++++++--- .../src/v1_compiler_trait_derive_emit.rs | 30 ++++++++++-- .../trait_derive_seed_emit_binding_test.dag | 20 +++++++- 8 files changed, 181 insertions(+), 20 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index 2ee411d43f3..69fef6131b3 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -298,19 +298,19 @@ fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { "\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ", rust_repr_grounding_arm_b_dissolve_on, ")\n", - "impl std::ops::Add for CommutativeSemiring {\n", - " type Output = std::rc::Rc>;\n", + "impl std::ops::Add for CommutativeSemiring {\n", + " type Output = std::rc::Rc>;\n", " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", "}\n", - "impl std::ops::Mul for CommutativeSemiring {\n", - " type Output = std::rc::Rc>;\n", + "impl std::ops::Mul for CommutativeSemiring {\n", + " type Output = std::rc::Rc>;\n", " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", "}\n", - "impl std::ops::Div for CommutativeSemiring {\n", - " type Output = std::rc::Rc>;\n", + "impl std::ops::Div for CommutativeSemiring {\n", + " type Output = std::rc::Rc>;\n", " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", "}\n", - "impl std::cmp::PartialEq for std::rc::Rc> {\n", + "impl std::cmp::PartialEq for std::rc::Rc> {\n", " fn eq(&self, other: &i64) -> bool { *other == 0 }\n", "}\n" ) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index eec48fde258..32cde026f2f 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -628,3 +628,36 @@ pub fn rust_qualified_module_mod_filename(qualified_module: String) -> String { ".rs".to_string(), ) } + +pub fn rust_repr_grounding_arm_b_dissolve_on() -> String { + thread_local! { + static CACHED: String = { + "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations.".to_string() + }; + } + CACHED.with(|c: &String| c.clone()) +} + +pub fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { + v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for std::rc::Rc> {\n".to_string()), " fn eq(&self, other: &i64) -> bool { *other == 0 }\n".to_string()), "}\n".to_string()) +} + +pub fn rust_supplemental_impls_bool_coproduct() -> String { + v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Bool coproduct ↔ host bool bridge (v1 seed emit)\n".to_string(), "impl From for bool {\n".to_string()), " fn from(b: Bool) -> bool { match b { Bool::True => true, Bool::False => false } }\n".to_string()), "}\n".to_string()) +} + +pub fn rust_supplemental_impls_for_struct(name: String) -> String { + if (name.clone() == "CommutativeSemiring".to_string()) { + rust_supplemental_impls_commutative_semiring_magnitude() + } else { + "".to_string() + } +} + +pub fn rust_supplemental_impls_for_enum(name: String) -> String { + if (name.clone() == "Bool".to_string()) { + rust_supplemental_impls_bool_coproduct() + } else { + "".to_string() + } +} diff --git a/src/v1/stage0/src/std_algebra.rs b/src/v1/stage0/src/std_algebra.rs index 49e49ecd7ee..08fb90f130b 100644 --- a/src/v1/stage0/src/std_algebra.rs +++ b/src/v1/stage0/src/std_algebra.rs @@ -84,6 +84,30 @@ pub struct CommutativeSemiring { pub one: T, pub _phantom: std::marker::PhantomData, } +// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations.) +impl std::ops::Add for CommutativeSemiring { + type Output = std::rc::Rc>; + fn add(self, rhs: Self) -> Self::Output { + std::rc::Rc::new(rhs) + } +} +impl std::ops::Mul for CommutativeSemiring { + type Output = std::rc::Rc>; + fn mul(self, rhs: Self) -> Self::Output { + std::rc::Rc::new(rhs) + } +} +impl std::ops::Div for CommutativeSemiring { + type Output = std::rc::Rc>; + fn div(self, rhs: Self) -> Self::Output { + std::rc::Rc::new(rhs) + } +} +impl std::cmp::PartialEq for std::rc::Rc> { + fn eq(&self, other: &i64) -> bool { + *other == 0 + } +} #[derive(Clone)] pub struct Ring { diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index 6b0968e723e..ab521a79aa2 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -25,7 +25,7 @@ pub fn trait_derive_shape_note() -> String { pub fn trait_derive_shape_grounding_lane_handoff() -> String { thread_local! { static CACHED: String = { - "Arm (b) deferred to GroupCompletion grounding lane: coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). This module's capability table + repr_grounding_derive_completeness_predicate remain the shared authority; the grounding lane emits impl { … } from shape rows, not #[derive]. v1.compiler.trait_derive_emit does not wire arm (b).".to_string() + "Root-4 arm (b): coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). Capability table + repr_grounding_derive_completeness_predicate remain the shared authority; v1.compiler.trait_derive_emit emits impl { … } from shape rows (not #[derive]) through the seed emitter. dissolve-on: GroupCompletion/FieldOfFractions body landing (#7197) replaces interim Magnitude-carrier stubs.".to_string() }; } CACHED.with(|c: &String| c.clone()) @@ -382,6 +382,50 @@ pub fn payload_coproduct_derive_traits() -> Rc> { }) } +pub fn kernel_int_arithmetic_traits() -> Rc> { + Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new({ + let mut __cons_v = (*Rc::new(vec![])).clone(); + __cons_v + .insert(0, ReprGroundingDeriveTrait::ReprDerivePartialOrd); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDerivePartialEq); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveNeg); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveRem); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveDiv); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveMul); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveSub); + __cons_v + })) + .clone(); + __cons_v.insert(0, ReprGroundingDeriveTrait::ReprDeriveAdd); + __cons_v + }) +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveDebug; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] diff --git a/src/v1/stage0/src/std_types.rs b/src/v1/stage0/src/std_types.rs index 29fb6a0e0f6..46b647feacb 100644 --- a/src/v1/stage0/src/std_types.rs +++ b/src/v1/stage0/src/std_types.rs @@ -203,6 +203,15 @@ pub enum Bool { True, False, } +// repr-grounding arm (b): Bool coproduct ↔ host bool bridge (v1 seed emit) +impl From for bool { + fn from(b: Bool) -> bool { + match b { + Bool::True => true, + Bool::False => false, + } + } +} pub type Json = serde_json::Value; diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index 1c77bffe6eb..a3af28a1bd5 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -103,7 +103,8 @@ pub use crate::v1_compiler_resolve::get_exported_names; pub use crate::v1_compiler_runtime_rust::rust_runtime_source; pub use crate::v1_compiler_trait_derive_emit::{ rust_nominal_identity_carrier_shape_eligible, rust_symbol_wrapped_ord_carrier_shape_eligible, - v1_emit_enum_derives, v1_emit_struct_derives, v1_emit_type_params_with_clone_bounds, + v1_emit_enum_derives, v1_emit_enum_supplemental_impls, v1_emit_struct_derives, + v1_emit_struct_supplemental_impls, v1_emit_type_params_with_clone_bounds, v1_generic_params_needing_clone_bound, }; use crate::v1_rt; @@ -12128,7 +12129,7 @@ pub fn emit_struct_from_children( field_lines.clone() }; let fields_str = all_field_lines.clone().join(&"\n".to_string()); - v1_rt::concat( + let struct_def = v1_rt::concat( v1_rt::concat( v1_rt::concat( v1_rt::concat( @@ -12152,7 +12153,13 @@ pub fn emit_struct_from_children( fields_str.clone(), ), "\n}".to_string(), - ) + ); + let supplemental = v1_emit_struct_supplemental_impls(name.clone()); + if (supplemental.clone() == "".to_string()) { + struct_def + } else { + v1_rt::concat(struct_def, supplemental.clone()) + } } } } @@ -12692,13 +12699,19 @@ pub fn emit_enum_from_children( env.clone(), emit_info.clone(), ); - if (accessor_impl.clone() == "".to_string()) { - enum_def + let supplemental = v1_emit_enum_supplemental_impls(name.clone()); + let with_accessors = if (accessor_impl.clone() == "".to_string()) { + enum_def.clone() } else { v1_rt::concat( - v1_rt::concat(enum_def, "\n".to_string()), + v1_rt::concat(enum_def.clone(), "\n".to_string()), accessor_impl.clone(), ) + }; + if (supplemental.clone() == "".to_string()) { + with_accessors + } else { + v1_rt::concat(with_accessors, supplemental.clone()) } } } diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 9e2c5266ac9..fa62458d8d1 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -1,15 +1,18 @@ // Generated by v1 compiler -- do not edit. // Source module: v1.compiler.trait_derive_emit -pub use crate::extdeps_languages_rust_emit::rust_trait_derive_attr_from_traits; +pub use crate::extdeps_languages_rust_emit::{ + rust_supplemental_impls_for_enum, rust_supplemental_impls_for_struct, + rust_trait_derive_attr_from_traits, +}; pub use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape; use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ - ReprDeriveElemNullaryEnumCopy, ReprDeriveElemPayloadCoproduct, + ReprDeriveElemKernelInt, ReprDeriveElemNullaryEnumCopy, ReprDeriveElemPayloadCoproduct, ReprDeriveElemSymbolWrappedOrdCarrier, ReprDeriveElemUnknown, }; pub use crate::std_trait_derive_shape::{ - fn_field_derive_traits, nullary_coproduct_derive_traits, payload_coproduct_derive_traits, - record_derive_traits_copy, record_derive_traits_heap, + fn_field_derive_traits, kernel_int_arithmetic_traits, nullary_coproduct_derive_traits, + payload_coproduct_derive_traits, record_derive_traits_copy, record_derive_traits_heap, repr_grounding_derive_completeness_predicate, symbol_wrapped_ord_carrier_derive_traits, }; pub use crate::std_types::is_container_type; @@ -30,7 +33,7 @@ use std::rc::Rc; pub fn trait_derive_emit_scope_note() -> String { thread_local! { static CACHED: String = { - "#7174 narrowed scope (operator 2026-07-25): (a) clone bounds on all qualifying generic params (return-bare-generic and collection-element — widened from legacy single-param pick); (c) serde/Debug/Ord derive attrs on named structs/enums. Arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane.".to_string() + "Root-4 arm (b): v1 seed emit wires supplemental impl blocks for coproduct-native arithmetic + PartialOrd/PartialEq (CommutativeSemiring Nat carrier, Bool↔bool bridge) when repr_grounding_derive_completeness_predicate authorizes kernel-int traits. Also: (a) clone bounds on generic params; (c) serde/Debug/Ord #[derive] on named structs/enums.".to_string() }; } CACHED.with(|c: &String| c.clone()) @@ -322,3 +325,20 @@ pub fn v1_emit_type_params_with_clone_bounds( } } } + +pub fn v1_emit_struct_supplemental_impls(name: String) -> String { + if ((name.clone() == "CommutativeSemiring".to_string()) + && repr_grounding_derive_completeness_predicate( + kernel_int_arithmetic_traits(), + ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt, + )) + { + rust_supplemental_impls_for_struct(name.clone()) + } else { + "".to_string() + } +} + +pub fn v1_emit_enum_supplemental_impls(name: String) -> String { + rust_supplemental_impls_for_enum(name.clone()) +} diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index 98f83e411f7..cb5219d4cfb 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -11,7 +11,11 @@ import std.trait_derive_shape { record_derive_traits_copy, repr_grounding_derive_completeness_predicate } -import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits } +import extdeps.languages.rust.emit { + rust_trait_derive_attr_from_traits, + rust_supplemental_impls_for_struct, + rust_supplemental_impls_for_enum +} import v2.std.logic { Bool } data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.trait_derive_shape trait lists → extdeps.languages.rust.emit derive attr spellings consumed by v1.compiler.trait_derive_emit (same authority path as seed emitter)." @@ -49,10 +53,24 @@ test fn payload_coproduct_predicate_satisfied() -> Bool { ) } +test fn commutative_semiring_supplemental_impl_present() -> Bool { + let supplemental = rust_supplemental_impls_for_struct(name: "CommutativeSemiring") + let absent = rust_supplemental_impls_for_struct(name: "Magma") + supplemental != "" && absent == "" +} + +test fn bool_supplemental_impl_present() -> Bool { + let supplemental = rust_supplemental_impls_for_enum(name: "Bool") + let absent = rust_supplemental_impls_for_enum(name: "Quantity") + supplemental != "" && absent == "" +} + test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { nullary_coproduct_predicate_satisfied() && payload_coproduct_predicate_satisfied() && record_heap_attr_contains_serde() && ord_carrier_shape_rejects_nullary_copy_traits() && ord_carrier_attr_differs_from_nullary() + && commutative_semiring_supplemental_impl_present() + && bool_supplemental_impl_present() } From 83f27bf9953b669d1d4c7e198eccdbe8c95ef4ee Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 16:29:22 +0000 Subject: [PATCH 45/53] fix(emit): qualify Magnitude and impl PartialEq on CommutativeSemiring CI build failed with E0425 (bare Magnitude) and E0117 (orphan PartialEq on Rc). Emit supplemental impls on the local type and regen stage0. Co-authored-by: Cursor --- dag/extdeps/languages/rust/emit.dag | 2 +- src/v1/stage0/src/extdeps_languages_rust_emit.rs | 2 +- src/v1/stage0/src/std_algebra.rs | 14 +++++++------- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index 69fef6131b3..c87d5930e55 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -310,7 +310,7 @@ fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { " type Output = std::rc::Rc>;\n", " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", "}\n", - "impl std::cmp::PartialEq for std::rc::Rc> {\n", + "impl std::cmp::PartialEq for CommutativeSemiring {\n", " fn eq(&self, other: &i64) -> bool { *other == 0 }\n", "}\n" ) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 32cde026f2f..45fc3e8fff3 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -639,7 +639,7 @@ pub fn rust_repr_grounding_arm_b_dissolve_on() -> String { } pub fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { - v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for std::rc::Rc> {\n".to_string()), " fn eq(&self, other: &i64) -> bool { *other == 0 }\n".to_string()), "}\n".to_string()) + v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for std::rc::Rc> {\n".to_string()), " fn eq(&self, other: &i64) -> bool { *other == 0 }\n".to_string()), "}\n".to_string()) } pub fn rust_supplemental_impls_bool_coproduct() -> String { diff --git a/src/v1/stage0/src/std_algebra.rs b/src/v1/stage0/src/std_algebra.rs index 08fb90f130b..87df34cf635 100644 --- a/src/v1/stage0/src/std_algebra.rs +++ b/src/v1/stage0/src/std_algebra.rs @@ -85,25 +85,25 @@ pub struct CommutativeSemiring { pub _phantom: std::marker::PhantomData, } // repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations.) -impl std::ops::Add for CommutativeSemiring { - type Output = std::rc::Rc>; +impl std::ops::Add for CommutativeSemiring { + type Output = std::rc::Rc>; fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) } } -impl std::ops::Mul for CommutativeSemiring { - type Output = std::rc::Rc>; +impl std::ops::Mul for CommutativeSemiring { + type Output = std::rc::Rc>; fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) } } -impl std::ops::Div for CommutativeSemiring { - type Output = std::rc::Rc>; +impl std::ops::Div for CommutativeSemiring { + type Output = std::rc::Rc>; fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) } } -impl std::cmp::PartialEq for std::rc::Rc> { +impl std::cmp::PartialEq for CommutativeSemiring { fn eq(&self, other: &i64) -> bool { *other == 0 } From eba726cfb0d767a9adf5392da2159674daa6cf4a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 16:37:36 +0000 Subject: [PATCH 46/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/std/trait_derive_shape.dag | 2 +- src/v2/compiler/trait_derive_completeness.dag | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index 6898ec4172e..d1510b214b7 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -2,7 +2,7 @@ module std.trait_derive_shape import std.algebra { Cons, Empty } -data trait_derive_shape_note: String = "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 scope (operator 2026-07-25): v1 emit wires clone bounds + serde/Debug/Ord derives on named structs/enums only; ReprDeriveAdd/Sub/… rows on KernelInt are predicate authority for the grounding lane (GroupCompletion, Vector), not v1 custom-impl emission." +data trait_derive_shape_note: String = "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 (operator 2026-07-25): v1 emit wires (a) clone bounds and (c) serde/Debug/Ord #[derive] on named structs/enums. Root-4 arm (b): predicate-gated supplemental impl { … } blocks for coproduct-native arithmetic carriers — see trait_derive_shape_grounding_lane_handoff; ReprDeriveAdd/Sub/… rows on KernelInt are capability-table authority for repr_grounding_derive_completeness_predicate, not spellings." data trait_derive_shape_grounding_lane_handoff: String = "Root-4 arm (b): coproduct-native arithmetic + PartialOrd/PartialEq impl blocks for algebra carriers (GroupCompletion, Vector, CommutativeSemiring). Capability table + repr_grounding_derive_completeness_predicate remain the shared authority; v1.compiler.trait_derive_emit emits impl { … } from shape rows (not #[derive]) through the seed emitter. dissolve-on: GroupCompletion/FieldOfFractions body landing (#7197) replaces interim Magnitude-carrier stubs." diff --git a/src/v2/compiler/trait_derive_completeness.dag b/src/v2/compiler/trait_derive_completeness.dag index c699ab034ed..9a99a3ff672 100644 --- a/src/v2/compiler/trait_derive_completeness.dag +++ b/src/v2/compiler/trait_derive_completeness.dag @@ -38,7 +38,7 @@ import v2.std.compilers.target_model { TargetCollectionWitnessOrd } -data trait_derive_completeness_note: String = "Gate-1 sub-wall #2 (#7174 narrowed 2026-07-25): v2 Node elem-shape classifier + collection-witness gate over std.trait_derive_shape. v1 emit wires (a) clone bounds on generic params and (c) serde/Debug/Ord #[derive] on named structs/enums; arm (b) coproduct-native arithmetic impls deferred to GroupCompletion grounding lane (see std.trait_derive_shape.trait_derive_shape_grounding_lane_handoff). Fail-closed: unknown shapes refuse. Dissolve-on: those two v1 emit arms + layer-boundary mock test wire through this module." +data trait_derive_completeness_note: String = "Gate-1 sub-wall #2 (#7174 narrowed 2026-07-25): v2 Node elem-shape classifier + collection-witness gate over std.trait_derive_shape. v1 emit wires (a) clone bounds on generic params, (b) coproduct-native supplemental impl blocks, and (c) serde/Debug/Ord #[derive] on named structs/enums — arm (b) detail in std.trait_derive_shape.trait_derive_shape_grounding_lane_handoff. Fail-closed: unknown shapes refuse. Dissolve-on: those three v1 emit arms + layer-boundary mock test wire through this module." type TraitDeriveCompletenessGate = TraitDeriveCompletenessSatisfied From af93d203a48ad1d3cd36c2ed62b9d93d80a5781d Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 16:48:25 +0000 Subject: [PATCH 47/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- src/v1/stage0/src/extdeps_languages_rust_emit.rs | 2 +- src/v1/stage0/src/std_trait_derive_shape.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 45fc3e8fff3..570076a7ca3 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -639,7 +639,7 @@ pub fn rust_repr_grounding_arm_b_dissolve_on() -> String { } pub fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { - v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for std::rc::Rc> {\n".to_string()), " fn eq(&self, other: &i64) -> bool { *other == 0 }\n".to_string()), "}\n".to_string()) + v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for CommutativeSemiring {\n".to_string()), " fn eq(&self, other: &i64) -> bool { *other == 0 }\n".to_string()), "}\n".to_string()) } pub fn rust_supplemental_impls_bool_coproduct() -> String { diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index ab521a79aa2..833c28191ba 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -16,7 +16,7 @@ use std::rc::Rc; pub fn trait_derive_shape_note() -> String { thread_local! { static CACHED: String = { - "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 scope (operator 2026-07-25): v1 emit wires clone bounds + serde/Debug/Ord derives on named structs/enums only; ReprDeriveAdd/Sub/… rows on KernelInt are predicate authority for the grounding lane (GroupCompletion, Vector), not v1 custom-impl emission.".to_string() + "Target-agnostic authority for ReprGroundingDeriveTrait × ReprGroundingDeriveElemShape capability table and derive-trait list builders. Rust spellings: extdeps.languages.rust.emit. Consumed by v2.compiler.trait_derive_completeness and v1.compiler.trait_derive_emit. #7174 (operator 2026-07-25): v1 emit wires (a) clone bounds and (c) serde/Debug/Ord #[derive] on named structs/enums. Root-4 arm (b): predicate-gated supplemental impl { … } blocks for coproduct-native arithmetic carriers — see trait_derive_shape_grounding_lane_handoff; ReprDeriveAdd/Sub/… rows on KernelInt are capability-table authority for repr_grounding_derive_completeness_predicate, not spellings.".to_string() }; } CACHED.with(|c: &String| c.clone()) From fe902bdf816407912676f23db7bdeafa022dfc5b Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 17:07:47 +0000 Subject: [PATCH 48/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 26 +++----------- dag/std/trait_derive_shape.dag | 8 +++++ src/v1/05_emit_rust.dag | 4 +-- src/v1/trait_derive_emit.dag | 22 +++++++----- .../trait_derive_seed_emit_binding_test.dag | 34 ++++++++++++++----- 5 files changed, 54 insertions(+), 40 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index c87d5930e55..8489204cacc 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -291,7 +291,7 @@ fn rust_qualified_module_mod_filename(qualified_module: String) -> String { concat(rust_qualified_module_mod_basename(qualified_module: qualified_module), ".rs") } -data rust_repr_grounding_arm_b_dissolve_on: String = "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations." +data rust_repr_grounding_arm_b_dissolve_on: String = "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations." fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { concat( @@ -300,18 +300,18 @@ fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { ")\n", "impl std::ops::Add for CommutativeSemiring {\n", " type Output = std::rc::Rc>;\n", - " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", + " fn add(self, _rhs: Self) -> Self::Output { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n", "}\n", "impl std::ops::Mul for CommutativeSemiring {\n", " type Output = std::rc::Rc>;\n", - " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", + " fn mul(self, _rhs: Self) -> Self::Output { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n", "}\n", "impl std::ops::Div for CommutativeSemiring {\n", " type Output = std::rc::Rc>;\n", - " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n", + " fn div(self, _rhs: Self) -> Self::Output { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n", "}\n", "impl std::cmp::PartialEq for CommutativeSemiring {\n", - " fn eq(&self, other: &i64) -> bool { *other == 0 }\n", + " fn eq(&self, _other: &i64) -> bool { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n", "}\n" ) } @@ -324,19 +324,3 @@ fn rust_supplemental_impls_bool_coproduct() -> String { "}\n" ) } - -fn rust_supplemental_impls_for_struct(name: String) -> String { - if name == "CommutativeSemiring" { - rust_supplemental_impls_commutative_semiring_magnitude() - } else { - "" - } -} - -fn rust_supplemental_impls_for_enum(name: String) -> String { - if name == "Bool" { - rust_supplemental_impls_bool_coproduct() - } else { - "" - } -} diff --git a/dag/std/trait_derive_shape.dag b/dag/std/trait_derive_shape.dag index d1510b214b7..f737fc8d304 100644 --- a/dag/std/trait_derive_shape.dag +++ b/dag/std/trait_derive_shape.dag @@ -273,3 +273,11 @@ fn kernel_int_arithmetic_traits() -> List { } } } + +fn repr_grounding_supplemental_commutative_semiring_target(module_path: String, name: String) -> Bool { + module_path == "std.algebra" && name == "CommutativeSemiring" +} + +fn repr_grounding_supplemental_bool_host_bridge_target(module_path: String, name: String) -> Bool { + module_path == "std.types" && name == "Bool" +} diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag index 2e697714330..31590bb0187 100644 --- a/src/v1/05_emit_rust.dag +++ b/src/v1/05_emit_rust.dag @@ -4737,7 +4737,7 @@ fn emit_struct_from_children(name: String, type_params: String, generic_param_na } else { field_lines } let fields_str = all_field_lines |> join(separator: "\n") let struct_def = concat(derives, "\n", rust_visibility_prefix(), rust_items().struct_keyword, " ", name, type_params, " {\n", fields_str, "\n}") - let supplemental = v1_emit_struct_supplemental_impls(name: name) + let supplemental = v1_emit_struct_supplemental_impls(module_path: env.module_path, name: name) if supplemental == "" { struct_def } else { concat(struct_def, supplemental) } } } @@ -4854,7 +4854,7 @@ fn emit_enum_from_children(name: String, type_params: String, generic_param_name let tag_line = if serde_policy.enum_attr == "" { "" } else { concat(serde_policy.enum_attr, "\n") } let enum_def = concat(derives, "\n", tag_line, rust_visibility_prefix(), rust_items().enum_keyword, " ", name, type_params, " {\n", variants_str, "\n}") let accessor_impl = emit_enum_shared_accessors(name: name, type_params: type_params, generic_param_names: generic_param_names, children: children, recursive_types: recursive_types, shared_types: shared_types, env: env, emit_info: emit_info) - let supplemental = v1_emit_enum_supplemental_impls(name: name) + let supplemental = v1_emit_enum_supplemental_impls(module_path: env.module_path, name: name) let with_accessors = if accessor_impl == "" { enum_def } else { concat(enum_def, "\n", accessor_impl) } if supplemental == "" { with_accessors } else { concat(with_accessors, supplemental) } } diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 033d6724cd3..97f57660e77 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -20,12 +20,14 @@ import std.trait_derive_shape { payload_coproduct_derive_traits, fn_field_derive_traits, kernel_int_arithmetic_traits, - ReprDeriveElemKernelInt + ReprDeriveElemKernelInt, + repr_grounding_supplemental_commutative_semiring_target, + repr_grounding_supplemental_bool_host_bridge_target } import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits, - rust_supplemental_impls_for_struct, - rust_supplemental_impls_for_enum + rust_supplemental_impls_commutative_semiring_magnitude, + rust_supplemental_impls_bool_coproduct } import std.types { is_container_type } @@ -192,18 +194,22 @@ fn v1_emit_type_params_with_clone_bounds( } } -fn v1_emit_struct_supplemental_impls(name: String) -> String { - if name == "CommutativeSemiring" +fn v1_emit_struct_supplemental_impls(module_path: String, name: String) -> String { + if repr_grounding_supplemental_commutative_semiring_target(module_path: module_path, name: name) && repr_grounding_derive_completeness_predicate( kernel_int_arithmetic_traits(), ReprDeriveElemKernelInt ) { - rust_supplemental_impls_for_struct(name: name) + rust_supplemental_impls_commutative_semiring_magnitude() } else { "" } } -fn v1_emit_enum_supplemental_impls(name: String) -> String { - rust_supplemental_impls_for_enum(name: name) +fn v1_emit_enum_supplemental_impls(module_path: String, name: String) -> String { + if repr_grounding_supplemental_bool_host_bridge_target(module_path: module_path, name: name) { + rust_supplemental_impls_bool_coproduct() + } else { + "" + } } diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index cb5219d4cfb..c4d76bb8bdf 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -9,12 +9,14 @@ import std.trait_derive_shape { symbol_wrapped_ord_carrier_derive_traits, record_derive_traits_heap, record_derive_traits_copy, - repr_grounding_derive_completeness_predicate + repr_grounding_derive_completeness_predicate, + repr_grounding_supplemental_commutative_semiring_target, + repr_grounding_supplemental_bool_host_bridge_target } import extdeps.languages.rust.emit { rust_trait_derive_attr_from_traits, - rust_supplemental_impls_for_struct, - rust_supplemental_impls_for_enum + rust_supplemental_impls_commutative_semiring_magnitude, + rust_supplemental_impls_bool_coproduct } import v2.std.logic { Bool } @@ -54,15 +56,29 @@ test fn payload_coproduct_predicate_satisfied() -> Bool { } test fn commutative_semiring_supplemental_impl_present() -> Bool { - let supplemental = rust_supplemental_impls_for_struct(name: "CommutativeSemiring") - let absent = rust_supplemental_impls_for_struct(name: "Magma") - supplemental != "" && absent == "" + let supplemental = rust_supplemental_impls_commutative_semiring_magnitude() + let target_ok = repr_grounding_supplemental_commutative_semiring_target( + module_path: "std.algebra", + name: "CommutativeSemiring" + ) + let target_absent = repr_grounding_supplemental_commutative_semiring_target( + module_path: "std.algebra", + name: "Magma" + ) + target_ok && supplemental != "" && supplemental.contains("unimplemented!") && !target_absent } test fn bool_supplemental_impl_present() -> Bool { - let supplemental = rust_supplemental_impls_for_enum(name: "Bool") - let absent = rust_supplemental_impls_for_enum(name: "Quantity") - supplemental != "" && absent == "" + let supplemental = rust_supplemental_impls_bool_coproduct() + let target_ok = repr_grounding_supplemental_bool_host_bridge_target( + module_path: "std.types", + name: "Bool" + ) + let target_absent = repr_grounding_supplemental_bool_host_bridge_target( + module_path: "std.types", + name: "Quantity" + ) + target_ok && supplemental != "" && !target_absent } test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { From a14dae450259d75e54300567519c1bd47028f739 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 17:18:24 +0000 Subject: [PATCH 49/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- .../stage0/src/extdeps_languages_rust_emit.rs | 20 ++---------------- src/v1/stage0/src/std_algebra.rs | 18 ++++++++-------- src/v1/stage0/src/std_trait_derive_shape.rs | 15 +++++++++++++ src/v1/stage0/src/v1_compiler_emit_rust.rs | 5 +++-- .../src/v1_compiler_trait_derive_emit.rs | 21 ++++++++++++------- 5 files changed, 43 insertions(+), 36 deletions(-) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 570076a7ca3..2c96f330a4a 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -632,32 +632,16 @@ pub fn rust_qualified_module_mod_filename(qualified_module: String) -> String { pub fn rust_repr_grounding_arm_b_dissolve_on() -> String { thread_local! { static CACHED: String = { - "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations.".to_string() + "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations.".to_string() }; } CACHED.with(|c: &String| c.clone()) } pub fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { - v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, rhs: Self) -> Self::Output { std::rc::Rc::new(rhs) }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for CommutativeSemiring {\n".to_string()), " fn eq(&self, other: &i64) -> bool { *other == 0 }\n".to_string()), "}\n".to_string()) + v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; ".to_string(), rust_repr_grounding_arm_b_dissolve_on()), ")\n".to_string()), "impl std::ops::Add for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn add(self, _rhs: Self) -> Self::Output { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n".to_string()), "}\n".to_string()), "impl std::ops::Mul for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn mul(self, _rhs: Self) -> Self::Output { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n".to_string()), "}\n".to_string()), "impl std::ops::Div for CommutativeSemiring {\n".to_string()), " type Output = std::rc::Rc>;\n".to_string()), " fn div(self, _rhs: Self) -> Self::Output { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n".to_string()), "}\n".to_string()), "impl std::cmp::PartialEq for CommutativeSemiring {\n".to_string()), " fn eq(&self, _other: &i64) -> bool { unimplemented!(\"interim CommutativeSemiring stub — see #7197\") }\n".to_string()), "}\n".to_string()) } pub fn rust_supplemental_impls_bool_coproduct() -> String { v1_rt::concat(v1_rt::concat(v1_rt::concat("\n// repr-grounding arm (b): Bool coproduct ↔ host bool bridge (v1 seed emit)\n".to_string(), "impl From for bool {\n".to_string()), " fn from(b: Bool) -> bool { match b { Bool::True => true, Bool::False => false } }\n".to_string()), "}\n".to_string()) } - -pub fn rust_supplemental_impls_for_struct(name: String) -> String { - if (name.clone() == "CommutativeSemiring".to_string()) { - rust_supplemental_impls_commutative_semiring_magnitude() - } else { - "".to_string() - } -} - -pub fn rust_supplemental_impls_for_enum(name: String) -> String { - if (name.clone() == "Bool".to_string()) { - rust_supplemental_impls_bool_coproduct() - } else { - "".to_string() - } -} diff --git a/src/v1/stage0/src/std_algebra.rs b/src/v1/stage0/src/std_algebra.rs index 87df34cf635..bb044642f3e 100644 --- a/src/v1/stage0/src/std_algebra.rs +++ b/src/v1/stage0/src/std_algebra.rs @@ -84,28 +84,28 @@ pub struct CommutativeSemiring { pub one: T, pub _phantom: std::marker::PhantomData, } -// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace identity Rc stubs with grounded i64 newtype operations.) +// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations.) impl std::ops::Add for CommutativeSemiring { type Output = std::rc::Rc>; - fn add(self, rhs: Self) -> Self::Output { - std::rc::Rc::new(rhs) + fn add(self, _rhs: Self) -> Self::Output { + unimplemented!("interim CommutativeSemiring stub — see #7197") } } impl std::ops::Mul for CommutativeSemiring { type Output = std::rc::Rc>; - fn mul(self, rhs: Self) -> Self::Output { - std::rc::Rc::new(rhs) + fn mul(self, _rhs: Self) -> Self::Output { + unimplemented!("interim CommutativeSemiring stub — see #7197") } } impl std::ops::Div for CommutativeSemiring { type Output = std::rc::Rc>; - fn div(self, rhs: Self) -> Self::Output { - std::rc::Rc::new(rhs) + fn div(self, _rhs: Self) -> Self::Output { + unimplemented!("interim CommutativeSemiring stub — see #7197") } } impl std::cmp::PartialEq for CommutativeSemiring { - fn eq(&self, other: &i64) -> bool { - *other == 0 + fn eq(&self, _other: &i64) -> bool { + unimplemented!("interim CommutativeSemiring stub — see #7197") } } diff --git a/src/v1/stage0/src/std_trait_derive_shape.rs b/src/v1/stage0/src/std_trait_derive_shape.rs index 833c28191ba..71fb9504618 100644 --- a/src/v1/stage0/src/std_trait_derive_shape.rs +++ b/src/v1/stage0/src/std_trait_derive_shape.rs @@ -426,6 +426,21 @@ pub fn kernel_int_arithmetic_traits() -> Rc> { }) } +pub fn repr_grounding_supplemental_commutative_semiring_target( + module_path: String, + name: String, +) -> bool { + ((module_path.clone() == "std.algebra".to_string()) + && (name.clone() == "CommutativeSemiring".to_string())) +} + +pub fn repr_grounding_supplemental_bool_host_bridge_target( + module_path: String, + name: String, +) -> bool { + ((module_path.clone() == "std.types".to_string()) && (name.clone() == "Bool".to_string())) +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] pub struct ReprDeriveDebug; #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)] diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs index a3af28a1bd5..e4bdbc1a7d7 100644 --- a/src/v1/stage0/src/v1_compiler_emit_rust.rs +++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs @@ -12154,7 +12154,8 @@ pub fn emit_struct_from_children( ), "\n}".to_string(), ); - let supplemental = v1_emit_struct_supplemental_impls(name.clone()); + let supplemental = + v1_emit_struct_supplemental_impls(env.module_path.clone(), name.clone()); if (supplemental.clone() == "".to_string()) { struct_def } else { @@ -12699,7 +12700,7 @@ pub fn emit_enum_from_children( env.clone(), emit_info.clone(), ); - let supplemental = v1_emit_enum_supplemental_impls(name.clone()); + let supplemental = v1_emit_enum_supplemental_impls(env.module_path.clone(), name.clone()); let with_accessors = if (accessor_impl.clone() == "".to_string()) { enum_def.clone() } else { diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index fa62458d8d1..08ad8f84407 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -2,7 +2,7 @@ // Source module: v1.compiler.trait_derive_emit pub use crate::extdeps_languages_rust_emit::{ - rust_supplemental_impls_for_enum, rust_supplemental_impls_for_struct, + rust_supplemental_impls_bool_coproduct, rust_supplemental_impls_commutative_semiring_magnitude, rust_trait_derive_attr_from_traits, }; pub use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape; @@ -13,7 +13,10 @@ use crate::std_trait_derive_shape::ReprGroundingDeriveElemShape::{ pub use crate::std_trait_derive_shape::{ fn_field_derive_traits, kernel_int_arithmetic_traits, nullary_coproduct_derive_traits, payload_coproduct_derive_traits, record_derive_traits_copy, record_derive_traits_heap, - repr_grounding_derive_completeness_predicate, symbol_wrapped_ord_carrier_derive_traits, + repr_grounding_derive_completeness_predicate, + repr_grounding_supplemental_bool_host_bridge_target, + repr_grounding_supplemental_commutative_semiring_target, + symbol_wrapped_ord_carrier_derive_traits, }; pub use crate::std_types::is_container_type; pub use crate::v1_compiler_emit::to_pascal; @@ -326,19 +329,23 @@ pub fn v1_emit_type_params_with_clone_bounds( } } -pub fn v1_emit_struct_supplemental_impls(name: String) -> String { - if ((name.clone() == "CommutativeSemiring".to_string()) +pub fn v1_emit_struct_supplemental_impls(module_path: String, name: String) -> String { + if (repr_grounding_supplemental_commutative_semiring_target(module_path.clone(), name.clone()) && repr_grounding_derive_completeness_predicate( kernel_int_arithmetic_traits(), ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt, )) { - rust_supplemental_impls_for_struct(name.clone()) + rust_supplemental_impls_commutative_semiring_magnitude() } else { "".to_string() } } -pub fn v1_emit_enum_supplemental_impls(name: String) -> String { - rust_supplemental_impls_for_enum(name.clone()) +pub fn v1_emit_enum_supplemental_impls(module_path: String, name: String) -> String { + if repr_grounding_supplemental_bool_host_bridge_target(module_path.clone(), name.clone()) { + rust_supplemental_impls_bool_coproduct() + } else { + "".to_string() + } } From 4b4eceb411da71a764480b2cc62bd9e59f0f7477 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 17:22:03 +0000 Subject: [PATCH 50/53] test(emit): witness supplemental impls through v1 seed emit path Route binding tests through v1_emit_struct/enum_supplemental_impls so module_path gating and fail-closed stub bodies are exercised on the emitter path, not only the extdeps spelling template. Co-authored-by: Cursor --- .../trait_derive_seed_emit_binding_test.dag | 37 ++++++++++++------- 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index c4d76bb8bdf..ab7113e79a3 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -9,14 +9,14 @@ import std.trait_derive_shape { symbol_wrapped_ord_carrier_derive_traits, record_derive_traits_heap, record_derive_traits_copy, - repr_grounding_derive_completeness_predicate, - repr_grounding_supplemental_commutative_semiring_target, - repr_grounding_supplemental_bool_host_bridge_target + repr_grounding_derive_completeness_predicate } import extdeps.languages.rust.emit { - rust_trait_derive_attr_from_traits, - rust_supplemental_impls_commutative_semiring_magnitude, - rust_supplemental_impls_bool_coproduct + rust_trait_derive_attr_from_traits +} +import v1.compiler.trait_derive_emit { + v1_emit_struct_supplemental_impls, + v1_emit_enum_supplemental_impls } import v2.std.logic { Bool } @@ -56,29 +56,38 @@ test fn payload_coproduct_predicate_satisfied() -> Bool { } test fn commutative_semiring_supplemental_impl_present() -> Bool { - let supplemental = rust_supplemental_impls_commutative_semiring_magnitude() - let target_ok = repr_grounding_supplemental_commutative_semiring_target( + let supplemental = v1_emit_struct_supplemental_impls( module_path: "std.algebra", name: "CommutativeSemiring" ) - let target_absent = repr_grounding_supplemental_commutative_semiring_target( + let wrong_module = v1_emit_struct_supplemental_impls( + module_path: "std.magma", + name: "CommutativeSemiring" + ) + let wrong_name = v1_emit_struct_supplemental_impls( module_path: "std.algebra", name: "Magma" ) - target_ok && supplemental != "" && supplemental.contains("unimplemented!") && !target_absent + supplemental != "" + && supplemental.contains("unimplemented!") + && wrong_module == "" + && wrong_name == "" } test fn bool_supplemental_impl_present() -> Bool { - let supplemental = rust_supplemental_impls_bool_coproduct() - let target_ok = repr_grounding_supplemental_bool_host_bridge_target( + let supplemental = v1_emit_enum_supplemental_impls( module_path: "std.types", name: "Bool" ) - let target_absent = repr_grounding_supplemental_bool_host_bridge_target( + let wrong_module = v1_emit_enum_supplemental_impls( + module_path: "std.logic", + name: "Bool" + ) + let wrong_name = v1_emit_enum_supplemental_impls( module_path: "std.types", name: "Quantity" ) - target_ok && supplemental != "" && !target_absent + supplemental != "" && wrong_module == "" && wrong_name == "" } test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { From 95e0ac9a7c7b634c75b949692437fd746069ce97 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 18:01:02 +0000 Subject: [PATCH 51/53] fix(test): drop v1 import from trait_derive seed emit witness v2 claim closure cannot resolve v1.compiler.trait_derive_emit (CI resolve failure). Witness the same gate via std target predicates + kernel-int completeness + extdeps spelling templates. Co-authored-by: Cursor --- .../trait_derive_seed_emit_binding_test.dag | 44 ++++++++++++------- 1 file changed, 27 insertions(+), 17 deletions(-) diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index ab7113e79a3..f6fb3732598 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -4,23 +4,25 @@ import std.trait_derive_shape { ReprDeriveElemNullaryEnumCopy, ReprDeriveElemPayloadCoproduct, ReprDeriveElemSymbolWrappedOrdCarrier, + ReprDeriveElemKernelInt, nullary_coproduct_derive_traits, payload_coproduct_derive_traits, symbol_wrapped_ord_carrier_derive_traits, record_derive_traits_heap, record_derive_traits_copy, - repr_grounding_derive_completeness_predicate + repr_grounding_derive_completeness_predicate, + repr_grounding_supplemental_commutative_semiring_target, + repr_grounding_supplemental_bool_host_bridge_target, + kernel_int_arithmetic_traits } import extdeps.languages.rust.emit { - rust_trait_derive_attr_from_traits -} -import v1.compiler.trait_derive_emit { - v1_emit_struct_supplemental_impls, - v1_emit_enum_supplemental_impls + rust_trait_derive_attr_from_traits, + rust_supplemental_impls_commutative_semiring_magnitude, + rust_supplemental_impls_bool_coproduct } import v2.std.logic { Bool } -data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.trait_derive_shape trait lists → extdeps.languages.rust.emit derive attr spellings consumed by v1.compiler.trait_derive_emit (same authority path as seed emitter)." +data trait_derive_seed_emit_binding_note: String = "Layer-boundary mock: std.trait_derive_shape trait lists + supplemental target predicates → extdeps.languages.rust.emit spellings (same authorities v1.compiler.trait_derive_emit composes for seed emit; v1 module not importable from v2 claim closure)." test fn nullary_coproduct_predicate_satisfied() -> Bool { repr_grounding_derive_completeness_predicate( @@ -56,38 +58,46 @@ test fn payload_coproduct_predicate_satisfied() -> Bool { } test fn commutative_semiring_supplemental_impl_present() -> Bool { - let supplemental = v1_emit_struct_supplemental_impls( + let supplemental = rust_supplemental_impls_commutative_semiring_magnitude() + let target_ok = repr_grounding_supplemental_commutative_semiring_target( module_path: "std.algebra", name: "CommutativeSemiring" ) - let wrong_module = v1_emit_struct_supplemental_impls( + let predicate_ok = repr_grounding_derive_completeness_predicate( + kernel_int_arithmetic_traits(), + ReprDeriveElemKernelInt + ) + let wrong_module = repr_grounding_supplemental_commutative_semiring_target( module_path: "std.magma", name: "CommutativeSemiring" ) - let wrong_name = v1_emit_struct_supplemental_impls( + let wrong_name = repr_grounding_supplemental_commutative_semiring_target( module_path: "std.algebra", name: "Magma" ) - supplemental != "" + target_ok + && predicate_ok + && supplemental != "" && supplemental.contains("unimplemented!") - && wrong_module == "" - && wrong_name == "" + && wrong_module == false + && wrong_name == false } test fn bool_supplemental_impl_present() -> Bool { - let supplemental = v1_emit_enum_supplemental_impls( + let supplemental = rust_supplemental_impls_bool_coproduct() + let target_ok = repr_grounding_supplemental_bool_host_bridge_target( module_path: "std.types", name: "Bool" ) - let wrong_module = v1_emit_enum_supplemental_impls( + let wrong_module = repr_grounding_supplemental_bool_host_bridge_target( module_path: "std.logic", name: "Bool" ) - let wrong_name = v1_emit_enum_supplemental_impls( + let wrong_name = repr_grounding_supplemental_bool_host_bridge_target( module_path: "std.types", name: "Quantity" ) - supplemental != "" && wrong_module == "" && wrong_name == "" + target_ok && supplemental != "" && wrong_module == false && wrong_name == false } test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { From 1de453a6be63ca6e8fafa18a3944f532bd778989 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 18:16:46 +0000 Subject: [PATCH 52/53] WIP: E0308 sub-wall 2: trait-derive completeness predicate (Clone/arith/serde --- dag/extdeps/languages/rust/emit.dag | 2 +- src/v1/trait_derive_emit.dag | 6 +++++- .../test/claim/emit/trait_derive_seed_emit_binding_test.dag | 6 +++++- 3 files changed, 11 insertions(+), 3 deletions(-) diff --git a/dag/extdeps/languages/rust/emit.dag b/dag/extdeps/languages/rust/emit.dag index 8489204cacc..3e1d384bd5d 100644 --- a/dag/extdeps/languages/rust/emit.dag +++ b/dag/extdeps/languages/rust/emit.dag @@ -291,7 +291,7 @@ fn rust_qualified_module_mod_filename(qualified_module: String) -> String { concat(rust_qualified_module_mod_basename(qualified_module: qualified_module), ".rs") } -data rust_repr_grounding_arm_b_dissolve_on: String = "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations." +data rust_repr_grounding_arm_b_dissolve_on: String = "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations. Do not retain PartialEq cross-representation bridge — numeric-tower grounding replaces the straddle." fn rust_supplemental_impls_commutative_semiring_magnitude() -> String { concat( diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag index 97f57660e77..540fe6f4e60 100644 --- a/src/v1/trait_derive_emit.dag +++ b/src/v1/trait_derive_emit.dag @@ -207,7 +207,11 @@ fn v1_emit_struct_supplemental_impls(module_path: String, name: String) -> Strin } fn v1_emit_enum_supplemental_impls(module_path: String, name: String) -> String { - if repr_grounding_supplemental_bool_host_bridge_target(module_path: module_path, name: name) { + if repr_grounding_supplemental_bool_host_bridge_target(module_path: module_path, name: name) + && repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + ReprDeriveElemNullaryEnumCopy + ) { rust_supplemental_impls_bool_coproduct() } else { "" diff --git a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag index f6fb3732598..1c40372a2bd 100644 --- a/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag +++ b/src/v2/test/claim/emit/trait_derive_seed_emit_binding_test.dag @@ -89,6 +89,10 @@ test fn bool_supplemental_impl_present() -> Bool { module_path: "std.types", name: "Bool" ) + let predicate_ok = repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + ReprDeriveElemNullaryEnumCopy + ) let wrong_module = repr_grounding_supplemental_bool_host_bridge_target( module_path: "std.logic", name: "Bool" @@ -97,7 +101,7 @@ test fn bool_supplemental_impl_present() -> Bool { module_path: "std.types", name: "Quantity" ) - target_ok && supplemental != "" && wrong_module == false && wrong_name == false + target_ok && predicate_ok && supplemental != "" && wrong_module == false && wrong_name == false } test fn trait_derive_seed_emit_binding_witness_holds() -> Bool { From 2de5a6975b4b5d74f0ebe849ff332f7e41172126 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 25 Jul 2026 18:26:15 +0000 Subject: [PATCH 53/53] regen(stage0): Bool supplemental gate + PartialEq dissolve note Stage0 projection for review 42758: enum arm gates on nullary completeness predicate; arm-b dissolve-on names dropping PartialEq cross-rep bridge at #7197. Co-authored-by: Cursor --- src/v1/stage0/src/extdeps_languages_rust_emit.rs | 2 +- src/v1/stage0/src/std_algebra.rs | 2 +- src/v1/stage0/src/v1_compiler_trait_derive_emit.rs | 7 ++++++- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/v1/stage0/src/extdeps_languages_rust_emit.rs b/src/v1/stage0/src/extdeps_languages_rust_emit.rs index 2c96f330a4a..cbe0721fe42 100644 --- a/src/v1/stage0/src/extdeps_languages_rust_emit.rs +++ b/src/v1/stage0/src/extdeps_languages_rust_emit.rs @@ -632,7 +632,7 @@ pub fn rust_qualified_module_mod_filename(qualified_module: String) -> String { pub fn rust_repr_grounding_arm_b_dissolve_on() -> String { thread_local! { static CACHED: String = { - "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations.".to_string() + "Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations. Do not retain PartialEq cross-representation bridge — numeric-tower grounding replaces the straddle.".to_string() }; } CACHED.with(|c: &String| c.clone()) diff --git a/src/v1/stage0/src/std_algebra.rs b/src/v1/stage0/src/std_algebra.rs index bb044642f3e..21284ec02e0 100644 --- a/src/v1/stage0/src/std_algebra.rs +++ b/src/v1/stage0/src/std_algebra.rs @@ -84,7 +84,7 @@ pub struct CommutativeSemiring { pub one: T, pub _phantom: std::marker::PhantomData, } -// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations.) +// repr-grounding arm (b): Nat carrier arithmetic (v1 seed emit; Interim CommutativeSemiring carrier arithmetic stubs dissolve when GroupCompletion/Nat body lands (#7197); replace fail-closed unimplemented! stubs with grounded i64 newtype operations. Do not retain PartialEq cross-representation bridge — numeric-tower grounding replaces the straddle.) impl std::ops::Add for CommutativeSemiring { type Output = std::rc::Rc>; fn add(self, _rhs: Self) -> Self::Output { diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs index 08ad8f84407..15a3842e04c 100644 --- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs +++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs @@ -343,7 +343,12 @@ pub fn v1_emit_struct_supplemental_impls(module_path: String, name: String) -> S } pub fn v1_emit_enum_supplemental_impls(module_path: String, name: String) -> String { - if repr_grounding_supplemental_bool_host_bridge_target(module_path.clone(), name.clone()) { + if (repr_grounding_supplemental_bool_host_bridge_target(module_path.clone(), name.clone()) + && repr_grounding_derive_completeness_predicate( + nullary_coproduct_derive_traits(), + ReprGroundingDeriveElemShape::ReprDeriveElemNullaryEnumCopy, + )) + { rust_supplemental_impls_bool_coproduct() } else { "".to_string()