Merge branch 'master' into two_traits_same_fn_name_fix

acvm-repo/acvm_js/src/execute.rs

@@ -1,5 +1,5 @@
 use acvm::{
-    acir::circuit::{Circuit, OpcodeLocation},
+    acir::circuit::Circuit,
     pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM},
 };
 #[allow(deprecated)]
@@ -84,17 +84,13 @@ pub async fn execute_circuit_with_black_box_solver(
                     | OpcodeResolutionError::IndexOutOfBounds {
                         opcode_location: ErrorLocation::Resolved(opcode_location),
                         ..
-                    } => (
-                        get_assert_message(&circuit.assert_messages, opcode_location),
-                        Some(vec![*opcode_location]),
-                    ),
+                    } => {
+                        (circuit.get_assert_message(*opcode_location), Some(vec![*opcode_location]))
+                    }
                     OpcodeResolutionError::BrilligFunctionFailed { call_stack, .. } => {
                         let failing_opcode =
                             call_stack.last().expect("Brillig error call stacks cannot be empty");
-                        (
-                            get_assert_message(&circuit.assert_messages, failing_opcode),
-                            Some(call_stack.clone()),
-                        )
+                        (circuit.get_assert_message(*failing_opcode), Some(call_stack.clone()))
                     }
                     _ => (None, None),
                 };
@@ -117,15 +113,3 @@ pub async fn execute_circuit_with_black_box_solver(
     let witness_map = acvm.finalize();
     Ok(witness_map.into())
 }
-
-// Searches the slice for `opcode_location`.
-// This is functionality equivalent to .get on a map.
-fn get_assert_message(
-    assert_messages: &[(OpcodeLocation, String)],
-    opcode_location: &OpcodeLocation,
-) -> Option<String> {
-    assert_messages
-        .iter()
-        .find(|(loc, _)| loc == opcode_location)
-        .map(|(_, message)| message.clone())
-}

compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs

@@ -487,11 +487,11 @@ impl AcirContext {
             | (AcirVarData::Const(constant), AcirVarData::Witness(witness)) => {
                 let mut expr = Expression::default();
                 expr.push_addition_term(constant, witness);
-                self.add_data(AcirVarData::Expr(expr))
+                self.add_data(AcirVarData::from(expr))
             }
             (AcirVarData::Const(constant), AcirVarData::Expr(expr))
             | (AcirVarData::Expr(expr), AcirVarData::Const(constant)) => {
-                self.add_data(AcirVarData::Expr(&expr * constant))
+                self.add_data(AcirVarData::from(&expr * constant))
             }
             (AcirVarData::Witness(lhs_witness), AcirVarData::Witness(rhs_witness)) => {
                 let mut expr = Expression::default();

compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs

@@ -440,9 +440,30 @@ impl GeneratedAcir {
         //
         // When the predicate is 0, the equation always passes.
         // When the predicate is 1, the rhs must not be 0.
-        let rhs_is_zero = self.is_zero(rhs);
-        let rhs_is_not_zero = self.mul_with_witness(&rhs_is_zero.into(), predicate);
-        self.assert_is_zero(rhs_is_not_zero);
+        let rhs_is_nonzero_const = rhs.is_const() && !rhs.is_zero();
+        if !rhs_is_nonzero_const {
+            match predicate.to_const() {
+                Some(predicate) if predicate.is_zero() => {
+                    // If predicate is known to be inactive, we don't need to lay down constraints.
+                }
+
+                Some(predicate) if predicate.is_one() => {
+                    // If the predicate is known to be active, we simply assert that an inverse must exist.
+                    // This implies that `rhs != 0`.
+                    let unsafe_inverse = self.brillig_inverse(rhs.clone());
+                    let rhs_has_inverse =
+                        self.mul_with_witness(rhs, &unsafe_inverse.into()) - FieldElement::one();
+                    self.assert_is_zero(rhs_has_inverse);
+                }
+
+                _ => {
+                    // Otherwise we must handle both potential cases.
+                    let rhs_is_zero = self.is_zero(rhs);
+                    let rhs_is_not_zero = self.mul_with_witness(&rhs_is_zero.into(), predicate);
+                    self.assert_is_zero(rhs_is_not_zero);
+                }
+            }
+        }
 
         // maximum bit size for q and for [r and rhs]
         let mut max_q_bits = max_bit_size;

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

@@ -774,7 +774,15 @@ fn operator_result_max_bit_size_to_truncate(
     match op {
         Add => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
         Subtract => Some(std::cmp::max(lhs_bit_size, rhs_bit_size) + 1),
-        Multiply => Some(lhs_bit_size + rhs_bit_size),
+        Multiply => {
+            if lhs_bit_size == 1 || rhs_bit_size == 1 {
+                // Truncation is unnecessary as multiplication by a boolean value cannot cause an overflow.
+                None
+            } else {
+                Some(lhs_bit_size + rhs_bit_size)
+            }
+        }
+
         ShiftLeft => {
             if let Some(rhs_constant) = dfg.get_numeric_constant(rhs) {
                 // Happy case is that we know precisely by how many bits the the integer will

compiler/noirc_frontend/src/ast/expression.rs

@@ -26,6 +26,7 @@ pub enum ExpressionKind {
     Variable(Path),
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
+    Parenthesized(Box<Expression>),
     Error,
 }
 
@@ -479,6 +480,7 @@ impl Display for ExpressionKind {
                 write!(f, "({})", elements.join(", "))
             }
             Lambda(lambda) => lambda.fmt(f),
+            Parenthesized(subexpr) => write!(f, "({subexpr})"),
             Error => write!(f, "Error"),
         }
     }

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

@@ -1260,6 +1260,7 @@ impl<'a> Resolver<'a> {
                     captures: lambda_context.captures,
                 })
             }),
+            ExpressionKind::Parenthesized(subexpr) => return self.resolve_expression(*subexpr),
         };
 
         let expr_id = self.interner.push_expr(hir_expr);

compiler/noirc_frontend/src/lexer/lexer.rs

@@ -19,6 +19,7 @@ pub struct Lexer<'a> {
     char_iter: Peekable<Zip<Chars<'a>, RangeFrom<u32>>>,
     position: Position,
     done: bool,
+    skip_comments: bool,
 }
 
 pub type SpannedTokenResult = Result<SpannedToken, LexerErrorKind>;
