feat(std_lib): println statements

crates/nargo/tests/test_data/strings/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo/tests/test_data/strings/Prover.toml

@@ -0,0 +1,2 @@
+message = "hello world"
+y = 5

crates/nargo/tests/test_data/strings/src/main.nr

@@ -0,0 +1,21 @@
+use dep::std;
+
+fn main(message : pub str[11], y : Field) {
+    let mut bad_message = "hello world";
+
+    constrain message == "hello world";
+    bad_message = "helld world";
+    let x = 2;
+    log(x);
+
+    // Currently broken
+    // let hash = std::hash::pedersen([x])[0];
+    // log(bad_message);
+    log("five");
+
+    let array = [1, 2, 3, 5, 8];
+    constrain y != 5;
+    log(array);
+
+    constrain message != bad_message;
+}

crates/noirc_abi/src/input_parser/mod.rs

@@ -14,6 +14,7 @@ use crate::AbiType;
 pub enum InputValue {
     Field(FieldElement),
     Vec(Vec<FieldElement>),
+    String(String),
     Struct(BTreeMap<String, InputValue>),
     Undefined,
 }
@@ -38,6 +39,10 @@ impl InputValue {
                     .all(|field_element| Self::Field(*field_element).matches_abi(typ))
             }
 
+            (InputValue::String(string), AbiType::String { length }) => {
+                string.len() == *length as usize
+            }
+
             (InputValue::Struct(map), AbiType::Struct { fields, .. }) => {
                 if map.len() != fields.len() {
                     return false;

crates/noirc_abi/src/input_parser/toml.rs

@@ -55,9 +55,14 @@ fn toml_map_to_field(
     for (parameter, value) in toml_map {
         let mapped_value = match value {
             TomlTypes::String(string) => {
-                let new_value = parse_str(&string)?;
-
-                if let Some(field_element) = new_value {
+                let new_value = try_str_to_field(&string);
+
+                // We accept UTF-8 strings as input as well as hex strings representing field elements.
+                // We still want developers to be able to pass in hex strings for FieldElement inputs.
+                // Thus, we first try to parse the string into a field element, and if that fails we assume that the input is meant to be a plain string
+                if new_value.is_err() {
+                    InputValue::String(string)
+                } else if let Ok(Some(field_element)) = new_value {
                     InputValue::Field(field_element)
                 } else {
                     InputValue::Undefined
@@ -84,7 +89,7 @@ fn toml_map_to_field(
             TomlTypes::ArrayString(arr_str) => {
                 let array_elements: Vec<_> = arr_str
                     .into_iter()
-                    .map(|elem_str| parse_str(&elem_str).unwrap().unwrap())
+                    .map(|elem_str| try_str_to_field(&elem_str).unwrap().unwrap())
                     .collect();
 
                 InputValue::Vec(array_elements)
@@ -116,6 +121,7 @@ fn toml_remap(map: &BTreeMap<String, InputValue>) -> BTreeMap<String, TomlTypes>
                 let array = v.iter().map(|i| format!("0x{}", i.to_hex())).collect();
                 TomlTypes::ArrayString(array)
             }
+            InputValue::String(s) => TomlTypes::String(s.clone()),
             InputValue::Struct(map) => {
                 let map_with_toml_types = toml_remap(map);
                 TomlTypes::Table(map_with_toml_types)
@@ -145,7 +151,7 @@ enum TomlTypes {
     Table(BTreeMap<String, TomlTypes>),
 }
 
-fn parse_str(value: &str) -> Result<Option<FieldElement>, InputParserError> {
+fn try_str_to_field(value: &str) -> Result<Option<FieldElement>, InputParserError> {
     if value.is_empty() {
         Ok(None)
     } else if value.starts_with("0x") {

crates/noirc_abi/src/lib.rs

@@ -1,4 +1,4 @@
-use std::{collections::BTreeMap, convert::TryInto};
+use std::{collections::BTreeMap, convert::TryInto, str};
 
 use acvm::FieldElement;
 use errors::AbiError;
@@ -31,6 +31,7 @@ pub enum AbiType {
     Array { length: u128, typ: Box<AbiType> },
     Integer { sign: Sign, width: u32 },
     Struct { fields: BTreeMap<String, AbiType> },
+    String { length: u128 },
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -63,6 +64,7 @@ impl AbiType {
             AbiType::Field | AbiType::Integer { .. } => 1,
             AbiType::Array { length, typ: _ } => *length as usize,
             AbiType::Struct { fields, .. } => fields.len(),
+            AbiType::String { length } => *length as usize,
         }
     }
 
@@ -74,6 +76,7 @@ impl AbiType {
             AbiType::Struct { fields, .. } => {
                 fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count())
             }
+            AbiType::String { length } => *length as u32,
         }
     }
 }
@@ -177,6 +180,13 @@ impl Abi {
         match value {
             InputValue::Field(elem) => encoded_value.push(elem),
             InputValue::Vec(vec_elem) => encoded_value.extend(vec_elem),
+            InputValue::String(string) => {
+                let str_as_fields = string
+                    .into_bytes()
+                    .into_iter()
+                    .map(|byte| FieldElement::from_be_bytes_reduce(&[byte]));
+                encoded_value.extend(str_as_fields)
+            }
             InputValue::Struct(object) => {
                 for (field_name, value) in object {
                     let new_name = format!("{}.{}", param_name, field_name);
@@ -235,6 +245,24 @@ impl Abi {
                 index += *length as usize;
                 InputValue::Vec(field_elements.to_vec())
             }
+            AbiType::String { length } => {
+                let field_elements = &encoded_inputs[index..index + (*length as usize)];
+
+                let string_as_slice = field_elements
+                    .iter()
+                    .map(|e| {
+                        let mut field_as_bytes = e.to_bytes();
+                        let char_byte = field_as_bytes.pop().unwrap(); // A character in a string is represented by a u8, thus we just want the last byte of the element
+                        assert!(field_as_bytes.into_iter().all(|b| b == 0)); // Assert that the rest of the field element's bytes are empty
+                        char_byte
+                    })
+                    .collect::<Vec<_>>();
+
+                let final_string = str::from_utf8(&string_as_slice).unwrap();
+
+                index += *length as usize;
+                InputValue::String(final_string.to_owned())
+            }
             AbiType::Struct { fields, .. } => {
                 let mut struct_map = BTreeMap::new();
 
@@ -265,6 +293,7 @@ impl Serialize for Abi {
             match param.typ {
                 AbiType::Field => map.serialize_entry(&param.name, "")?,
                 AbiType::Array { .. } => map.serialize_entry(&param.name, &vec)?,
+                AbiType::String { .. } => map.serialize_entry(&param.name, "")?,
                 AbiType::Integer { .. } => map.serialize_entry(&param.name, "")?,
                 AbiType::Struct { .. } => map.serialize_entry(&param.name, "")?,
             };

crates/noirc_evaluator/src/lib.rs

@@ -152,6 +152,11 @@ impl Evaluator {
                 self.generate_struct_witnesses(&mut struct_witnesses, visibility, &new_fields)?;
                 igen.abi_struct(name, Some(def), fields, struct_witnesses);
             }
+            AbiType::String { length } => {
+                let typ = AbiType::Integer { sign: noirc_abi::Sign::Unsigned, width: 8 };
+                let witnesses = self.generate_array_witnesses(visibility, length, &typ)?;
+                igen.abi_array(name, Some(def), &typ, *length, witnesses);
+            }
         }
         Ok(())
     }
@@ -192,6 +197,12 @@ impl Evaluator {
                     }
                     self.generate_struct_witnesses(struct_witnesses, visibility, &new_fields)?
                 }
+                AbiType::String { length } => {
+                    let typ = AbiType::Integer { sign: noirc_abi::Sign::Unsigned, width: 8 };
+                    let internal_str_witnesses =
+                        self.generate_array_witnesses(visibility, length, &typ)?;
+                    struct_witnesses.insert(name.clone(), internal_str_witnesses);
+                }
             }
         }
         Ok(())

crates/noirc_evaluator/src/ssa/acir_gen.rs

@@ -1,14 +1,12 @@
 use super::mem::{ArrayId, MemArray, Memory};
-use super::node::{BinaryOp, Instruction, ObjectType, Operation};
+use super::node::{BinaryOp, Instruction, LogInfo, NodeId, ObjectType, Operation};
 use acvm::acir::OPCODE;
 use acvm::FieldElement;
 
-use super::node::NodeId;
-
 use num_traits::{One, Zero};
 use std::cmp::Ordering;
-use std::collections::HashMap;
 use std::ops::{Mul, Neg};
+use std::{collections::HashMap, str};
 //use crate::acir::native_types::{Arithmetic, Witness};
 use crate::ssa::context::SsaContext;
 use crate::ssa::node::Node;
@@ -210,6 +208,82 @@ impl Acir {
                     todo!("dynamic arrays are not implemented yet");
                 }
             }
+
+            Operation::Log(log_id) => {
+                // TODO: switch these prints to string creation and make a Directive to use when solving the ACIR
+                match log_id {
+                    LogInfo::Node(node_id) => match ctx.get_as_constant(*node_id) {
+                        Some(field) => {
+                            println!("{}", field)
+                        }
+                        None => unreachable!("array objects should not be marked as single values"),
+                    },
+                    LogInfo::Array(array_log) => {
+                        let mem_array = &ctx.mem[array_log.array_id];
+                        let mut field_elements = Vec::new();
+                        for idx in 0..mem_array.len {
+                            let absolute_adr = mem_array.absolute_adr(idx);
+                            if self.memory_map.contains_key(&absolute_adr) {
+                                let array_elem_expr =
+                                    self.memory_map[&absolute_adr].expression.clone();
+                                if array_elem_expr.is_const() {
+                                    field_elements.push(array_elem_expr.q_c)
+                                } else {
+                                    unreachable!("array elements being logging must be const");
+                                }
+                            } else {
+                                // TODO add handling for if key not found
+                                unreachable!(
+                                    "array element being logging does not exist in memory"
+                                );
+                            }
+                        }
+                        if array_log.is_string {
+                            // TODO: make a decode_string_value method in noirc_abi and use it here this is reused code
+                            let string_as_slice = field_elements
+                                .iter()
+                                .map(|e| {
+                                    let mut field_as_bytes = e.to_bytes();
+                                    let char_byte = field_as_bytes.pop().unwrap(); // A character in a string is represented by a u8, thus we just want the last byte of the element
+                                    assert!(field_as_bytes.into_iter().all(|b| b == 0)); // Assert that the rest of the field element's bytes are empty
+                                    char_byte
+                                })
+                                .collect::<Vec<_>>();
+
+                            let final_string = str::from_utf8(&string_as_slice).unwrap();
+                            println!("{}", final_string);
+                        } else {
+                            print!("[");
+                            let mut iter = field_elements.iter().peekable();
+                            while let Some(elem) = iter.next() {
+                                if iter.peek().is_none() {
+                                    print!("{}", elem);
+                                } else {
+                                    print!("{}, ", elem)
+                                }
+                            }
+                            println!("]");
+                        }
+                        // for idx in 0..mem_array.len {
+                        // let absolute_adr = mem_array.absolute_adr(idx);
+                        // if self.memory_map.contains_key(&absolute_adr) {
+                        //     let array_elem_expr = self.memory_map[&absolute_adr].expression.clone();
+                        //     if array_elem_expr.is_const() {
+                        //         let field_element = array_elem_expr.q_c;
+                        //         if array_log.is_string {
+
+                        //         } else {
+                        //             print!("{}, ",field_element)
+                        //         }
+                        //     }
+                        //     // dbg!(self.memory_map[&absolute_adr].expression.to_string());
+                        // }
+                        // }
+                    }
+                }
+                //we do not generate constraint, so no output.
+                InternalVar::default()
+            }
         };
         output.id = Some(ins.id);
         self.arith_cache.insert(ins.id, output);

crates/noirc_evaluator/src/ssa/code_gen.rs

@@ -1,7 +1,7 @@
 use super::context::SsaContext;
 use super::function::FuncIndex;
 use super::mem::ArrayId;
-use super::node::{Binary, BinaryOp, NodeId, ObjectType, Operation, Variable};
+use super::node::{ArrayLog, Binary, BinaryOp, LogInfo, NodeId, ObjectType, Operation, Variable};
 use super::{block, node, ssa_form};
 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryInto;
@@ -158,6 +158,9 @@ impl IRGenerator {
             noirc_abi::AbiType::Struct { .. } => {
                 unreachable!("array of structs are not supported for now")
             }
+            noirc_abi::AbiType::String { .. } => {
+                unreachable!("array of strings are not supported for now")
+            }
         }
     }
 
@@ -515,6 +518,28 @@ impl IRGenerator {
                 }
                 Ok(Value::Single(new_var))
             }
+            Expression::Literal(Literal::Str(string)) => {
+                let string_as_integers = string
+                    .bytes()
+                    .into_iter()
+                    .map(|byte| {
+                        let f = FieldElement::from_be_bytes_reduce(&[byte]);
+                        Expression::Literal(Literal::Integer(
+                            f,
+                            Type::Integer(noirc_frontend::Signedness::Unsigned, 8),
+                        ))
+                    })
+                    .collect::<Vec<_>>();
+
+                let string_arr_literal = ArrayLiteral {
+                    contents: string_as_integers,
+                    element_type: Type::Integer(noirc_frontend::Signedness::Unsigned, 8),
+                };
+
+                let new_value = self
+                    .codegen_expression(&Expression::Literal(Literal::Array(string_arr_literal)))?;
+                Ok(new_value)
+            }
             Expression::Ident(ident) => {
                 Ok(self.codegen_identifier(ident))
                 //n.b this creates a new variable if it does not exist, may be we should delegate this to explicit statements (let) - TODO
@@ -602,9 +627,38 @@ impl IRGenerator {
                 self.codegen_expression(expr.as_ref())?;
                 Ok(Value::dummy())
             }
+            Expression::Log(expr) => {
+                // dbg!(expr.as_ref());
+                self.codegen_log(expr.as_ref())
+            }
         }
     }
 
+    fn codegen_log(&mut self, expression: &Expression) -> Result<Value, RuntimeError> {
+        let is_string = match expression {
+            Expression::Ident(ident) => match ident.typ {
+                Type::String(_) => true,
+                _ => false,
+            },
+            Expression::Literal(literal) => match literal {
+                Literal::Str(_) => true,
+                _ => false,
+            },
+            _ => unreachable!("logging this expression type is not supported"),
+        };
+
+        let node_id = self.codegen_expression(expression)?.unwrap_id();
+        let obj_type = self.context.get_object_type(node_id);
+        let operation = match obj_type {
+            ObjectType::Pointer(array_id) => {
+                Operation::Log(LogInfo::Array(ArrayLog { array_id, is_string }))
+            }
+            _ => Operation::Log(LogInfo::Node(node_id)),
+        };
+        self.context.new_instruction(operation, ObjectType::NotAnObject)?;
+        Ok(Value::dummy())
+    }
+
     fn codegen_lowlevel(&mut self, call: &CallLowLevel) -> Result<NodeId, RuntimeError> {
         match OPCODE::lookup(&call.opcode) {
             Some(func) => self.call_low_level(func, call),