Separation between Felt, Bool, and Uint types

Cargo.toml

@@ -8,6 +8,7 @@ members = [
     "air",
     "codegen/winterfell",
     "codegen/ace",
+    "types",
 ]
 resolver = "2"
 
@@ -22,3 +23,4 @@ rust-version = "1.89"
 anyhow = "1.0"
 miden-diagnostics = "0.1"
 thiserror = "2.0"
+air-types = { version = "1.0", path = "types" }

air/src/passes/translate_from_mir.rs

@@ -252,7 +252,7 @@ impl AirBuilder<'_> {
                     ));
                 };
 
-                let ConstantValue::Felt(rhs_value) = constant_value else {
+                let ConstantValue::Scalar(rhs_value) = constant_value else {
                     return Err(CompileError::SemanticAnalysis(
                         SemanticAnalysisError::InvalidExpr(
                             ast::InvalidExprError::NonConstantExponent(rhs.span()),
@@ -267,7 +267,7 @@ impl AirBuilder<'_> {
 
                 let value = match mir_value {
                     MirValue::Constant(constant_value) => {
-                        if let ConstantValue::Felt(felt) = constant_value {
+                        if let ConstantValue::Scalar(felt) = constant_value {
                             crate::ir::Value::Constant(*felt)
                         } else {
                             unreachable!()
@@ -323,7 +323,7 @@ impl AirBuilder<'_> {
 
                 let value = match mir_value {
                     MirValue::Constant(constant_value) => {
-                        if let ConstantValue::Felt(felt) = constant_value {
+                        if let ConstantValue::Scalar(felt) = constant_value {
                             crate::ir::Value::Constant(*felt)
                         } else {
                             unreachable!()
@@ -610,11 +610,7 @@ impl AirBuilder<'_> {
                                 .emit();
                     return Err(CompileError::Failed);
                 }
-                MirTraceAccess {
-                    segment: trace_access_binding.segment,
-                    column: trace_access_binding.offset,
-                    row_offset: 0,
-                }
+                MirTraceAccess::new(trace_access_binding.segment, trace_access_binding.offset, 0)
             },
             SpannedMirValue {
                 value: MirValue::BusAccess(bus_access), ..

air/src/tests/trace.rs

@@ -151,5 +151,5 @@ fn err_ic_trace_cols_group_used_as_scalar() {
         enf a[0]' = a + clk;
     }";
 
-    expect_diagnostic(source, "type mismatch");
+    expect_diagnostic(source, "invalid binary expression");
 }

mir/Cargo.toml

@@ -14,11 +14,12 @@ edition.workspace = true
 [dependencies]
 air-parser = { package = "air-parser", path = "../parser", version = "0.5" }
 air-pass = { package = "air-pass", path = "../pass", version = "0.5" }
+air-types.workspace = true
 anyhow = { workspace = true }
 derive-ir = { package = "air-derive-ir", path = "./derive-ir", version = "0.5" }
 miden-core = { package = "miden-core", version = "0.13", default-features = false }
 miden-diagnostics = { workspace = true }
 pretty_assertions = "1.4"
 rand = "0.9"
 thiserror = { workspace = true }
-winter-math = { package = "winter-math", version = "0.12", default-features = false }
+winter-math = { package = "winter-math", version = "0.12", default-features = false }

mir/derive-ir/src/builder.rs

@@ -564,20 +564,24 @@ fn make_build_method(
     match enum_wrapper {
         EnumWrapper::Op => quote! {
             pub fn build(&self) -> crate::ir::Link<Op> {
-                Op::#name(
+                let mut op = Op::#name(
                     #name {
                         #(#fields),*
                     }
-                ).into()
+                );
+                op.finalize_hook();
+                op.into()
             }
         },
         EnumWrapper::Root => quote! {
             pub fn build(&self) -> crate::ir::Link<Root> {
-                Root::#name(
+                let mut root = Root::#name(
                     #name {
                         #(#fields),*
                     }
-                ).into()
+                );
+                root.finalize_hook();
+                root.into()
             }
         },
     }

mir/src/ir/link.rs

@@ -5,6 +5,8 @@ use std::{
     rc::{Rc, Weak},
 };
 
+use air_types::Typing;
+use air_types::*;
 use miden_diagnostics::{SourceSpan, Spanned};
 
 /// A wrapper around a `Rc<RefCell<T>>` to allow custom trait implementations.
@@ -110,6 +112,24 @@ where
     }
 }
 
+impl<T: Typing> Typing for Link<T> {
+    fn ty(&self) -> Option<Type> {
+        self.borrow().ty()
+    }
+}
+
+impl<T: ScalarTypeMut> ScalarTypeMut for Link<T> {
+    fn update_scalar_ty_unchecked(&mut self, new_ty: Option<ScalarType>) {
+        self.borrow_mut().update_scalar_ty_unchecked(new_ty);
+    }
+}
+
+impl<T: TypeMut> TypeMut for Link<T> {
+    fn update_ty_unchecked(&mut self, new_ty: Option<Type>) {
+        self.borrow_mut().update_ty_unchecked(new_ty);
+    }
+}
+
 /// A wrapper around a `Option<Weak<RefCell<T>>>` to allow custom trait implementations.
 /// Used instead of `Link` where a `Link` would create a cyclIc reference.
 pub struct BackLink<T> {

mir/src/ir/mod.rs

@@ -7,8 +7,11 @@ mod nodes;
 mod owner;
 mod quad_eval;
 mod utils;
+pub extern crate air_types;
 pub extern crate derive_ir;
 
+#[allow(unused_imports)]
+pub use air_types::*;
 pub use bus::Bus;
 pub use derive_ir::Builder;
 pub use graph::Graph;
@@ -113,3 +116,7 @@ pub trait Builder {
     /// Create a new empty builder that exposes all fields
     fn builder() -> Self::Empty;
 }
+
+pub trait BuilderHook {
+    fn finalize_hook(&mut self) {}
+}

mir/src/ir/node.rs

@@ -1,8 +1,8 @@
 use std::ops::Deref;
 
-use miden_diagnostics::{SourceSpan, Spanned};
+use miden_diagnostics::Spanned;
 
-use crate::ir::{BackLink, Child, Link, Op, Owner, Parent, Root};
+use crate::ir::{BackLink, Child, Link, Op, Owner, Parent, Root, Stale};
 
 /// All the nodes that can be in the MIR Graph
 /// Combines all [Root] and [Op] variants
@@ -33,7 +33,8 @@ pub enum Node {
     BusOp(BackLink<Op>),
     Parameter(BackLink<Op>),
     Value(BackLink<Op>),
-    None(SourceSpan),
+    Cast(BackLink<Op>),
+    None(Stale),
 }
 
 impl Default for Node {
@@ -64,6 +65,7 @@ impl PartialEq for Node {
             (Node::BusOp(lhs), Node::BusOp(rhs)) => lhs.to_link() == rhs.to_link(),
             (Node::Parameter(lhs), Node::Parameter(rhs)) => lhs.to_link() == rhs.to_link(),
             (Node::Value(lhs), Node::Value(rhs)) => lhs.to_link() == rhs.to_link(),
+            (Node::Cast(lhs), Node::Cast(rhs)) => lhs.to_link() == rhs.to_link(),
             (Node::None(_), Node::None(_)) => true,
             _ => false,
         }
@@ -92,6 +94,7 @@ impl std::hash::Hash for Node {
             Node::BusOp(b) => b.to_link().hash(state),
             Node::Parameter(p) => p.to_link().hash(state),
             Node::Value(v) => v.to_link().hash(state),
+            Node::Cast(c) => c.to_link().hash(state),
             Node::None(_) => (),
         }
     }
@@ -119,6 +122,7 @@ impl Parent for Node {
             Node::BusOp(b) => b.children(),
             Node::Parameter(_p) => Link::default(),
             Node::Value(_v) => Link::default(),
+            Node::Cast(c) => c.children(),
             Node::None(_) => Link::default(),
         }
     }
@@ -146,6 +150,7 @@ impl Child for Node {
             Node::BusOp(b) => b.get_parents(),
             Node::Parameter(p) => p.get_parents(),
             Node::Value(v) => v.get_parents(),
+            Node::Cast(c) => c.get_parents(),
             Node::None(_) => Vec::default(),
         }
     }
@@ -169,6 +174,7 @@ impl Child for Node {
             Node::BusOp(b) => b.add_parent(parent),
             Node::Parameter(p) => p.add_parent(parent),
             Node::Value(v) => v.add_parent(parent),
+            Node::Cast(c) => c.add_parent(parent),
             Node::None(_) => (),
         }
     }
@@ -192,6 +198,7 @@ impl Child for Node {
             Node::BusOp(b) => b.remove_parent(parent),
             Node::Parameter(p) => p.remove_parent(parent),
             Node::Value(v) => v.remove_parent(parent),
+            Node::Cast(c) => c.remove_parent(parent),
             Node::None(_) => (),
         }
     }
@@ -220,17 +227,18 @@ impl Link<Node> {
                 Op::BusOp(_) => Node::BusOp(BackLink::from(op_inner_val)),
                 Op::Parameter(_) => Node::Parameter(BackLink::from(op_inner_val)),
                 Op::Value(_) => Node::Value(BackLink::from(op_inner_val)),
-                Op::None(span) => Node::None(*span),
+                Op::Cast(_) => Node::Cast(BackLink::from(op_inner_val)),
+                Op::None(none) => Node::None(none.clone()),
             };
         } else if let Some(root_inner_val) = self.as_root() {
             to_update = match root_inner_val.clone().borrow().deref() {
                 Root::Function(_) => Node::Function(BackLink::from(root_inner_val)),
                 Root::Evaluator(_) => Node::Evaluator(BackLink::from(root_inner_val)),
-                Root::None(span) => Node::None(*span),
+                Root::None(none) => Node::None(none.clone()),
             };
         } else {
             // If the [Node] is stale, we set it to None
-            to_update = Node::None(self.span());
+            to_update = Node::None(Stale { span: self.span(), ty: None });
         }
 
         *self.borrow_mut() = to_update;
@@ -276,6 +284,7 @@ impl Link<Node> {
             Node::BusOp(_) => None,
             Node::Parameter(_) => None,
             Node::Value(_) => None,
+            Node::Cast(_) => None,
             Node::None(_) => None,
         }
     }
@@ -301,6 +310,7 @@ impl Link<Node> {
             Node::BusOp(inner) => inner.to_link(),
             Node::Parameter(inner) => inner.to_link(),
             Node::Value(inner) => inner.to_link(),
+            Node::Cast(inner) => inner.to_link(),
             Node::None(_) => None,
         }
     }

mir/src/ir/nodes/mod.rs

@@ -1,10 +1,12 @@
+pub mod stale;
 mod op;
 mod ops;
 mod root;
 mod roots;
 
 use std::cell::{Ref, RefMut};
 
+pub use stale::*;
 pub use op::Op;
 pub use ops::*;
 pub use root::Root;