Merge branch 'master' into aztec-packages

noir-lang · Nov 28, 2024 · fc3875c · fc3875c
2 parents 46330f8 + 53f16c7
commit fc3875c
Show file tree

Hide file tree

Showing 39 changed files with 2,207 additions and 419 deletions.
diff --git a/compiler/noirc_errors/src/position.rs b/compiler/noirc_errors/src/position.rs
@@ -94,8 +94,10 @@ impl Span {
         self.start() <= other.start() && self.end() >= other.end()
     }
 
+    /// Returns `true` if any point of `self` intersects a point of `other`.
+    /// Adjacent spans are considered to intersect (so, for example, `0..1` intersects `1..3`).
     pub fn intersects(&self, other: &Span) -> bool {
-        self.end() > other.start() && self.start() < other.end()
+        self.end() >= other.start() && self.start() <= other.end()
     }
 
     pub fn is_smaller(&self, other: &Span) -> bool {
@@ -140,3 +142,37 @@ impl Location {
         self.file == other.file && self.span.contains(&other.span)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::Span;
+
+    #[test]
+    fn test_intersects() {
+        assert!(Span::from(5..10).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(5..5)));
+        assert!(Span::from(5..5).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(10..10).intersects(&Span::from(5..10)));
+        assert!(Span::from(5..10).intersects(&Span::from(10..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(6..9)));
+        assert!(Span::from(6..9).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(4..11)));
+        assert!(Span::from(4..11).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(4..6)));
+        assert!(Span::from(4..6).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(9..11)));
+        assert!(Span::from(9..11).intersects(&Span::from(5..10)));
+
+        assert!(!Span::from(5..10).intersects(&Span::from(3..4)));
+        assert!(!Span::from(3..4).intersects(&Span::from(5..10)));
+
+        assert!(!Span::from(5..10).intersects(&Span::from(11..12)));
+        assert!(!Span::from(11..12).intersects(&Span::from(5..10)));
+    }
+}
diff --git a/compiler/noirc_evaluator/src/acir/mod.rs b/compiler/noirc_evaluator/src/acir/mod.rs
@@ -24,12 +24,10 @@ mod big_int;
 mod brillig_directive;
 mod generated_acir;
 
+use crate::brillig::brillig_gen::gen_brillig_for;
 use crate::brillig::{
     brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext,
-    brillig_ir::{
-        artifact::{BrilligParameter, GeneratedBrillig},
-        BrilligContext,
-    },
+    brillig_ir::artifact::{BrilligParameter, GeneratedBrillig},
     Brillig,
 };
 use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
