diff --git a/src/v3/compiler/src/lib.rs b/src/v3/compiler/src/lib.rs index a3deca9a553..ad86d22fbde 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`. @@ -95,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 { @@ -109,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 { @@ -136,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 { @@ -146,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), @@ -153,6 +168,126 @@ 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])?; + // `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)) => { + 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::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)), + ) => 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 be Int literals, Bool literals, or String literals (Eq/Ne only for String)", + }); + } + }; + 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", + }), + } + } + + /// 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", + }; + 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 => Err(EvalError::UnsupportedTransformTarget { + kind: "ArithmeticDiv", + }), + } + } + pub fn evaluate_body( dag: &Dag, entry: NodeId, @@ -273,8 +408,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; @@ -451,12 +586,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(), ); @@ -464,18 +599,173 @@ 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_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(); + 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_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(); + 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();