record bitwidth in ConstValue::Int (#118)

fixes #117

Author: ss2165

src/builder/tail_loop.rs

@@ -99,7 +99,7 @@ mod test {
                 "main",
                 Signature::new_df(type_row![BIT], type_row![NAT, BIT]),
             )?;
-            let s1 = module_builder.constant(ConstValue::Int(1))?;
+            let s1 = module_builder.constant(ConstValue::i64(1))?;
             let _fdef = {
                 let mut fbuild = module_builder.define_function(&main)?;
                 let [i1] = fbuild.input_wires_arr();
@@ -130,7 +130,7 @@ mod test {
             let main = module_builder
                 .declare("main", Signature::new_df(type_row![BIT], type_row![NAT]))?;
 
-            let s2 = module_builder.constant(ConstValue::Int(2))?;
+            let s2 = module_builder.constant(ConstValue::i64(2))?;
             let tru_const = module_builder.constant(ConstValue::true_val())?;
 
             let _fdef = {

src/ops/module.rs

@@ -115,7 +115,7 @@ impl ModuleOp {
 #[allow(missing_docs)]
 pub enum ConstValue {
     /// An arbitrary length integer constant.
-    Int(i64),
+    Int { value: i64, width: usize },
     /// A constant specifying a variant of a Sum type.
     Sum {
         tag: usize,
@@ -131,7 +131,16 @@ pub enum ConstValue {
 impl PartialEq for ConstValue {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (Self::Int(l0), Self::Int(r0)) => l0 == r0,
+            (
+                Self::Int {
+                    value: l0,
+                    width: l_width,
+                },
+                Self::Int {
+                    value: r0,
+                    width: r_width,
+                },
+            ) => l0 == r0 && l_width == r_width,
             (Self::Opaque(l0, l1), Self::Opaque(r0, r1)) => l0 == r0 && l1.eq(&**r1),
             (
                 Self::Sum { tag, variants, val },
@@ -152,15 +161,18 @@ impl Eq for ConstValue {}
 
 impl Default for ConstValue {
     fn default() -> Self {
-        Self::Int(0)
+        Self::Int {
+            value: 0,
+            width: 64,
+        }
     }
 }
 
 impl ConstValue {
     /// Returns the datatype of the constant.
     pub fn const_type(&self) -> ClassicType {
         match self {
-            Self::Int(_) => ClassicType::i64(),
+            Self::Int { value: _, width } => ClassicType::Int(*width),
             Self::Opaque(_, b) => (*b).const_type(),
             Self::Sum { variants, .. } => {
                 ClassicType::Container(Container::Sum(Box::new(variants.clone())))
@@ -178,7 +190,7 @@ impl ConstValue {
     /// Unique name of the constant.
     pub fn name(&self) -> SmolStr {
         match self {
-            Self::Int(v) => format!("const:int:{v}"),
+            Self::Int { value, width } => format!("const:int<{width}>:{value}"),
             Self::Opaque(_, v) => format!("const:{}", v.name()),
             Self::Sum { tag, val, .. } => {
                 format!("const:sum:{{tag:{tag}, val:{}}}", val.name())
@@ -235,6 +247,11 @@ impl ConstValue {
     pub fn simple_unary_predicate() -> Self {
         Self::simple_predicate(0, 1)
     }
+
+    /// New 64 bit integer constant
+    pub fn i64(value: i64) -> Self {
+        Self::Int { value, width: 64 }
+    }
 }
 
 impl<T: CustomConst> From<T> for ConstValue {