Separation between Felt, Bool, and Uint types

Cargo.toml

@@ -8,6 +8,7 @@ members = [
     "air",
     "codegen/winterfell",
     "codegen/ace",
+    "typing",
 ]
 resolver = "2"
 

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" }
+typing = { package = "typing", path = "../typing", version = "0.1" }
 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/src/ir/mod.rs

@@ -8,6 +8,7 @@ mod owner;
 mod quad_eval;
 mod utils;
 pub extern crate derive_ir;
+pub extern crate typing;
 
 pub use bus::Bus;
 pub use derive_ir::Builder;
@@ -18,6 +19,8 @@ pub use node::Node;
 pub use nodes::*;
 pub use owner::Owner;
 pub use quad_eval::{QuadFelt, RandomInputs};
+#[allow(unused_imports)]
+pub use typing::*;
 pub use utils::*;
 /// A trait for nodes that can have children
 /// This is used with the Child trait to allow for easy traversal and manipulation of the graph

mir/src/ir/nodes/ops/mod.rs

@@ -29,8 +29,9 @@ pub use matrix::Matrix;
 pub use mul::Mul;
 pub use parameter::Parameter;
 pub use sub::Sub;
+pub use typing::*;
 pub use value::{
-    BusAccess, ConstantValue, MirType, MirValue, PeriodicColumnAccess, PublicInputAccess,
+    BusAccess, ConstantValue, MirValue, PeriodicColumnAccess, PublicInputAccess,
     PublicInputTableAccess, SpannedMirValue, TraceAccess, TraceAccessBinding, Value,
 };
 pub use vector::Vector;

mir/src/ir/nodes/ops/parameter.rs

@@ -1,8 +1,8 @@
 use std::hash::{Hash, Hasher};
 
 use miden_diagnostics::{SourceSpan, Spanned};
+use typing::*;
 
-use super::MirType;
 use crate::ir::{BackLink, Builder, Child, Link, Node, Op, Owner, Singleton};
 
 /// A MIR operation to represent a `Parameter` in a function or evaluator.
