feat(stdlib): Implement str as_bytes and into_bytes function

crates/nargo_cli/tests/execution_success/str_as_bytes/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "str_as_bytes"
+type = "bin"
+authors = [""]
+compiler_version = "0.9.0"
+
+[dependencies]

crates/nargo_cli/tests/execution_success/str_as_bytes/src/main.nr

@@ -0,0 +1,16 @@
+use dep::std;
+fn main() {
+    let a = "hello";
+    let b = a.as_bytes();
+    assert(b[0]==104);
+    assert(b[1]==101);
+    assert(b[2]==108);
+    assert(b[3]==108);
+    assert(b[4]==111);
+    let mut c = a.into_bytes();
+    assert(c.get(0)==104);
+    assert(c.get(1)==101);
+    assert(c.get(2)==108);
+    assert(c.get(3)==108);
+    assert(c.get(4)==111);
+}

crates/noirc_evaluator/src/ssa/ir/instruction.rs

@@ -41,6 +41,7 @@ pub(crate) enum Intrinsic {
     SlicePopFront,
     SliceInsert,
     SliceRemove,
+    StrAsBytes,
     Println,
     ToBits(Endian),
     ToRadix(Endian),
@@ -60,6 +61,7 @@ impl std::fmt::Display for Intrinsic {
             Intrinsic::SlicePopFront => write!(f, "slice_pop_front"),
             Intrinsic::SliceInsert => write!(f, "slice_insert"),
             Intrinsic::SliceRemove => write!(f, "slice_remove"),
+            Intrinsic::StrAsBytes => write!(f, "str_as_bytes"),
             Intrinsic::ToBits(Endian::Big) => write!(f, "to_be_bits"),
             Intrinsic::ToBits(Endian::Little) => write!(f, "to_le_bits"),
             Intrinsic::ToRadix(Endian::Big) => write!(f, "to_be_radix"),
@@ -84,6 +86,7 @@ impl Intrinsic {
             "slice_pop_front" => Some(Intrinsic::SlicePopFront),
             "slice_insert" => Some(Intrinsic::SliceInsert),
             "slice_remove" => Some(Intrinsic::SliceRemove),
+            "str_as_bytes" => Some(Intrinsic::StrAsBytes),
             "to_le_radix" => Some(Intrinsic::ToRadix(Endian::Little)),
             "to_be_radix" => Some(Intrinsic::ToRadix(Endian::Big)),
             "to_le_bits" => Some(Intrinsic::ToBits(Endian::Little)),

crates/noirc_evaluator/src/ssa/ir/instruction/call.rs

@@ -165,6 +165,15 @@ pub(super) fn simplify_call(
                 SimplifyResult::None
             }
         }
+        Intrinsic::StrAsBytes => {
+            let str = dfg.get_array_constant(arguments[0]);
+            if let Some((str, typ)) = str {
+                let result = dfg.make_array(str, typ);
+                SimplifyResult::SimplifiedTo(result)
+            } else {
+                SimplifyResult::None
+            }
+        }
         Intrinsic::AssertConstant => {
             if arguments.iter().all(|argument| dfg.is_constant(*argument)) {
                 SimplifyResult::Remove

noir_stdlib/Nargo.toml

@@ -1,5 +1,6 @@
 [package]
 name = "std"
+type = "lib"
 authors = [""]
 compiler_version = "0.1"
 

noir_stdlib/src/lib.nr

@@ -15,6 +15,7 @@ mod unsafe;
 mod collections;
 mod compat;
 mod option;
+mod string;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident 

noir_stdlib/src/string.nr

@@ -0,0 +1,11 @@
+use crate::collections::vec::Vec;
+impl<N> str<N> {
+    /// return a byte slice of the str content
+    #[builtin(str_as_bytes)]
+    fn as_bytes(_self: Self) -> [u8] { }
+
+    /// return a byte vector of the str content
+    fn into_bytes(self: Self) -> Vec<u8> {
+        Vec::from_slice(self.as_bytes())
+    }
+}