feat: add Type::is_field and Type::as_integer

compiler/noirc_frontend/src/ast/mod.rs

@@ -39,6 +39,18 @@
     SixtyFour,
 }
 
+impl IntegerBitSize {
+    pub fn bit_size(&self) -> u8 {
+        match self {
+            IntegerBitSize::One => 1,
+            IntegerBitSize::Eight => 8,
+            IntegerBitSize::Sixteen => 16,
+            IntegerBitSize::ThirtyTwo => 32,
+            IntegerBitSize::SixtyFour => 64,
+        }
+    }
+}
+
 impl IntegerBitSize {
     pub fn allowed_sizes() -> Vec<Self> {
         vec![Self::One, Self::Eight, Self::ThirtyTwo, Self::SixtyFour]
@@ -117,7 +129,7 @@
         /*env:*/ Box<UnresolvedType>,
     ),
 
     // The type of quoted code for metaprogramming
     Quoted(crate::QuotedType),
 
     /// An already resolved type. These can only be parsed if they were present in the token stream
@@ -297,6 +309,15 @@
     Signed,
 }
 
+impl Signedness {
+    pub fn is_signed(&self) -> bool {
+        match self {
+            Signedness::Unsigned => false,
+            Signedness::Signed => true,
+        }
+    }
+}
+
 impl UnresolvedTypeExpression {
     // This large error size is justified because it improves parsing speeds by around 40% in
     // release mode. See `ParserError` definition for further explanation.

compiler/noirc_frontend/src/hir/comptime/interpreter.rs

@@ -339,22 +339,30 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                 let argument = Value::Pointer(Shared::new(argument), true);
                 self.define_pattern(pattern, typ, argument, location)
             }
-            HirPattern::Tuple(pattern_fields, _) => match (argument, typ) {
-                (Value::Tuple(fields), Type::Tuple(type_fields))
-                    if fields.len() == pattern_fields.len() =>
-                {
-                    for ((pattern, typ), argument) in
-                        pattern_fields.iter().zip(type_fields).zip(fields)
+            HirPattern::Tuple(pattern_fields, _) => {
+                let typ = &typ.follow_bindings();
+
+                match (argument, typ) {
+                    (Value::Tuple(fields), Type::Tuple(type_fields))
+                        if fields.len() == pattern_fields.len() =>
                     {
-                        self.define_pattern(pattern, typ, argument, location)?;
+                        for ((pattern, typ), argument) in
+                            pattern_fields.iter().zip(type_fields).zip(fields)
+                        {
+                            self.define_pattern(pattern, typ, argument, location)?;
+                        }
+                        Ok(())
+                    }
+                    (value, _) => {
+                        let actual = value.get_type().into_owned();
+                        Err(InterpreterError::TypeMismatch {
+                            expected: typ.clone(),
+                            actual,
+                            location,
+                        })
                     }
-                    Ok(())
-                }
-                (value, _) => {
-                    let actual = value.get_type().into_owned();
-                    Err(InterpreterError::TypeMismatch { expected: typ.clone(), actual, location })
                 }
-            },
+            }
             HirPattern::Struct(struct_type, pattern_fields, _) => {
                 self.push_scope();