Merge branch 'master' into tf/full-backprop

* master:
  chore: Stop cloning `FuncMeta` (#3968)
  feat: add MVP `nargo export` command (#3870)
  chore: clippy and general cleanup of debugger (#3957)
  chore: updating the noirjs tutorial to match stable + some other improvements (#3929)
  chore: add `insert_range_check` method to `FunctionBuilder` (#3959)
  chore: remove usage of term "preprocessed" in favour of "artifact" (#3939)

Author: TomAFrench

.github/workflows/test-js-packages.yml

@@ -319,7 +319,7 @@ jobs:
         run: yarn workspace @noir-lang/noir_wasm test:browser
 
   test-noir-codegen:
-    needs: [build-acvm-js, build-noirc-abi]
+    needs: [build-acvm-js, build-noirc-abi, build-nargo]
     name: noir_codegen
     runs-on: ubuntu-latest
     timeout-minutes: 30
@@ -328,6 +328,12 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Download nargo binary
+        uses: actions/download-artifact@v3
+        with:
+          name: nargo
+          path: ./nargo
+
       - name: Download acvm_js package artifact
         uses: actions/download-artifact@v3
         with:
@@ -339,6 +345,14 @@ jobs:
         with:
           name: noirc_abi_wasm
           path: ./tooling/noirc_abi_wasm
+      
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
 
       - name: Install Yarn dependencies
         uses: ./.github/actions/setup

Cargo.lock

@@ -33,7 +33,7 @@ pub(super) fn compute_function_abi(
 ) -> (Vec<AbiParameter>, Option<AbiType>) {
     let func_meta = context.def_interner.function_meta(func_id);
 
-    let (parameters, return_type) = func_meta.into_function_signature();
+    let (parameters, return_type) = func_meta.function_signature();
     let parameters = into_abi_params(context, parameters);
     let return_type = return_type.map(|typ| AbiType::from_type(context, &typ));
     (parameters, return_type)

compiler/noirc_driver/src/abi_gen.rs

@@ -255,6 +255,19 @@ impl FunctionBuilder {
         self.insert_instruction(Instruction::Constrain(lhs, rhs, assert_message), None);
     }
 
+    /// Insert a [`Instruction::RangeCheck`] instruction at the end of the current block.
+    pub(crate) fn insert_range_check(
+        &mut self,
+        value: ValueId,
+        max_bit_size: u32,
+        assert_message: Option<String>,
+    ) {
+        self.insert_instruction(
+            Instruction::RangeCheck { value, max_bit_size, assert_message },
+            None,
+        );
+    }
+
     /// Insert a call instruction at the end of the current block and return
     /// the results of the call.
     pub(crate) fn insert_call(

compiler/noirc_evaluator/src/ssa/function_builder/mod.rs

@@ -349,12 +349,11 @@ impl<'a> FunctionContext<'a> {
                     self.check_shift_overflow(result, rhs, bit_size, location, false)
                 } else {
                     let message = format!("attempt to {} with overflow", op_name);
-                    let range_constraint = Instruction::RangeCheck {
-                        value: result,
-                        max_bit_size: bit_size,
-                        assert_message: Some(message),
-                    };
-                    self.builder.set_location(location).insert_instruction(range_constraint, None);
+                    self.builder.set_location(location).insert_range_check(
+                        result,
+                        bit_size,
+                        Some(message),
+                    );
                     result
                 }
             }
@@ -464,12 +463,11 @@ impl<'a> FunctionContext<'a> {
                 let product_field = self.builder.insert_binary(lhs_abs, BinaryOp::Mul, rhs_abs);
                 // It must not already overflow the bit_size
                 let message = "attempt to multiply with overflow".to_string();
-                let size_overflow = Instruction::RangeCheck {
-                    value: product_field,
-                    max_bit_size: bit_size,
-                    assert_message: Some(message.clone()),
-                };
-                self.builder.set_location(location).insert_instruction(size_overflow, None);
+                self.builder.set_location(location).insert_range_check(
+                    product_field,
+                    bit_size,
+                    Some(message.clone()),
+                );
                 let product = self.builder.insert_cast(product_field, Type::unsigned(bit_size));
 
                 // Then we check the signed product fits in a signed integer of bit_size-bits

compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs

@@ -542,6 +542,7 @@ pub(crate) fn check_methods_signatures(
 
             // TODO: This is not right since it may bind generic return types
             trait_method.return_type().unify(&resolved_return_type, &mut typecheck_errors, || {
+                let impl_method = resolver.interner.function_meta(func_id);
                 let ret_type_span = impl_method.return_type.get_type().span;
                 let expr_span = ret_type_span.expect("return type must always have a span");
 

compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs

@@ -173,6 +173,29 @@ impl CrateDefMap {
             })
         })
     }
+
+    /// Go through all modules in this crate, and find all functions in
+    /// each module with the #[export] attribute
+    pub fn get_all_exported_functions<'a>(
+        &'a self,
+        interner: &'a NodeInterner,
+    ) -> impl Iterator<Item = FuncId> + 'a {
+        self.modules.iter().flat_map(|(_, module)| {
+            module.value_definitions().filter_map(|id| {
+                if let Some(func_id) = id.as_function() {
+                    let attributes = interner.function_attributes(&func_id);
+                    if attributes.secondary.contains(&SecondaryAttribute::Export) {
+                        Some(func_id)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+        })
+    }
+
     /// Go through all modules in this crate, find all `contract ... { ... }` declarations,
     /// and collect them all into a Vec.
     pub fn get_all_contracts(&self, interner: &NodeInterner) -> Vec<Contract> {

compiler/noirc_frontend/src/hir/def_map/mod.rs

@@ -152,7 +152,7 @@ impl Context<'_> {
         None
     }
 
-    pub fn function_meta(&self, func_id: &FuncId) -> FuncMeta {
+    pub fn function_meta(&self, func_id: &FuncId) -> &FuncMeta {
         self.def_interner.function_meta(func_id)
     }
 
@@ -194,6 +194,19 @@ impl Context<'_> {
             .collect()
     }
 
+    pub fn get_all_exported_functions_in_crate(&self, crate_id: &CrateId) -> Vec<(String, FuncId)> {
+        let interner = &self.def_interner;
+        let def_map = self.def_map(crate_id).expect("The local crate should be analyzed already");
+
+        def_map
+            .get_all_exported_functions(interner)
+            .map(|function_id| {
+                let function_name = self.function_name(&function_id).to_owned();
+                (function_name, function_id)
+            })
+            .collect()
+    }
+
     /// Return a Vec of all `contract` declarations in the source code and the functions they contain
     pub fn get_all_contracts(&self, crate_id: &CrateId) -> Vec<Contract> {
         self.def_map(crate_id)

compiler/noirc_frontend/src/hir/mod.rs

@@ -190,10 +190,11 @@ impl<'interner> TypeChecker<'interner> {
                                 // Automatically add `&mut` if the method expects a mutable reference and
                                 // the object is not already one.
                                 if *func_id != FuncId::dummy_id() {
-                                    let func_meta = self.interner.function_meta(func_id);
+                                    let function_type =
+                                        self.interner.function_meta(func_id).typ.clone();
                                     self.try_add_mutable_reference_to_object(
                                         &mut method_call,
-                                        &func_meta.typ,
+                                        &function_type,
                                         &mut args,
                                     );
                                 }
@@ -561,7 +562,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 let func_meta = self.interner.function_meta(&func_id);
                 let param_len = func_meta.parameters.len();
-                (func_meta.typ, param_len)
+                (func_meta.typ.clone(), param_len)
             }
             HirMethodReference::TraitMethodId(method) => {
                 let the_trait = self.interner.get_trait(method.trait_id);
@@ -916,7 +917,7 @@ impl<'interner> TypeChecker<'interner> {
                     &self.current_function.expect("unexpected method outside a function"),
                 );
 
-                for constraint in func_meta.trait_constraints {
+                for constraint in &func_meta.trait_constraints {
                     if *object_type == constraint.typ {
                         if let Some(the_trait) = self.interner.try_get_trait(constraint.trait_id) {
                             for (method_index, method) in the_trait.methods.iter().enumerate() {

compiler/noirc_frontend/src/hir/type_check/expr.rs

@@ -50,18 +50,23 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     type_checker.current_function = Some(func_id);
 
     let meta = type_checker.interner.function_meta(&func_id);
+    let parameters = meta.parameters.clone();
+    let expected_return_type = meta.return_type.clone();
+    let expected_trait_constraints = meta.trait_constraints.clone();
+    let name_span = meta.name.location.span;
+
     let mut errors = Vec::new();
 
     // Temporarily add any impls in this function's `where` clause to scope
-    for constraint in &meta.trait_constraints {
+    for constraint in &expected_trait_constraints {
         let object = constraint.typ.clone();
         let trait_id = constraint.trait_id;
 
         if !type_checker.interner.add_assumed_trait_implementation(object, trait_id) {
             if let Some(the_trait) = type_checker.interner.try_get_trait(trait_id) {
                 let trait_name = the_trait.name.to_string();
                 let typ = constraint.typ.clone();
-                let span = meta.name.location.span;
+                let span = name_span;
                 errors.push(TypeCheckError::UnneededTraitConstraint { trait_name, typ, span });
             }
         }
@@ -70,7 +75,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     // Bind each parameter to its annotated type.
     // This is locally obvious, but it must be bound here so that the
     // Definition object of the parameter in the NodeInterner is given the correct type.
-    for param in meta.parameters.into_iter() {
+    for param in parameters {
         type_checker.bind_pattern(&param.0, param.1);
     }
 
@@ -93,7 +98,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     errors.append(&mut type_checker.errors);
 
     // Now remove all the `where` clause constraints we added
-    for constraint in &meta.trait_constraints {
+    for constraint in &expected_trait_constraints {
         interner.remove_assumed_trait_implementations_for_trait(constraint.trait_id);
     }
 
@@ -107,7 +112,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
                     expected: declared_return_type.clone(),
                     actual: function_last_type,
                     span: func_span,
-                    source: Source::Return(meta.return_type, expr_span),
+                    source: Source::Return(expected_return_type, expr_span),
                 };
                 errors.push(error);
             }
@@ -122,7 +127,7 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
                         expected: declared_return_type.clone(),
                         actual: function_last_type.clone(),
                         span: func_span,
-                        source: Source::Return(meta.return_type, expr_span),
+                        source: Source::Return(expected_return_type, expr_span),
                     };
 
                     if empty_function {