@@ -16,19 +16,19 @@ pub struct Parameter {
     /// The position of the `Parameter` in the referred node's `Parameter` list
     pub position: usize,
     /// The type of the `Parameter`
-    pub ty: MirType,
+    pub ty: Option<Type>,
     pub _node: Singleton<Node>,
     #[span]
     pub span: SourceSpan,
 }
 
 impl Parameter {
-    pub fn create(position: usize, ty: MirType, span: SourceSpan) -> Link<Op> {
+    pub fn create(position: usize, ty: Type, span: SourceSpan) -> Link<Op> {
         Op::Parameter(Self {
             parents: Vec::default(),
             ref_node: BackLink::none(),
             position,
-            ty,
+            ty: Some(ty),
             _node: Singleton::none(),
             span,
         })

mir/src/ir/nodes/ops/value.rs

@@ -1,6 +1,4 @@
-use air_parser::ast::{
-    self, BusType, Identifier, QualifiedIdentifier, TraceColumnIndex, TraceSegmentId,
-};
+use air_parser::ast::{BusType, Identifier, QualifiedIdentifier, TraceColumnIndex, TraceSegmentId};
 use miden_diagnostics::{SourceSpan, Spanned};
 
 use crate::ir::{BackLink, Builder, Bus, Child, Link, Node, Op, Owner, Singleton};
@@ -149,24 +147,6 @@ pub struct SpannedMirValue {
     pub value: MirValue,
 }
 
-#[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
-pub enum MirType {
-    #[default]
-    Felt,
-    Vector(usize),
-    Matrix(usize, usize),
-}
-
-impl From<ast::Type> for MirType {
-    fn from(value: ast::Type) -> Self {
-        match value {
-            ast::Type::Felt => MirType::Felt,
-            ast::Type::Vector(n) => MirType::Vector(n),
-            ast::Type::Matrix(cols, rows) => MirType::Matrix(cols, rows),
-        }
-    }
-}
-
 /// Represents an access of a PeriodicColumn, similar in nature to [TraceAccess].
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct PeriodicColumnAccess {

mir/src/passes/inlining.rs

@@ -7,8 +7,8 @@ use super::{duplicate_node_or_replace, visitor::Visitor};
 use crate::{
     CompileError,
     ir::{
-        Accessor, Graph, Link, Mir, MirType, MirValue, Node, Op, Parameter, Parent, Root,
-        SpannedMirValue, TraceAccessBinding, Value, Vector,
+        Accessor, Graph, Link, Mir, MirValue, Node, Op, Parameter, Parent, Root, SpannedMirValue,
+        TraceAccessBinding, Type, Value, Vector,
     },
 };
 
@@ -515,8 +515,8 @@ fn check_evaluator_argument_sizes(
             } else if let Some(parameter) = child.as_parameter() {
                 let Parameter { ty, .. } = parameter.deref();
                 let size = match ty {
-                    MirType::Felt => 1,
-                    MirType::Vector(len) => *len,
+                    Some(Type::Scalar(_)) => 1,
+                    Some(Type::Vector(_, len)) => *len,
                     _ => unreachable!("expected felt or vector, got {:?}", ty),
                 };
                 trace_segments_arg_vector_len += size;
@@ -535,8 +535,8 @@ fn check_evaluator_argument_sizes(
                 } else if let Some(parameter) = indexable.as_parameter() {
                     let Parameter { ty, .. } = parameter.deref();
                     let size = match ty {
-                        MirType::Felt => 1,
-                        MirType::Vector(len) => *len,
+                        Some(Type::Scalar(_)) => 1,
+                        Some(Type::Vector(_, len)) => *len,
                         _ => unreachable!("expected felt or vector, got {:?}", ty),
                     };
                     trace_segments_arg_vector_len += size;
@@ -637,8 +637,8 @@ fn unpack_evaluator_arguments(args: &[Link<Op>]) -> Vec<Link<Op>> {
                 } else if let Some(parameter) = indexable.as_parameter() {
                     let Parameter { ty, .. } = parameter.deref();
                     let _size = match ty {
-                        MirType::Felt => 1,
-                        MirType::Vector(len) => *len,
+                        Some(Type::Scalar(_)) => 1,
+                        Some(Type::Vector(_, len)) => *len,
                         _ => unreachable!("expected felt or vector, got {:?}", ty),
                     };
 

mir/src/passes/mod.rs

@@ -186,7 +186,7 @@ pub fn duplicate_node(
                 .to_link()
                 .unwrap_or_else(|| panic!("invalid ref_node for parameter {parameter:?}",));
             let new_param =
-                Parameter::create(parameter.position, parameter.ty.clone(), parameter.span());
+                Parameter::create(parameter.position, parameter.ty.unwrap(), parameter.span());
 
             if let Some(_root_ref) = owner_ref.as_root() {
                 new_param.as_parameter_mut().unwrap().set_ref_node(owner_ref);
@@ -431,7 +431,7 @@ pub fn duplicate_node_or_replace(
                 current_replace_map.insert(node.get_ptr(), (node.clone(), new_node));
             } else {
                 let new_param =
-                    Parameter::create(parameter.position, parameter.ty.clone(), parameter.span());
+                    Parameter::create(parameter.position, parameter.ty.unwrap(), parameter.span());
 
                 if let Some(_root_ref) = owner_ref.as_root() {
                     new_param.as_parameter_mut().unwrap().set_ref_node(owner_ref.clone());

mir/src/passes/translate.rs

@@ -4,14 +4,15 @@ use std::ops::Deref;
 use air_parser::{LexicalScope, ast, ast::AccessType, symbols};
 use air_pass::Pass;
 use miden_diagnostics::{DiagnosticsHandler, Severity, SourceSpan, Span, Spanned};
+use typing::*;
 
 use crate::{
     CompileError,
     ir::{
         Accessor, Add, Boundary, Builder, Bus, BusAccess, BusOp, BusOpKind, Call, ConstantValue,
         Enf, Evaluator, Exp, Fold, FoldOperator, For, Function, If, Link, MatchArm, Matrix, Mir,
-        MirType, MirValue, Mul, Op, Owner, Parameter, PublicInputAccess, PublicInputTableAccess,
-        Root, SpannedMirValue, Sub, TraceAccess, TraceAccessBinding, Value, Vector,
+        MirValue, Mul, Op, Owner, Parameter, PublicInputAccess, PublicInputTableAccess, Root,
+        SpannedMirValue, Sub, TraceAccess, TraceAccessBinding, Type, Value, Vector,
     },
     passes::duplicate_node,
 };
@@ -189,7 +190,7 @@ impl<'a> MirBuilder<'a> {
             for binding in trace_segment.bindings.iter() {
                 let name = binding.name.as_ref();
                 match &binding.ty {
-                    ast::Type::Vector(size) => {
+                    Type::Vector(_, size) => {
                         let mut params_vec = Vec::new();
                         let mut span = SourceSpan::UNKNOWN;
                         for _ in 0..*size {
@@ -203,7 +204,7 @@ impl<'a> MirBuilder<'a> {
                         let vector_node = Vector::create(params_vec, span);
                         self.bindings.insert(name.unwrap(), vector_node.clone());
                     },
-                    ast::Type::Felt => {
+                    Type::Scalar(_) => {
                         let param = all_params_flatten_for_trace_segment[i].clone();
                         i += 1;
                         self.bindings.insert(name.unwrap(), param.clone());
@@ -236,7 +237,7 @@ impl<'a> MirBuilder<'a> {
             func = func.parameters(param.clone());
         }
         i += 1;
-        let ret = Parameter::create(i, self.translate_type(&ast_func.return_type), ast_func.span());
+        let ret = Parameter::create(i, ast_func.return_type, ast_func.span());
         params.push(ret.clone());
 
         let func = func.return_type(ret).build();
@@ -272,25 +273,25 @@ impl<'a> MirBuilder<'a> {
         &mut self,
         span: SourceSpan,
         name: Option<&'a ast::Identifier>,
-        ty: &ast::Type,
+        ty: &Type,
         i: &mut usize,
     ) -> Result<Vec<Link<Op>>, CompileError> {
         match ty {
-            ast::Type::Felt => {
-                let param = Parameter::create(*i, MirType::Felt, span);
+            Type::Scalar(_) => {
+                let param = Parameter::create(*i, ty!(felt).unwrap(), span);
                 *i += 1;
                 Ok(vec![param])
             },
-            ast::Type::Vector(size) => {
+            Type::Vector(_, size) => {
                 let mut params = Vec::new();
                 for _ in 0..*size {
-                    let param = Parameter::create(*i, MirType::Felt, span);
+                    let param = Parameter::create(*i, ty!(felt[*size]).unwrap(), span);
                     *i += 1;
                     params.push(param);
                 }
                 Ok(params)
             },
-            ast::Type::Matrix(_rows, _cols) => {
+            Type::Matrix(..) => {
                 let span = if let Some(name) = name {
                     name.span()
                 } else {
@@ -310,21 +311,21 @@ impl<'a> MirBuilder<'a> {
         &mut self,
         span: SourceSpan,
         name: Option<&'a ast::Identifier>,
-        ty: &ast::Type,
+        ty: &Type,
         i: &mut usize,
     ) -> Result<Link<Op>, CompileError> {
         match ty {
-            ast::Type::Felt => {
-                let param = Parameter::create(*i, MirType::Felt, span);
+            Type::Scalar(_) => {
+                let param = Parameter::create(*i, *ty, span);
                 *i += 1;
                 Ok(param)
             },
-            ast::Type::Vector(size) => {
-                let param = Parameter::create(*i, MirType::Vector(*size), span);
+            Type::Vector(..) => {
+                let param = Parameter::create(*i, *ty, span);
                 *i += 1;
                 Ok(param)
             },
-            ast::Type::Matrix(_rows, _cols) => {
+            Type::Matrix(..) => {
                 let span = if let Some(name) = name {
                     name.span()
                 } else {
@@ -364,14 +365,6 @@ impl<'a> MirBuilder<'a> {
         Ok(func)
     }
 
-    fn translate_type(&mut self, ty: &ast::Type) -> MirType {
-        match ty {
-            ast::Type::Felt => MirType::Felt,
-            ast::Type::Vector(size) => MirType::Vector(*size),
-            ast::Type::Matrix(rows, cols) => MirType::Matrix(*rows, *cols),
-        }
-    }
-
     fn translate_statement(&mut self, stmt: &'a ast::Statement) -> Result<Link<Op>, CompileError> {
         match stmt {
             ast::Statement::Let(let_stmt) => self.translate_let(let_stmt),
@@ -451,7 +444,8 @@ impl<'a> MirBuilder<'a> {
 
         self.bindings.enter();
         for (index, binding) in list_comp.bindings.iter().enumerate() {
-            let binding_node = Parameter::create(index, ast::Type::Felt.into(), binding.span());
+            // TODO: extract the type from the bound variable
+            let binding_node = Parameter::create(index, ty!(felt).unwrap(), binding.span());
             params.push(binding_node.clone());
             self.bindings.insert(binding, binding_node);
         }
@@ -824,6 +818,32 @@ impl<'a> MirBuilder<'a> {
                         .build();
                     Ok(node)
                 },
+                symbols::AssertBool => {
+                    assert_eq!(call.args.len(), 1);
+                    let x = self.translate_expr(call.args.first().unwrap())?;
+                    // enf x^2 = x
+                    let enforced =
+                        Sub::builder()
+                            .lhs(x.clone())
+                            .rhs(
+                                Exp::builder()
+                                    .lhs(x.clone())
+                                    .rhs(self.translate_const(
+                                        &ast::ConstantExpr::Scalar(2),
+                                        call.span(),
+                                    )?)
+                                    .span(call.span())
+                                    .build(),
+                            )
+                            .span(call.span())
+                            .build();
+                    let node = Enf::builder().span(call.span()).expr(enforced).build();
+                    let _ = self.insert_enforce(node);
+                    let bool_x = duplicate_node(x, &mut Default::default());
+                    // TODO: cast to a bool
+                    //bool_x.update_ty(ty!(bool));
+                    Ok(bool_x)
+                },
                 other => unimplemented!("unhandled builtin: {}", other),
             }
         } else {
@@ -941,7 +961,8 @@ impl<'a> MirBuilder<'a> {
         self.bindings.enter();
         let mut params = Vec::new();
         for (index, binding) in list_comp.bindings.iter().enumerate() {
-            let binding_node = Parameter::create(index, ast::Type::Felt.into(), binding.span());
+            // TODO: extract the type from the bound variable
+            let binding_node = Parameter::create(index, ty!(felt).unwrap(), binding.span());
             params.push(binding_node.clone());
             self.bindings.insert(binding, binding_node);
         }
@@ -1165,8 +1186,8 @@ impl<'a> MirBuilder<'a> {
             //
             // In that case, replacing the default type (Felt) with the one from the access
             if let Some(mut param) = let_bound_access_expr.as_parameter_mut() {
-                if let Some(access_ty) = &access.ty {
-                    param.ty = self.translate_type(access_ty);
+                if access.ty.is_some() {
+                    param.ty = access.ty
                 }
             }
             let accessor: Link<Op> = Accessor::create(

mir/src/passes/unrolling.rs

@@ -815,9 +815,12 @@ impl UnrollingFirstPass<'_> {
                 AccessType::Matrix(..) => 1,
             },
             Op::Parameter(parameter) => match parameter.ty {
-                MirType::Felt => 1,
-                MirType::Vector(l) => l,
-                MirType::Matrix(l, _) => l,
+                Some(Type::Scalar(_)) => 1,
+                Some(Type::Vector(_, l)) => l,
+                Some(Type::Matrix(_, l, _)) => l,
+                _ => {
+                    unreachable!("Parameter should have a type"); // Raise diag
+                },
             },
             _ => 1,
         }
@@ -862,8 +865,11 @@ impl UnrollingFirstPass<'_> {
             let mut new_vec = vec![];
 
             for i in 0..iterator_expected_len {
-                let new_node =
-                    Parameter::create(i, MirType::Felt, for_node.as_for().unwrap().deref().span());
+                let new_node = Parameter::create(
+                    i,
+                    ty!(felt).unwrap(),
+                    for_node.as_for().unwrap().deref().span(),
+                );
                 new_vec.push(new_node.clone());
 
                 let iterators_i = iterators