From d05ef9b3254fc80d60008af3eac150f963d3dc60 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 07:57:31 -0400 Subject: [PATCH 01/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/lib.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index a3deca9a553..5a2aad8143f 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -51,7 +51,10 @@ pub mod evaluator { use std::collections::HashMap; - use crate::dag::{Behavior, Dag, DeclarationId, LiteralBits, LoopBound, NodeId, PortId}; + use crate::dag::{ + ArithmeticOp, Behavior, ComparisonOp, Dag, DeclarationId, LiteralBits, LoopBound, NodeId, + OperatorKind, PortId, TransformNode, TransformTarget, + }; /// Rust mirror of the substrate runtime `Value` carrier in /// `src/v3/std/runtime.dag`. From 783e93102d35e33774793c84d5aeafb8db5ccfff Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 08:07:27 -0400 Subject: [PATCH 02/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/lib.rs | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index 5a2aad8143f..d4163bf8f9b 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -98,8 +98,9 @@ pub mod evaluator { LeftFirst, } - /// **Dissolution receipt: TERMINAL.** These are the E1 body-evaluator miss - /// modes until later PR-E slices implement the remaining behavior arms. + /// **Dissolution receipt: TERMINAL.** These are the E1/E2 body-evaluator miss + /// modes until later PR-E slices implement the remaining behavior arms, plus + /// E3 transform operand / arity diagnostics. #[derive(Debug, Clone, PartialEq, Eq)] pub enum EvalError { MissingNode { @@ -112,6 +113,16 @@ pub mod evaluator { node: NodeId, behavior: &'static str, }, + TransformArityMismatch { + expected: usize, + got: usize, + }, + UnsupportedTransformTarget { + kind: &'static str, + }, + BadTransformOperands { + reason: &'static str, + }, } pub fn eval_value(value: &crate::dag::ValueNode) -> Value { From 6cb82c4f8b816f3e30de5ed90284a32608991d1a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 08:13:20 -0400 Subject: [PATCH 03/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/lib.rs | 107 ++++++++++++++++++++++++++++++++++++- 1 file changed, 106 insertions(+), 1 deletion(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index d4163bf8f9b..401fe22b3e3 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -150,7 +150,7 @@ pub mod evaluator { pub fn eval_node( dag: &Dag, node: NodeId, - _state: &mut EvalStateStack, + state: &mut EvalStateStack, strategy: &EvalStrategy, ) -> Result { match strategy { @@ -160,6 +160,7 @@ pub mod evaluator { } match dag.node_opt(&node).ok_or(EvalError::MissingNode { node })? { Behavior::Value(value) => Ok(eval_value(value)), + Behavior::Transform(t) => eval_transform_node(dag, t, state, strategy), behavior => Err(EvalError::UnsupportedBehavior { node: behavior.id(), behavior: behavior_label(behavior), @@ -167,6 +168,110 @@ pub mod evaluator { } } + fn eval_transform_node( + dag: &Dag, + t: &TransformNode, + state: &mut EvalStateStack, + strategy: &EvalStrategy, + ) -> Result { + let mut operands = Vec::with_capacity(t.inputs.len()); + for port in &t.inputs { + operands.push(eval_port(dag, *port, state, strategy)?); + } + match &t.target { + TransformTarget::Operator(OperatorKind::Arithmetic(op)) => { + if operands.len() != 2 { + return Err(EvalError::TransformArityMismatch { + expected: 2, + got: operands.len(), + }); + } + let a = expect_int_literal(&operands[0])?; + let b = expect_int_literal(&operands[1])?; + let n = apply_arithmetic_int(*op, a, b)?; + Ok(Value::LiteralValue(LiteralBits::Int(n))) + } + TransformTarget::Operator(OperatorKind::Comparison(op)) => { + if operands.len() != 2 { + return Err(EvalError::TransformArityMismatch { + expected: 2, + got: operands.len(), + }); + } + let out = match (&operands[0], &operands[1]) { + (Value::LiteralValue(LiteralBits::Int(a)), Value::LiteralValue(LiteralBits::Int(b))) => { + match op { + ComparisonOp::Eq => a == b, + ComparisonOp::Ne => a != b, + ComparisonOp::Lt => a < b, + ComparisonOp::Le => a <= b, + ComparisonOp::Gt => a > b, + ComparisonOp::Ge => a >= b, + } + } + ( + Value::LiteralValue(LiteralBits::String(a)), + Value::LiteralValue(LiteralBits::String(b)), + ) => match op { + ComparisonOp::Eq => a == b, + ComparisonOp::Ne => a != b, + _ => { + return Err(EvalError::BadTransformOperands { + reason: "string comparison beyond Eq/Ne", + }); + } + }, + _ => { + return Err(EvalError::BadTransformOperands { + reason: + "comparison operands must both be Int literals or both String literals", + }); + } + }; + Ok(Value::LiteralValue(LiteralBits::Bool(out))) + } + TransformTarget::Operator(OperatorKind::Logical(_)) => Err( + EvalError::UnsupportedTransformTarget { + kind: "Logical", + }, + ), + TransformTarget::FieldProject { .. } => Err(EvalError::UnsupportedTransformTarget { + kind: "FieldProject", + }), + TransformTarget::Callable(_) => Err(EvalError::UnsupportedTransformTarget { + kind: "Callable", + }), + } + } + + fn expect_int_literal(value: &Value) -> Result { + match value { + Value::LiteralValue(LiteralBits::Int(n)) => Ok(*n), + _ => Err(EvalError::BadTransformOperands { + reason: "expected Int literal", + }), + } + } + + fn apply_arithmetic_int(op: ArithmeticOp, a: i64, b: i64) -> Result { + const OVERFLOW: EvalError = EvalError::BadTransformOperands { + reason: "integer overflow", + }; + match op { + ArithmeticOp::Add => a.checked_add(b).ok_or(OVERFLOW), + ArithmeticOp::Sub => a.checked_sub(b).ok_or(OVERFLOW), + ArithmeticOp::Mul => a.checked_mul(b).ok_or(OVERFLOW), + ArithmeticOp::Div => { + if b == 0 { + return Err(EvalError::BadTransformOperands { + reason: "division by zero", + }); + } + a.checked_div(b).ok_or(OVERFLOW) + } + } + } + pub fn evaluate_body( dag: &Dag, entry: NodeId, From 46159fe5760caf85f743a6e1382c6c0c4a020d07 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 08:13:37 -0400 Subject: [PATCH 04/12] chore: apply cargo fmt --- src/v3/compiler/src/lib.rs | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index 401fe22b3e3..51a32828e07 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -199,16 +199,17 @@ pub mod evaluator { }); } let out = match (&operands[0], &operands[1]) { - (Value::LiteralValue(LiteralBits::Int(a)), Value::LiteralValue(LiteralBits::Int(b))) => { - match op { - ComparisonOp::Eq => a == b, - ComparisonOp::Ne => a != b, - ComparisonOp::Lt => a < b, - ComparisonOp::Le => a <= b, - ComparisonOp::Gt => a > b, - ComparisonOp::Ge => a >= b, - } - } + ( + Value::LiteralValue(LiteralBits::Int(a)), + Value::LiteralValue(LiteralBits::Int(b)), + ) => match op { + ComparisonOp::Eq => a == b, + ComparisonOp::Ne => a != b, + ComparisonOp::Lt => a < b, + ComparisonOp::Le => a <= b, + ComparisonOp::Gt => a > b, + ComparisonOp::Ge => a >= b, + }, ( Value::LiteralValue(LiteralBits::String(a)), Value::LiteralValue(LiteralBits::String(b)), @@ -230,17 +231,15 @@ pub mod evaluator { }; Ok(Value::LiteralValue(LiteralBits::Bool(out))) } - TransformTarget::Operator(OperatorKind::Logical(_)) => Err( - EvalError::UnsupportedTransformTarget { - kind: "Logical", - }, - ), + TransformTarget::Operator(OperatorKind::Logical(_)) => { + Err(EvalError::UnsupportedTransformTarget { kind: "Logical" }) + } TransformTarget::FieldProject { .. } => Err(EvalError::UnsupportedTransformTarget { kind: "FieldProject", }), - TransformTarget::Callable(_) => Err(EvalError::UnsupportedTransformTarget { - kind: "Callable", - }), + TransformTarget::Callable(_) => { + Err(EvalError::UnsupportedTransformTarget { kind: "Callable" }) + } } } From 0eaadf3ced1a98345ef611005665de397cc4b284 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 08:18:28 -0400 Subject: [PATCH 05/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/lib.rs | 132 ++++++++++++++++++++++++++++++++++--- 1 file changed, 123 insertions(+), 9 deletions(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index 51a32828e07..506d84352e5 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -391,8 +391,8 @@ pub mod evaluator { EvalStateStack, EvalStrategy, InputEvaluationOrder, Value, }; use crate::dag::{ - ArithmeticOp, Behavior, BranchPattern, Dag, LiteralBits, LoopBound, NodeId, Path, - PortId, TransformTarget, + ArithmeticOp, Behavior, BranchPattern, ComparisonOp, Dag, LiteralBits, LogicalOp, + LoopBound, NodeId, OperatorKind, Path, PortId, TransformTarget, }; use crate::diagnostics::SourceSpan; @@ -569,12 +569,12 @@ pub mod evaluator { } #[test] - fn transform_behavior_fails_closed() { + fn transform_arithmetic_add_evaluates() { let mut dag = Dag::new(); let lhs = dag.push_value(LiteralBits::Int(1), span()); let rhs = dag.push_value(LiteralBits::Int(2), span()); let output = dag.push_transform( - TransformTarget::Operator(crate::dag::OperatorKind::Arithmetic(ArithmeticOp::Add)), + TransformTarget::Operator(OperatorKind::Arithmetic(ArithmeticOp::Add)), vec![lhs, rhs], span(), ); @@ -582,18 +582,132 @@ pub mod evaluator { let mut state = empty_state(); let strategy = eager_strategy(); - let err = - eval_node(&dag, entry, &mut state, &strategy).expect_err("unsupported transform"); + let value = eval_node(&dag, entry, &mut state, &strategy).expect("transform evaluates"); + + assert_eq!(value, Value::LiteralValue(LiteralBits::Int(3))); + } + + #[test] + fn transform_arithmetic_sub_evaluates() { + let mut dag = Dag::new(); + let lhs = dag.push_value(LiteralBits::Int(10), span()); + let rhs = dag.push_value(LiteralBits::Int(3), span()); + let output = dag.push_transform( + TransformTarget::Operator(OperatorKind::Arithmetic(ArithmeticOp::Sub)), + vec![lhs, rhs], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let value = eval_node(&dag, entry, &mut state, &eager_strategy()).expect("sub"); + + assert_eq!(value, Value::LiteralValue(LiteralBits::Int(7))); + } + + #[test] + fn transform_arithmetic_checked_overflow_fails_closed() { + let mut dag = Dag::new(); + let lhs = dag.push_value(LiteralBits::Int(i64::MAX), span()); + let rhs = dag.push_value(LiteralBits::Int(1), span()); + let output = dag.push_transform( + TransformTarget::Operator(OperatorKind::Arithmetic(ArithmeticOp::Add)), + vec![lhs, rhs], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let err = eval_node(&dag, entry, &mut state, &eager_strategy()).expect_err("overflow"); assert_eq!( err, - EvalError::UnsupportedBehavior { - node: entry, - behavior: "Transform" + EvalError::BadTransformOperands { + reason: "integer overflow", + } + ); + } + + #[test] + fn transform_comparison_int_evaluates() { + let mut dag = Dag::new(); + let lhs = dag.push_value(LiteralBits::Int(2), span()); + let rhs = dag.push_value(LiteralBits::Int(3), span()); + let output = dag.push_transform( + TransformTarget::Operator(OperatorKind::Comparison(ComparisonOp::Lt)), + vec![lhs, rhs], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let value = eval_node(&dag, entry, &mut state, &eager_strategy()).expect("cmp"); + + assert_eq!(value, Value::LiteralValue(LiteralBits::Bool(true))); + } + + #[test] + fn transform_logical_operator_unsupported_in_e3_slice() { + let mut dag = Dag::new(); + let lhs = dag.push_value(LiteralBits::Bool(true), span()); + let rhs = dag.push_value(LiteralBits::Bool(false), span()); + let output = dag.push_transform( + TransformTarget::Operator(OperatorKind::Logical(LogicalOp::And)), + vec![lhs, rhs], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let err = eval_node(&dag, entry, &mut state, &eager_strategy()).expect_err("logical"); + + assert_eq!( + err, + EvalError::UnsupportedTransformTarget { kind: "Logical" } + ); + } + + #[test] + fn transform_field_project_unsupported_in_e3_slice() { + let mut dag = Dag::new(); + let v = dag.push_value(LiteralBits::Int(1), span()); + let output = dag.push_transform( + TransformTarget::FieldProject { + field_label: "x".to_string(), + field_child: None, + }, + vec![v], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let err = eval_node(&dag, entry, &mut state, &eager_strategy()).expect_err("project"); + + assert_eq!( + err, + EvalError::UnsupportedTransformTarget { + kind: "FieldProject", } ); } + #[test] + fn transform_callable_unsupported_in_e3_slice() { + let mut dag = Dag::new(); + let int_decl = dag.declaration_by_name("Int").expect("Int").id; + let output = dag.push_transform(TransformTarget::Callable(int_decl), vec![], span()); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let err = eval_node(&dag, entry, &mut state, &eager_strategy()).expect_err("callable"); + + assert_eq!( + err, + EvalError::UnsupportedTransformTarget { kind: "Callable" } + ); + } + #[test] fn branch_behavior_fails_closed() { let mut dag = Dag::new(); From be3b5d432ecf0d999c5af69e120430c13fbe21d6 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 09:08:01 -0400 Subject: [PATCH 06/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/infer.rs | 40 +++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/src/v3/compiler/src/infer.rs b/src/v3/compiler/src/infer.rs index 87735a82d35..0074b945e87 100644 --- a/src/v3/compiler/src/infer.rs +++ b/src/v3/compiler/src/infer.rs @@ -53,7 +53,7 @@ use crate::int_literal_ranges::{ magnitude_out_of_range_for_interval, IntegerRangeLookup, }; use crate::lower::{clone_predicate_body, outer_predicate_slots}; -use crate::operators::{LogicalOp, OperatorKind}; +use crate::operators::{ComparisonOp, LogicalOp, OperatorKind}; use crate::types::TypeShape; /// Outcome of [`try_reconcile_int_literal_decision_set`]. @@ -4423,6 +4423,39 @@ fn div_total_result_output_shape(dag: &mut Dag, base_lhs: TypeShape) -> Option bool { + let Some(int_shape) = dag.int_shape() else { + return false; + }; + if lhs_base == &int_shape { + return true; + } + let Some(bool_shape) = dag.bool_shape() else { + return false; + }; + if lhs_base == &bool_shape { + return true; + } + let Some(string_shape) = dag.string_shape() else { + return false; + }; + if lhs_base == &string_shape { + return matches!(op, ComparisonOp::Eq | ComparisonOp::Ne); + } + false +} + fn resolve_operator_arrow( dag: &mut Dag, op_kind: OperatorKind, @@ -4456,6 +4489,11 @@ fn resolve_operator_arrow( // name. let field_name = crate::operators::algebra_field_name(op_kind); if let Some(field) = children.iter().find(|f| f.label == field_name) { + if let OperatorKind::Comparison(op) = op_kind { + if !host_eager_comparison_operator_supported(dag, &base_lhs, op) { + return None; + } + } return read_algebra_field(dag, &decl, field.ty, source_id, op_kind, &base_lhs); } // Algebra doesn't declare this operator's field — From a9b8c9bf27e980f856c91706c92eeeef34983392 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 09:09:40 -0400 Subject: [PATCH 07/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/infer.rs | 51 +++++++++++++++++++++++++++++++++++- src/v3/compiler/src/lib.rs | 29 ++++++++++++++++++++ 2 files changed, 79 insertions(+), 1 deletion(-) diff --git a/src/v3/compiler/src/infer.rs b/src/v3/compiler/src/infer.rs index 0074b945e87..1fdc8e3b779 100644 --- a/src/v3/compiler/src/infer.rs +++ b/src/v3/compiler/src/infer.rs @@ -4554,7 +4554,12 @@ fn resolve_operator_arrow( div_total_result_output_shape(dag, base_lhs)?, ), OperatorKind::Arithmetic(_) => (vec![base_lhs, base_lhs], base_lhs), - OperatorKind::Comparison(_) => (vec![base_lhs, base_lhs], dag.bool_shape()?), + OperatorKind::Comparison(op) => { + if !host_eager_comparison_operator_supported(dag, &base_lhs, op) { + return None; + } + (vec![base_lhs, base_lhs], dag.bool_shape()?) + } OperatorKind::Logical(_) => { let bool_shape = dag.bool_shape()?; (vec![bool_shape, bool_shape], bool_shape) @@ -5683,6 +5688,50 @@ mod bool_logical_operator_arrow_tests { ); } + #[test] + fn string_ordering_comparison_fails_resolve_operator_arrow_until_host_eval_supports_it() { + let mut dag = Dag::new(); + let string_shape = dag.string_shape().expect("bootstrap String"); + assert!( + resolve_operator_arrow( + &mut dag, + OperatorKind::Comparison(ComparisonOp::Lt), + &string_shape, + ) + .is_none(), + "host eager evaluator has no String `<`; inference must not admit it" + ); + assert!( + resolve_operator_arrow( + &mut dag, + OperatorKind::Comparison(ComparisonOp::Eq), + &string_shape, + ) + .is_some(), + "`==` on String must still resolve (Eq/Ne parity with lens_apply)" + ); + } + + #[test] + fn bool_comparison_operators_resolve_for_host_eval_total_order() { + let mut dag = Dag::new(); + let bool_shape = dag.bool_shape().expect("bootstrap Bool"); + for op in [ + ComparisonOp::Eq, + ComparisonOp::Ne, + ComparisonOp::Lt, + ComparisonOp::Le, + ComparisonOp::Gt, + ComparisonOp::Ge, + ] { + assert!( + resolve_operator_arrow(&mut dag, OperatorKind::Comparison(op), &bool_shape,) + .is_some(), + "Bool comparison {op:?} should resolve (Rust `bool` ordering)" + ); + } + } + #[test] fn bool_logical_and_resolves_via_boolean_algebra_meet_not_pending_fallback() { let mut dag = Dag::new(); diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index 506d84352e5..b14e4233960 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -210,6 +210,17 @@ pub mod evaluator { ComparisonOp::Gt => a > b, ComparisonOp::Ge => a >= b, }, + ( + Value::LiteralValue(LiteralBits::Bool(a)), + Value::LiteralValue(LiteralBits::Bool(b)), + ) => match op { + ComparisonOp::Eq => a == b, + ComparisonOp::Ne => a != b, + ComparisonOp::Lt => a < b, + ComparisonOp::Le => a <= b, + ComparisonOp::Gt => a > b, + ComparisonOp::Ge => a >= b, + }, ( Value::LiteralValue(LiteralBits::String(a)), Value::LiteralValue(LiteralBits::String(b)), @@ -646,6 +657,24 @@ pub mod evaluator { assert_eq!(value, Value::LiteralValue(LiteralBits::Bool(true))); } + #[test] + fn transform_comparison_bool_matches_rust_total_order() { + let mut dag = Dag::new(); + let lhs = dag.push_value(LiteralBits::Bool(false), span()); + let rhs = dag.push_value(LiteralBits::Bool(true), span()); + let output = dag.push_transform( + TransformTarget::Operator(OperatorKind::Comparison(ComparisonOp::Lt)), + vec![lhs, rhs], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let value = eval_node(&dag, entry, &mut state, &eager_strategy()).expect("bool lt"); + + assert_eq!(value, Value::LiteralValue(LiteralBits::Bool(true))); + } + #[test] fn transform_logical_operator_unsupported_in_e3_slice() { let mut dag = Dag::new(); From 104bac38e547301420eef08b7ae600c701d05027 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 09:12:44 -0400 Subject: [PATCH 08/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index b14e4233960..13b7ef8b702 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -236,7 +236,7 @@ pub mod evaluator { _ => { return Err(EvalError::BadTransformOperands { reason: - "comparison operands must both be Int literals or both String literals", + "comparison operands must be Int literals, Bool literals, or String literals (Eq/Ne only for String)", }); } }; From 08b3b748a94d81ce16c7dde8ee6c970f65f36de9 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 14:13:53 +0000 Subject: [PATCH 09/12] fix(evaluator): leave transform division unsupported --- src/v3/compiler/src/lib.rs | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index 13b7ef8b702..92c28644408 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -271,14 +271,9 @@ pub mod evaluator { ArithmeticOp::Add => a.checked_add(b).ok_or(OVERFLOW), ArithmeticOp::Sub => a.checked_sub(b).ok_or(OVERFLOW), ArithmeticOp::Mul => a.checked_mul(b).ok_or(OVERFLOW), - ArithmeticOp::Div => { - if b == 0 { - return Err(EvalError::BadTransformOperands { - reason: "division by zero", - }); - } - a.checked_div(b).ok_or(OVERFLOW) - } + ArithmeticOp::Div => Err(EvalError::UnsupportedTransformTarget { + kind: "ArithmeticDiv", + }), } } @@ -639,6 +634,29 @@ pub mod evaluator { ); } + #[test] + fn transform_arithmetic_div_unsupported_until_result_carrier_eval_lands() { + let mut dag = Dag::new(); + let lhs = dag.push_value(LiteralBits::Int(8), span()); + let rhs = dag.push_value(LiteralBits::Int(2), span()); + let output = dag.push_transform( + TransformTarget::Operator(OperatorKind::Arithmetic(ArithmeticOp::Div)), + vec![lhs, rhs], + span(), + ); + let entry = node_for_port(&dag, output); + let mut state = empty_state(); + + let err = eval_node(&dag, entry, &mut state, &eager_strategy()).expect_err("div"); + + assert_eq!( + err, + EvalError::UnsupportedTransformTarget { + kind: "ArithmeticDiv", + } + ); + } + #[test] fn transform_comparison_int_evaluates() { let mut dag = Dag::new(); From 3b79a7ef1e8963872df03af1f724b5e7120033a3 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 10:22:07 -0400 Subject: [PATCH 10/12] WIP: nimble-ferret-288 --- src/v3/compiler/src/lib.rs | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index 92c28644408..febafd1599d 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -188,7 +188,15 @@ pub mod evaluator { } let a = expect_int_literal(&operands[0])?; let b = expect_int_literal(&operands[1])?; - let n = apply_arithmetic_int(*op, a, b)?; + // `Div` is totalized as `Result` on the transform port in inference. + // The host `Value` carrier has no std `Result` projection yet — fail closed here + // instead of routing `/` through the same `i64` success path as `+`/`-`/`*`. + if matches!(op, ArithmeticOp::Div) { + return Err(EvalError::UnsupportedTransformTarget { + kind: "ArithmeticDiv", + }); + } + let n = apply_arithmetic_int_ring_only(*op, a, b)?; Ok(Value::LiteralValue(LiteralBits::Int(n))) } TransformTarget::Operator(OperatorKind::Comparison(op)) => { @@ -263,7 +271,10 @@ pub mod evaluator { } } - fn apply_arithmetic_int(op: ArithmeticOp, a: i64, b: i64) -> Result { + /// Checked `Int` ring ops only (`Add` / `Sub` / `Mul`). `Div` is rejected + /// at the [`eval_transform_node`] call site so this helper never collapses + /// division through the same `i64` carrier as ring success values. + fn apply_arithmetic_int_ring_only(op: ArithmeticOp, a: i64, b: i64) -> Result { const OVERFLOW: EvalError = EvalError::BadTransformOperands { reason: "integer overflow", }; @@ -271,9 +282,7 @@ pub mod evaluator { ArithmeticOp::Add => a.checked_add(b).ok_or(OVERFLOW), ArithmeticOp::Sub => a.checked_sub(b).ok_or(OVERFLOW), ArithmeticOp::Mul => a.checked_mul(b).ok_or(OVERFLOW), - ArithmeticOp::Div => Err(EvalError::UnsupportedTransformTarget { - kind: "ArithmeticDiv", - }), + ArithmeticOp::Div => unreachable!("caller filters Div before ring-only arithmetic"), } } From 80a27127a0560f17878658bac339d78832371e8a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 14:41:01 +0000 Subject: [PATCH 11/12] fix(evaluator): keep comparison inference global --- src/v3/compiler/src/infer.rs | 91 +----------------------------------- 1 file changed, 2 insertions(+), 89 deletions(-) diff --git a/src/v3/compiler/src/infer.rs b/src/v3/compiler/src/infer.rs index 1fdc8e3b779..87735a82d35 100644 --- a/src/v3/compiler/src/infer.rs +++ b/src/v3/compiler/src/infer.rs @@ -53,7 +53,7 @@ use crate::int_literal_ranges::{ magnitude_out_of_range_for_interval, IntegerRangeLookup, }; use crate::lower::{clone_predicate_body, outer_predicate_slots}; -use crate::operators::{ComparisonOp, LogicalOp, OperatorKind}; +use crate::operators::{LogicalOp, OperatorKind}; use crate::types::TypeShape; /// Outcome of [`try_reconcile_int_literal_decision_set`]. @@ -4423,39 +4423,6 @@ fn div_total_result_output_shape(dag: &mut Dag, base_lhs: TypeShape) -> Option bool { - let Some(int_shape) = dag.int_shape() else { - return false; - }; - if lhs_base == &int_shape { - return true; - } - let Some(bool_shape) = dag.bool_shape() else { - return false; - }; - if lhs_base == &bool_shape { - return true; - } - let Some(string_shape) = dag.string_shape() else { - return false; - }; - if lhs_base == &string_shape { - return matches!(op, ComparisonOp::Eq | ComparisonOp::Ne); - } - false -} - fn resolve_operator_arrow( dag: &mut Dag, op_kind: OperatorKind, @@ -4489,11 +4456,6 @@ fn resolve_operator_arrow( // name. let field_name = crate::operators::algebra_field_name(op_kind); if let Some(field) = children.iter().find(|f| f.label == field_name) { - if let OperatorKind::Comparison(op) = op_kind { - if !host_eager_comparison_operator_supported(dag, &base_lhs, op) { - return None; - } - } return read_algebra_field(dag, &decl, field.ty, source_id, op_kind, &base_lhs); } // Algebra doesn't declare this operator's field — @@ -4554,12 +4516,7 @@ fn resolve_operator_arrow( div_total_result_output_shape(dag, base_lhs)?, ), OperatorKind::Arithmetic(_) => (vec![base_lhs, base_lhs], base_lhs), - OperatorKind::Comparison(op) => { - if !host_eager_comparison_operator_supported(dag, &base_lhs, op) { - return None; - } - (vec![base_lhs, base_lhs], dag.bool_shape()?) - } + OperatorKind::Comparison(_) => (vec![base_lhs, base_lhs], dag.bool_shape()?), OperatorKind::Logical(_) => { let bool_shape = dag.bool_shape()?; (vec![bool_shape, bool_shape], bool_shape) @@ -5688,50 +5645,6 @@ mod bool_logical_operator_arrow_tests { ); } - #[test] - fn string_ordering_comparison_fails_resolve_operator_arrow_until_host_eval_supports_it() { - let mut dag = Dag::new(); - let string_shape = dag.string_shape().expect("bootstrap String"); - assert!( - resolve_operator_arrow( - &mut dag, - OperatorKind::Comparison(ComparisonOp::Lt), - &string_shape, - ) - .is_none(), - "host eager evaluator has no String `<`; inference must not admit it" - ); - assert!( - resolve_operator_arrow( - &mut dag, - OperatorKind::Comparison(ComparisonOp::Eq), - &string_shape, - ) - .is_some(), - "`==` on String must still resolve (Eq/Ne parity with lens_apply)" - ); - } - - #[test] - fn bool_comparison_operators_resolve_for_host_eval_total_order() { - let mut dag = Dag::new(); - let bool_shape = dag.bool_shape().expect("bootstrap Bool"); - for op in [ - ComparisonOp::Eq, - ComparisonOp::Ne, - ComparisonOp::Lt, - ComparisonOp::Le, - ComparisonOp::Gt, - ComparisonOp::Ge, - ] { - assert!( - resolve_operator_arrow(&mut dag, OperatorKind::Comparison(op), &bool_shape,) - .is_some(), - "Bool comparison {op:?} should resolve (Rust `bool` ordering)" - ); - } - } - #[test] fn bool_logical_and_resolves_via_boolean_algebra_meet_not_pending_fallback() { let mut dag = Dag::new(); From 28d338d2c9589a7abe124b1acf684f72b823f8ef Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Fri, 1 May 2026 14:45:09 +0000 Subject: [PATCH 12/12] fix(evaluator): return error for filtered div --- src/v3/compiler/src/lib.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index febafd1599d..ad86d22fbde 100644 --- a/src/v3/compiler/src/lib.rs +++ b/src/v3/compiler/src/lib.rs @@ -282,7 +282,9 @@ pub mod evaluator { ArithmeticOp::Add => a.checked_add(b).ok_or(OVERFLOW), ArithmeticOp::Sub => a.checked_sub(b).ok_or(OVERFLOW), ArithmeticOp::Mul => a.checked_mul(b).ok_or(OVERFLOW), - ArithmeticOp::Div => unreachable!("caller filters Div before ring-only arithmetic"), + ArithmeticOp::Div => Err(EvalError::UnsupportedTransformTarget { + kind: "ArithmeticDiv", + }), } }