Merge branch 'master' into gd/databus

Cargo.toml

@@ -80,8 +80,8 @@ noirc_abi = { path = "tooling/noirc_abi" }
 bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" }
 
 # LSP
-async-lsp = { version = "0.0.5", default-features = false }
-lsp-types = "0.94"
+async-lsp = { version = "0.1.0", default-features = false }
+lsp-types = "0.94.1"
 tower = "0.4"
 
 # Wasm

acvm-repo/acvm/src/pwg/brillig.rs

@@ -112,6 +112,22 @@ impl<'b, B: BlackBoxFunctionSolver> BrilligSolver<'b, B> {
         Ok(Self { vm, acir_index })
     }
 
+    pub fn get_registers(&self) -> &Registers {
+        self.vm.get_registers()
+    }
+
+    pub fn set_register(&mut self, register_index: usize, value: Value) {
+        self.vm.set_register(RegisterIndex(register_index), value);
+    }
+
+    pub fn get_memory(&self) -> &[Value] {
+        self.vm.get_memory()
+    }
+
+    pub fn write_memory_at(&mut self, ptr: usize, value: Value) {
+        self.vm.write_memory_at(ptr, value);
+    }
+
     pub(super) fn solve(&mut self) -> Result<BrilligSolverStatus, OpcodeResolutionError> {
         let status = self.vm.process_opcodes();
         self.handle_vm_status(status)

acvm-repo/acvm/src/pwg/mod.rs

@@ -168,6 +168,14 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
         &self.witness_map
     }
 
+    pub fn overwrite_witness(
+        &mut self,
+        witness: Witness,
+        value: FieldElement,
+    ) -> Option<FieldElement> {
+        self.witness_map.insert(witness, value)
+    }
+
     /// Returns a slice containing the opcodes of the circuit being executed.
     pub fn opcodes(&self) -> &[Opcode] {
         self.opcodes

acvm-repo/brillig_vm/src/lib.rs

@@ -164,10 +164,18 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
         &self.registers
     }
 
+    pub fn set_register(&mut self, register_index: RegisterIndex, value: Value) {
+        self.registers.set(register_index, value);
+    }
+
     pub fn get_memory(&self) -> &Vec<Value> {
         self.memory.values()
     }
 