@@ -39,15 +40,21 @@ impl<'a> Lexer<'a> {
         (Tokens(tokens), errors)
     }
 
-    fn new(source: &'a str) -> Self {
+    pub fn new(source: &'a str) -> Self {
         Lexer {
             // We zip with the character index here to ensure the first char has index 0
             char_iter: source.chars().zip(0..).peekable(),
             position: 0,
             done: false,
+            skip_comments: true,
         }
     }
 
+    pub fn skip_comments(mut self, flag: bool) -> Self {
+        self.skip_comments = flag;
+        self
+    }
+
     /// Iterates the cursor and returns the char at the new cursor position
     fn next_char(&mut self) -> Option<char> {
         let (c, index) = self.char_iter.next()?;
@@ -176,13 +183,16 @@ impl<'a> Lexer<'a> {
             Token::Minus => self.single_double_peek_token('>', prev_token, Token::Arrow),
             Token::Colon => self.single_double_peek_token(':', prev_token, Token::DoubleColon),
             Token::Slash => {
+                let start = self.position;
+
                 if self.peek_char_is('/') {
                     self.next_char();
-                    return self.parse_comment();
+                    return self.parse_comment(start);
                 } else if self.peek_char_is('*') {
                     self.next_char();
-                    return self.parse_block_comment();
+                    return self.parse_block_comment(start);
                 }
+
                 Ok(spanned_prev_token)
             }
             _ => Err(LexerErrorKind::NotADoubleChar {
@@ -377,15 +387,18 @@ impl<'a> Lexer<'a> {
         }
     }
 
-    fn parse_comment(&mut self) -> SpannedTokenResult {
-        let _ = self.eat_while(None, |ch| ch != '\n');
-        self.next_token()
+    fn parse_comment(&mut self, start: u32) -> SpannedTokenResult {
+        let comment = self.eat_while(None, |ch| ch != '\n');
+        if self.skip_comments {
+            return self.next_token();
+        }
+        Ok(Token::LineComment(comment).into_span(start, self.position))
     }
 
-    fn parse_block_comment(&mut self) -> SpannedTokenResult {
-        let start = self.position;
+    fn parse_block_comment(&mut self, start: u32) -> SpannedTokenResult {
         let mut depth = 1usize;
 
+        let mut content = String::new();
         while let Some(ch) = self.next_char() {
             match ch {
                 '/' if self.peek_char_is('*') => {
@@ -403,12 +416,15 @@ impl<'a> Lexer<'a> {
                         break;
                     }
                 }
-                _ => {}
+                ch => content.push(ch),
             }
         }
 
         if depth == 0 {
-            self.next_token()
+            if self.skip_comments {
+                return self.next_token();
+            }
+            Ok(Token::BlockComment(content).into_span(start, self.position))
         } else {
             let span = Span::inclusive(start, self.position);
             Err(LexerErrorKind::UnterminatedBlockComment { span })
@@ -431,7 +447,6 @@ impl<'a> Iterator for Lexer<'a> {
         }
     }
 }
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -497,7 +512,7 @@ mod tests {
         let input = r#"#[deprecated]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Secondary(SecondaryAttribute::Deprecated(None)))
@@ -509,7 +524,7 @@ mod tests {
         let input = r#"#[deprecated("hello")]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Secondary(crate::token::SecondaryAttribute::Deprecated(
@@ -542,7 +557,7 @@ mod tests {
         let input = r#"#[custom(hello)]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Secondary(SecondaryAttribute::Custom(
@@ -556,7 +571,7 @@ mod tests {
         let input = r#"#[test]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Function(FunctionAttribute::Test(TestScope::None)))
@@ -568,7 +583,7 @@ mod tests {
         let input = r#"#[contract_library_method]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod))
@@ -580,7 +595,7 @@ mod tests {
         let input = r#"#[test(should_fail)]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Function(FunctionAttribute::Test(
@@ -594,7 +609,7 @@ mod tests {
         let input = r#"#[test(should_fail_with = "hello")]"#;
         let mut lexer = Lexer::new(input);
 
-        let token = lexer.next().unwrap().unwrap();
+        let token = lexer.next_token().unwrap();
         assert_eq!(
             token.token(),
             &Token::Attribute(Attribute::Function(FunctionAttribute::Test(

compiler/noirc_frontend/src/lexer/token.rs

@@ -19,6 +19,8 @@ pub enum Token {
     Keyword(Keyword),
     IntType(IntType),
     Attribute(Attribute),
+    LineComment(String),
+    BlockComment(String),
     /// <
     Less,
     /// <=
@@ -149,6 +151,8 @@ impl fmt::Display for Token {
             Token::FmtStr(ref b) => write!(f, "f{b}"),
             Token::Keyword(k) => write!(f, "{k}"),
             Token::Attribute(ref a) => write!(f, "{a}"),
+            Token::LineComment(ref s) => write!(f, "//{s}"),
+            Token::BlockComment(ref s) => write!(f, "/*{s}*/"),
             Token::IntType(ref i) => write!(f, "{i}"),
             Token::Less => write!(f, "<"),
             Token::LessEqual => write!(f, "<="),

compiler/noirc_frontend/src/parser/parser.rs

@@ -1554,7 +1554,9 @@ where
         literal(),
     ))
     .map_with_span(Expression::new)
-    .or(parenthesized(expr_parser.clone()))
+    .or(parenthesized(expr_parser.clone()).map_with_span(|subexpr, span| {
+        Expression::new(ExpressionKind::Parenthesized(subexpr.into()), span)
+    }))
     .or(tuple(expr_parser))
     .labelled(ParsingRuleLabel::Atom)
 }

tooling/nargo/src/ops/execute.rs

@@ -15,15 +15,6 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver>(
 ) -> Result<WitnessMap, NargoError> {
     let mut acvm = ACVM::new(blackbox_solver, &circuit.opcodes, initial_witness);
 
-    // Assert messages are not a map due to https://github.com/noir-lang/acvm/issues/522
-    let get_assert_message = |opcode_location| {
-        circuit
-            .assert_messages
-            .iter()
-            .find(|(loc, _)| loc == opcode_location)
-            .map(|(_, message)| message.clone())
-    };
-
     let mut foreign_call_executor = ForeignCallExecutor::default();
 
     loop {
@@ -47,10 +38,10 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver>(
 
                 return Err(NargoError::ExecutionError(match call_stack {
                     Some(call_stack) => {
-                        if let Some(assert_message) = get_assert_message(
-                            call_stack.last().expect("Call stacks should not be empty"),
+                        if let Some(assert_message) = circuit.get_assert_message(
+                            *call_stack.last().expect("Call stacks should not be empty"),
                         ) {
-                            ExecutionError::AssertionFailed(assert_message, call_stack)
+                            ExecutionError::AssertionFailed(assert_message.to_owned(), call_stack)
                         } else {
                             ExecutionError::SolvingError(error)
                         }