@@ -518,7 +516,7 @@ impl<'a> Context<'a> {
         let outputs: Vec<AcirType> =
             vecmap(main_func.returns(), |result_id| dfg.type_of_value(*result_id).into());
 
-        let code = self.gen_brillig_for(main_func, arguments.clone(), brillig)?;
+        let code = gen_brillig_for(main_func, arguments.clone(), brillig)?;
 
         // We specifically do not attempt execution of the brillig code being generated as this can result in it being
         // replaced with constraints on witnesses to the program outputs.
@@ -878,8 +876,7 @@ impl<'a> Context<'a> {
                                         None,
                                     )?
                                 } else {
-                                    let code =
-                                        self.gen_brillig_for(func, arguments.clone(), brillig)?;
+                                    let code = gen_brillig_for(func, arguments.clone(), brillig)?;
                                     let generated_pointer =
                                         self.shared_context.new_generated_pointer();
                                     let output_values = self.acir_context.brillig_call(
@@ -999,47 +996,6 @@ impl<'a> Context<'a> {
             .collect()
     }
 
-    fn gen_brillig_for(
-        &self,
-        func: &Function,
-        arguments: Vec<BrilligParameter>,
-        brillig: &Brillig,
-    ) -> Result<GeneratedBrillig<FieldElement>, InternalError> {
-        // Create the entry point artifact
-        let mut entry_point = BrilligContext::new_entry_point_artifact(
-            arguments,
-            BrilligFunctionContext::return_values(func),
-            func.id(),
-        );
-        entry_point.name = func.name().to_string();
-
-        // Link the entry point with all dependencies
-        while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() {
-            let artifact = &brillig.find_by_label(unresolved_fn_label.clone());
-            let artifact = match artifact {
-                Some(artifact) => artifact,
-                None => {
-                    return Err(InternalError::General {
-                        message: format!("Cannot find linked fn {unresolved_fn_label}"),
-                        call_stack: CallStack::new(),
-                    })
-                }
-            };
-            entry_point.link_with(artifact);
-            // Insert the range of opcode locations occupied by a procedure
-            if let Some(procedure_id) = &artifact.procedure {
-                let num_opcodes = entry_point.byte_code.len();
-                let previous_num_opcodes = entry_point.byte_code.len() - artifact.byte_code.len();
-                // We subtract one as to keep the range inclusive on both ends
-                entry_point
-                    .procedure_locations
-                    .insert(procedure_id.clone(), (previous_num_opcodes, num_opcodes - 1));
-            }
-        }
-        // Generate the final bytecode
-        Ok(entry_point.finish())
-    }
-
     /// Handles an ArrayGet or ArraySet instruction.
     /// To set an index of the array (and create a new array in doing so), pass Some(value) for
     /// store_value. To just retrieve an index of the array, pass None for store_value.
@@ -2806,6 +2762,13 @@ impl<'a> Context<'a> {
             Intrinsic::FieldLessThan => {
                 unreachable!("FieldLessThan can only be called in unconstrained")
             }
+            Intrinsic::ArrayRefCount | Intrinsic::SliceRefCount => {
+                let zero = self.acir_context.add_constant(FieldElement::zero());
+                Ok(vec![AcirValue::Var(
+                    zero,
+                    AcirType::NumericType(NumericType::Unsigned { bit_size: 32 }),
+                )])
+            }
         }
     }
 

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
@@ -9,11 +9,17 @@ mod variable_liveness;
 use acvm::FieldElement;
 
 use self::{brillig_block::BrilligBlock, brillig_fn::FunctionContext};
-use super::brillig_ir::{
-    artifact::{BrilligArtifact, Label},
-    BrilligContext,
+use super::{
+    brillig_ir::{
+        artifact::{BrilligArtifact, BrilligParameter, GeneratedBrillig, Label},
+        BrilligContext,
+    },
+    Brillig,
+};
+use crate::{
+    errors::InternalError,
+    ssa::ir::{dfg::CallStack, function::Function},
 };
-use crate::ssa::ir::function::Function;
 
 /// Converting an SSA function into Brillig bytecode.
 pub(crate) fn convert_ssa_function(
@@ -36,3 +42,43 @@ pub(crate) fn convert_ssa_function(
     artifact.name = func.name().to_string();
     artifact
 }
+
+pub(crate) fn gen_brillig_for(
+    func: &Function,
+    arguments: Vec<BrilligParameter>,
+    brillig: &Brillig,
+) -> Result<GeneratedBrillig<FieldElement>, InternalError> {
+    // Create the entry point artifact
+    let mut entry_point = BrilligContext::new_entry_point_artifact(
+        arguments,
+        FunctionContext::return_values(func),
+        func.id(),
+    );
+    entry_point.name = func.name().to_string();
+
+    // Link the entry point with all dependencies
+    while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() {
+        let artifact = &brillig.find_by_label(unresolved_fn_label.clone());
+        let artifact = match artifact {
+            Some(artifact) => artifact,
+            None => {
+                return Err(InternalError::General {
+                    message: format!("Cannot find linked fn {unresolved_fn_label}"),
+                    call_stack: CallStack::new(),
+                })
+            }
+        };
+        entry_point.link_with(artifact);
+        // Insert the range of opcode locations occupied by a procedure
+        if let Some(procedure_id) = &artifact.procedure {
+            let num_opcodes = entry_point.byte_code.len();
+            let previous_num_opcodes = entry_point.byte_code.len() - artifact.byte_code.len();
+            // We subtract one as to keep the range inclusive on both ends
+            entry_point
+                .procedure_locations
+                .insert(procedure_id.clone(), (previous_num_opcodes, num_opcodes - 1));
+        }
+    }
+    // Generate the final bytecode
+    Ok(entry_point.finish())
+}