chore: Constrain slices from field decomposition functions to be expected length

noir_stdlib/src/field.nr

@@ -1,9 +1,16 @@
 
 impl Field {
-    #[builtin(to_le_bits)]
-    fn to_le_bits(_x : Field, _bit_size: u32) -> [u1] {}
-    #[builtin(to_be_bits)]
-    fn to_be_bits(_x : Field, _bit_size: u32) -> [u1] {}
+
+    fn to_le_bits(x : Field, bit_size: u32) -> [u1] {
+        let bit_array = x.__to_le_bits(bit_size);
+        assert(bit_array.len() == bit_size as Field);
+        bit_array
+    }
+    fn to_be_bits(x : Field, bit_size: u32) -> [u1] {
+        let bit_array = x.__to_be_bits(bit_size);
+        assert(bit_array.len() == bit_size as Field);
+        bit_array
+    }
 
     fn to_le_bytes(x : Field, byte_size: u32) -> [u8] {
         x.to_le_radix(256, byte_size)
@@ -12,12 +19,30 @@ impl Field {
         x.to_be_radix(256, byte_size)
     }
 
-    #[builtin(to_le_radix)]
+    fn to_le_radix(x : Field, radix: u32, result_len: u32) -> [u8] {
+        let radix_array = x.__to_le_radix(radix, result_len);
+        assert(radix_array.len() == result_len as Field);
+        radix_array
+    }
+
+    fn to_be_radix(x : Field, radix: u32, result_len: u32) -> [u8] {
+        let radix_array = x.__to_be_radix(radix, result_len);
+        assert(radix_array.len() == result_len as Field);
+        radix_array
+    }
+
+    #[builtin(to_le_bits)]
+    fn __to_le_bits(_x : Field, _bit_size: u32) -> [u1] {}
+    #[builtin(to_be_bits)]
+    fn __to_be_bits(_x : Field, _bit_size: u32) -> [u1] {}
+
+
     //decompose _x into a _result_len vector over the _radix basis
     //_radix must be less than 256
-    fn to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
+    #[builtin(to_le_radix)]
+    fn __to_le_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
     #[builtin(to_be_radix)]
-    fn to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
+    fn __to_be_radix(_x : Field, _radix: u32, _result_len: u32) -> [u8] {}
 
     // Returns self to the power of the given exponent value.
     // Caution: we assume the exponent fits into 32 bits