+    pub fn write_memory_at(&mut self, ptr: usize, value: Value) {
+        self.memory.write(ptr, value);
+    }
+
     /// Process a single opcode and modify the program counter.
     pub fn process_opcode(&mut self) -> VMStatus {
         let opcode = &self.bytecode[self.program_counter];

compiler/integration-tests/circuits/main/src/main.nr

@@ -1,3 +1,3 @@
-fn main(x : Field, y : pub Field) {
+fn main(x: Field, y: pub Field) {
     assert(x != y);
 }

compiler/integration-tests/circuits/recursion/src/main.nr

@@ -1,11 +1,11 @@
 use dep::std;
 
 fn main(
-    verification_key : [Field; 114], 
-    proof : [Field; 94], 
-    public_inputs : [Field; 1], 
-    key_hash : Field, 
-    input_aggregation_object : [Field; 16],
+    verification_key: [Field; 114],
+    proof: [Field; 94],
+    public_inputs: [Field; 1],
+    key_hash: Field,
+    input_aggregation_object: [Field; 16]
 ) -> pub [Field; 16] {
     let vk : [Field] = verification_key;
     let p : [Field] = proof;

compiler/noirc_errors/src/debug_info.rs

@@ -22,6 +22,7 @@ pub struct DebugInfo {
 
 /// Holds OpCodes Counts for Acir and Brillig Opcodes
 /// To be printed with `nargo info --profile-info`
+#[derive(Default, Debug, Serialize, Deserialize, Clone)]
 pub struct OpCodesCount {
     pub acir_size: usize,
     pub brillig_size: usize,
@@ -51,12 +52,12 @@ impl DebugInfo {
         self.locations.get(loc).cloned()
     }
 
-    pub fn count_span_opcodes(&self) -> HashMap<&Location, OpCodesCount> {
-        let mut accumulator: HashMap<&Location, Vec<&OpcodeLocation>> = HashMap::new();
+    pub fn count_span_opcodes(&self) -> HashMap<Location, OpCodesCount> {
+        let mut accumulator: HashMap<Location, Vec<&OpcodeLocation>> = HashMap::new();
 
         for (opcode_location, locations) in self.locations.iter() {
             for location in locations.iter() {
-                let opcodes = accumulator.entry(location).or_insert(Vec::new());
+                let opcodes = accumulator.entry(*location).or_insert(Vec::new());
                 opcodes.push(opcode_location);
             }
         }

compiler/noirc_evaluator/src/ssa/ir/printer.rs

@@ -173,7 +173,7 @@ pub(crate) fn display_instruction(
             )
         }
         Instruction::RangeCheck { value, max_bit_size, .. } => {
-            write!(f, "range_check {} to {} bits", show(*value), *max_bit_size,)
+            writeln!(f, "range_check {} to {} bits", show(*value), *max_bit_size,)
         }
     }
 }

compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs

@@ -662,6 +662,22 @@ impl<'f> Context<'f> {
                     self.remember_store(address, value);
                     Instruction::Store { address, value }
                 }
+                Instruction::RangeCheck { value, max_bit_size, assert_message } => {
+                    // Replace value with `value * predicate` to zero out value when predicate is inactive.
+
+                    // Condition needs to be cast to argument type in order to multiply them together.
+                    let argument_type = self.inserter.function.dfg.type_of_value(value);
+                    let casted_condition = self.insert_instruction(
+                        Instruction::Cast(condition, argument_type),
+                        call_stack.clone(),
+                    );
+
+                    let value = self.insert_instruction(
+                        Instruction::binary(BinaryOp::Mul, value, casted_condition),
+                        call_stack.clone(),
+                    );
+                    Instruction::RangeCheck { value, max_bit_size, assert_message }
+                }
                 other => other,
             }
         } else {

compiler/noirc_frontend/src/ast/expression.rs

@@ -370,7 +370,7 @@ pub struct FunctionDefinition {
     pub visibility: FunctionVisibility,
 
     pub generics: UnresolvedGenerics,
-    pub parameters: Vec<(Pattern, UnresolvedType, Visibility)>,
+    pub parameters: Vec<Param>,
     pub body: BlockExpression,
     pub span: Span,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
@@ -379,6 +379,14 @@ pub struct FunctionDefinition {
     pub return_distinctness: Distinctness,
 }
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Param {
+    pub visibility: Visibility,
+    pub pattern: Pattern,
+    pub typ: UnresolvedType,
+    pub span: Span,
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum FunctionReturnType {
     /// Returns type is not specified.
@@ -634,8 +642,11 @@ impl FunctionDefinition {
     ) -> FunctionDefinition {
         let p = parameters
             .iter()
-            .map(|(ident, unresolved_type)| {
-                (Pattern::Identifier(ident.clone()), unresolved_type.clone(), Visibility::Private)
+            .map(|(ident, unresolved_type)| Param {
+                visibility: Visibility::Private,
+                pattern: Pattern::Identifier(ident.clone()),
+                typ: unresolved_type.clone(),
+                span: ident.span().merge(unresolved_type.span.unwrap()),
             })
             .collect();
         FunctionDefinition {
@@ -661,8 +672,8 @@ impl Display for FunctionDefinition {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "{:?}", self.attributes)?;
 
-        let parameters = vecmap(&self.parameters, |(name, r#type, visibility)| {
-            format!("{name}: {visibility} {type}")
+        let parameters = vecmap(&self.parameters, |Param { visibility, pattern, typ, span: _ }| {
+            format!("{pattern}: {visibility} {typ}")
         });
 
         let where_clause = vecmap(&self.where_clause, ToString::to_string);

compiler/noirc_frontend/src/ast/function.rs

@@ -4,7 +4,7 @@ use noirc_errors::Span;
 
 use crate::{
     token::{Attributes, FunctionAttribute, SecondaryAttribute},
-    FunctionReturnType, Ident, Pattern, Visibility,
+    FunctionReturnType, Ident, Param, Visibility,
 };
 
 use super::{FunctionDefinition, UnresolvedType, UnresolvedTypeData};
@@ -45,6 +45,10 @@ impl NoirFunction {
         NoirFunction { kind: FunctionKind::Oracle, def }
     }
 
+    pub fn return_visibility(&self) -> Visibility {
+        self.def.return_visibility
+    }
+
     pub fn return_type(&self) -> UnresolvedType {
         match &self.def.return_type {
             FunctionReturnType::Default(_) => {
@@ -59,7 +63,7 @@ impl NoirFunction {
     pub fn name_ident(&self) -> &Ident {
         &self.def.name
     }
-    pub fn parameters(&self) -> &Vec<(Pattern, UnresolvedType, Visibility)> {
+    pub fn parameters(&self) -> &[Param] {
         &self.def.parameters
     }
     pub fn attributes(&self) -> &Attributes {

compiler/noirc_frontend/src/ast/statement.rs

@@ -436,6 +436,14 @@ pub enum Pattern {
 }
 
 impl Pattern {
+    pub fn span(&self) -> Span {
+        match self {
+            Pattern::Identifier(ident) => ident.span(),
+            Pattern::Mutable(_, span) | Pattern::Tuple(_, span) | Pattern::Struct(_, _, span) => {
+                *span
+            }
+        }
+    }
     pub fn name_ident(&self) -> &Ident {
         match self {
             Pattern::Identifier(name_ident) => name_ident,

compiler/noirc_frontend/src/hir/aztec_library.rs

@@ -17,7 +17,8 @@ use crate::{
 };
 use crate::{
     ForLoopStatement, ForRange, FunctionDefinition, FunctionVisibility, ImportStatement,
-    NoirStruct, PrefixExpression, Signedness, StatementKind, StructType, Type, TypeImpl, UnaryOp,
+    NoirStruct, Param, PrefixExpression, Signedness, StatementKind, StructType, Type, TypeImpl,
+    UnaryOp,
 };
 use fm::FileId;
 
@@ -226,12 +227,12 @@ fn check_for_compute_note_hash_and_nullifier_definition(module: &SortedModule) -
     module.functions.iter().any(|func| {
         func.def.name.0.contents == "compute_note_hash_and_nullifier"
                 && func.def.parameters.len() == 4
-                && func.def.parameters[0].1.typ == UnresolvedTypeData::FieldElement
-                && func.def.parameters[1].1.typ == UnresolvedTypeData::FieldElement
-                && func.def.parameters[2].1.typ == UnresolvedTypeData::FieldElement
+                && func.def.parameters[0].typ.typ == UnresolvedTypeData::FieldElement
+                && func.def.parameters[1].typ.typ == UnresolvedTypeData::FieldElement
+                && func.def.parameters[2].typ.typ == UnresolvedTypeData::FieldElement
                 // checks if the 4th parameter is an array and the Box<UnresolvedType> in
                 // Array(Option<UnresolvedTypeExpression>, Box<UnresolvedType>) contains only fields
-                && match &func.def.parameters[3].1.typ {
+                && match &func.def.parameters[3].typ.typ {
                     UnresolvedTypeData::Array(_, inner_type) => {
                         match inner_type.typ {
                             UnresolvedTypeData::FieldElement => true,
@@ -513,14 +514,14 @@ fn generate_selector_impl(structure: &NoirStruct) -> TypeImpl {
 /// fn foo() {
 ///   // ...
 /// }
-pub(crate) fn create_inputs(ty: &str) -> (Pattern, UnresolvedType, Visibility) {
+pub(crate) fn create_inputs(ty: &str) -> Param {
     let context_ident = ident("inputs");
     let context_pattern = Pattern::Identifier(context_ident);
     let type_path = chained_path!("aztec", "abi", ty);
     let context_type = make_type(UnresolvedTypeData::Named(type_path, vec![]));
     let visibility = Visibility::Private;
 
-    (context_pattern, context_type, visibility)
+    Param { pattern: context_pattern, typ: context_type, visibility, span: Span::default() }
 }
 
 /// Creates the private context object to be accessed within the function, the parameters need to be extracted to be
@@ -548,7 +549,7 @@ pub(crate) fn create_inputs(ty: &str) -> (Pattern, UnresolvedType, Visibility) {
 ///     let mut context = PrivateContext::new(inputs, hasher.hash());
 /// }
 /// ```
-fn create_context(ty: &str, params: &[(Pattern, UnresolvedType, Visibility)]) -> Vec<Statement> {
+fn create_context(ty: &str, params: &[Param]) -> Vec<Statement> {
     let mut injected_expressions: Vec<Statement> = vec![];
 
     // `let mut hasher = Hasher::new();`
@@ -564,7 +565,7 @@ fn create_context(ty: &str, params: &[(Pattern, UnresolvedType, Visibility)]) ->
     injected_expressions.push(let_hasher);
 
     // Iterate over each of the function parameters, adding to them to the hasher
-    params.iter().for_each(|(pattern, typ, _vis)| {
+    params.iter().for_each(|Param { pattern, typ, span: _, visibility: _ }| {
         match pattern {
             Pattern::Identifier(identifier) => {
                 // Match the type to determine the padding to do

compiler/noirc_frontend/src/hir/resolution/resolver.rs

@@ -38,7 +38,7 @@ use crate::{
 };
 use crate::{
     ArrayLiteral, ContractFunctionType, Distinctness, ForRange, FunctionVisibility, Generics,
-    LValue, NoirStruct, NoirTypeAlias, Path, PathKind, Pattern, Shared, StructType, Type,
+    LValue, NoirStruct, NoirTypeAlias, Param, Path, PathKind, Pattern, Shared, StructType, Type,
     TypeAliasType, TypeBinding, TypeVariable, UnaryOp, UnresolvedGenerics,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
     Visibility, ERROR_IDENT,
@@ -760,7 +760,7 @@ impl<'a> Resolver<'a> {
         let mut parameters = vec![];
         let mut parameter_types = vec![];
 
-        for (pattern, typ, visibility) in func.parameters().iter().cloned() {
+        for Param { visibility, pattern, typ, span: _ } in func.parameters().iter().cloned() {
             if visibility == Visibility::Public && !self.pub_allowed(func) {
                 self.push_err(ResolverError::UnnecessaryPub {
                     ident: func.name_ident().clone(),