Merge branch 'master' into michaeljklein/noir-cfg

Author: michaeljklein

.github/benchmark_projects.yml

@@ -15,7 +15,7 @@ projects:
     path: noir-projects/noir-protocol-circuits/crates/private-kernel-tail
     num_runs: 5
     timeout: 4
-    compilation-timeout: 1.2
+    compilation-timeout: 1.5
     execution-timeout: 0.04
     compilation-memory-limit: 250
     execution-memory-limit: 230

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

@@ -521,8 +521,8 @@ jobs:
         working-directory: ./examples/prove_and_verify
         run: ./test.sh
 
-      - name: Run `codegen_verifier`
-        working-directory: ./examples/codegen_verifier
+      - name: Run `solidity_verifier`
+        working-directory: ./examples/solidity_verifier
         run: ./test.sh
 
       - name: Run `oracle_transcript`

EXTERNAL_NOIR_LIBRARIES.yml

@@ -38,7 +38,7 @@ libraries:
     timeout: 2
   noir_rsa:
     repo: noir-lang/noir_rsa
-    timeout: 2
+    timeout: 4
   noir_json_parser:
     repo: noir-lang/noir_json_parser
     timeout: 12
@@ -60,7 +60,7 @@ libraries:
     repo: AztecProtocol/aztec-packages
     ref: *AZ_COMMIT
     path: noir-projects/noir-contracts
-    timeout: 80
+    timeout: 90
   blob:
     repo: AztecProtocol/aztec-packages
     ref: *AZ_COMMIT

compiler/noirc_evaluator/src/ssa/checks/check_for_underconstrained_values.rs

@@ -316,7 +316,12 @@ impl DependencyContext {
         function: &Function,
         all_functions: &BTreeMap<FunctionId, Function>,
     ) {
-        trace!("processing instructions of block {} of function {}", block, function.id());
+        trace!(
+            "processing instructions of block {} of function {} {}",
+            block,
+            function.name(),
+            function.id()
+        );
 
         // First, gather information on all Brillig calls in the block
         // to be able to follow their arguments first appearing in the
@@ -336,6 +341,12 @@ impl DependencyContext {
 
                         if !visited {
                             let results = function.dfg.instruction_results(*instruction);
+
+                            // Calls with no results (e.g. print) shouldn't be checked
+                            if results.is_empty() {
+                                return;
+                            }
+
                             let current_tainted =
                                 BrilligTaintedIds::new(function, arguments, results);
 
@@ -542,8 +553,9 @@ impl DependencyContext {
 
         if !self.tainted.is_empty() {
             trace!(
-                "number of Brillig calls in function {} left unchecked: {}",
-                function,
+                "number of Brillig calls in function {} {} left unchecked: {}",
+                function.name(),
+                function.id(),
                 self.tainted.len()
             );
         }
@@ -567,9 +579,10 @@ impl DependencyContext {
             .collect();
 
         trace!(
-            "making {} reports on underconstrained Brillig calls for function {}",
+            "making {} reports on underconstrained Brillig calls for function {} {}",
             warnings.len(),
-            function.name()
+            function.name(),
+            function.id()
         );
         warnings
     }
@@ -1418,4 +1431,30 @@ mod test {
         let ssa_level_warnings = ssa.check_for_missing_brillig_constraints(true);
         assert_eq!(ssa_level_warnings.len(), 0);
     }
+
+    #[test]
+    #[traced_test]
+    /// No-result calls (e.g. print) shouldn't trigger the check
+    fn test_no_result_brillig_calls() {
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0():
+            call f1(Field 1)
+            return Field 1
+        }
+        acir(inline) fn println f1 {
+          b0(v0: Field):
+            call f2(u1 1, v0)
+            return
+        }
+        brillig(inline) fn print_unconstrained f2 {
+          b0(v0: u1, v1: Field):
+            return
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints(false);
+        assert_eq!(ssa_level_warnings.len(), 0);
+    }
 }

compiler/noirc_frontend/src/elaborator/lints.rs

@@ -307,7 +307,6 @@ fn can_return_without_recursing(interner: &NodeInterner, func_id: FuncId, expr_i
         HirExpression::Index(e) => check(e.collection) && check(e.index),
         HirExpression::MemberAccess(e) => check(e.lhs),
         HirExpression::Call(e) => check(e.func) && e.arguments.iter().cloned().all(check),
-        HirExpression::MethodCall(e) => check(e.object) && e.arguments.iter().cloned().all(check),
         HirExpression::Constrain(e) => check(e.0) && e.2.map(check).unwrap_or(true),
         HirExpression::Cast(e) => check(e.lhs),
         HirExpression::If(e) => {
@@ -323,7 +322,6 @@ fn can_return_without_recursing(interner: &NodeInterner, func_id: FuncId, expr_i
         | HirExpression::EnumConstructor(_)
         | HirExpression::Quote(_)
         | HirExpression::Unquote(_)
-        | HirExpression::Comptime(_)
         | HirExpression::Error => true,
     }
 }

compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs

@@ -6,8 +6,8 @@ use crate::ast::{
     ArrayLiteral, AssignStatement, BlockExpression, CallExpression, CastExpression, ConstrainKind,
     ConstructorExpression, ExpressionKind, ForLoopStatement, ForRange, GenericTypeArgs, Ident,
     IfExpression, IndexExpression, InfixExpression, LValue, Lambda, Literal, MatchExpression,
-    MemberAccessExpression, MethodCallExpression, Path, PathSegment, Pattern, PrefixExpression,
-    UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, UnsafeExpression, WhileStatement,
+    MemberAccessExpression, Path, PathSegment, Pattern, PrefixExpression, UnresolvedType,
+    UnresolvedTypeData, UnresolvedTypeExpression, UnsafeExpression, WhileStatement,
 };
 use crate::ast::{ConstrainExpression, Expression, Statement, StatementKind};
 use crate::hir_def::expr::{
@@ -148,19 +148,6 @@ impl HirExpression {
                 let is_macro_call = false;
                 ExpressionKind::Call(Box::new(CallExpression { func, arguments, is_macro_call }))
             }
-            HirExpression::MethodCall(method_call) => {
-                ExpressionKind::MethodCall(Box::new(MethodCallExpression {
-                    object: method_call.object.to_display_ast(interner),
-                    method_name: method_call.method.clone(),
-                    arguments: vecmap(method_call.arguments.clone(), |arg| {
-                        arg.to_display_ast(interner)
-                    }),
-                    generics: method_call.generics.clone().map(|option| {
-                        option.iter().map(|generic| generic.to_display_ast()).collect()
-                    }),
-                    is_macro_call: false,
-                }))
-            }
             HirExpression::Constrain(constrain) => {
                 let expr = constrain.0.to_display_ast(interner);
                 let mut arguments = vec![expr];
@@ -198,9 +185,6 @@ impl HirExpression {
                 ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
             }
             HirExpression::Error => ExpressionKind::Error,
-            HirExpression::Comptime(block) => {
-                ExpressionKind::Comptime(block.to_display_ast(interner), location)
-            }
             HirExpression::Unsafe(block) => ExpressionKind::Unsafe(UnsafeExpression {
                 block: block.to_display_ast(interner),
                 unsafe_keyword_location: location,

compiler/noirc_frontend/src/hir/comptime/interpreter.rs

@@ -29,8 +29,7 @@ use crate::{
         expr::{
             HirArrayLiteral, HirBlockExpression, HirCallExpression, HirCastExpression,
             HirConstructorExpression, HirExpression, HirIdent, HirIfExpression, HirIndexExpression,
-            HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess, HirMethodCallExpression,
-            HirPrefixExpression,
+            HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess, HirPrefixExpression,
         },
         stmt::{
             HirAssignStatement, HirForStatement, HirLValue, HirLetStatement, HirPattern,
@@ -528,15 +527,13 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             HirExpression::Constructor(constructor) => self.evaluate_constructor(constructor, id),
             HirExpression::MemberAccess(access) => self.evaluate_access(access, id),
             HirExpression::Call(call) => self.evaluate_call(call, id),
-            HirExpression::MethodCall(call) => self.evaluate_method_call(call, id),
             HirExpression::Constrain(constrain) => self.evaluate_constrain(constrain),
             HirExpression::Cast(cast) => self.evaluate_cast(&cast, id),
             HirExpression::If(if_) => self.evaluate_if(if_, id),
             HirExpression::Match(match_) => todo!("Evaluate match in comptime code"),
             HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
             HirExpression::Quote(tokens) => self.evaluate_quote(tokens, id),
-            HirExpression::Comptime(block) => self.evaluate_block(block),
             HirExpression::Unsafe(block) => self.evaluate_block(block),
             HirExpression::EnumConstructor(constructor) => {
                 self.evaluate_enum_constructor(constructor, id)
@@ -1369,33 +1366,6 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         });
     }
 
-    fn evaluate_method_call(
-        &mut self,
-        call: HirMethodCallExpression,
-        id: ExprId,
-    ) -> IResult<Value> {
-        let object = self.evaluate(call.object)?;
-        let arguments = try_vecmap(call.arguments, |arg| {
-            Ok((self.evaluate(arg)?, self.elaborator.interner.expr_location(&arg)))
-        })?;
-        let location = self.elaborator.interner.expr_location(&id);
-
-        let typ = object.get_type().follow_bindings();
-        let method_name = &call.method.0.contents;
-        let check_self_param = true;
-
-        let method = self
-            .elaborator
-            .lookup_method(&typ, method_name, location, check_self_param)
-            .and_then(|method| method.func_id(self.elaborator.interner));
-
-        if let Some(method) = method {
-            self.call_function(method, arguments, TypeBindings::new(), location)
-        } else {
-            Err(InterpreterError::NoMethodFound { name: method_name.clone(), typ, location })
-        }
-    }
-
     fn evaluate_cast(&mut self, cast: &HirCastExpression, id: ExprId) -> IResult<Value> {
         let evaluated_lhs = self.evaluate(cast.lhs)?;
         let location = self.elaborator.interner.expr_location(&id);

compiler/noirc_frontend/src/hir_def/expr.rs

@@ -34,7 +34,6 @@ pub enum HirExpression {
     EnumConstructor(HirEnumConstructorExpression),
     MemberAccess(HirMemberAccess),
     Call(HirCallExpression),
-    MethodCall(HirMethodCallExpression),
     Constrain(HirConstrainExpression),
     Cast(HirCastExpression),
     If(HirIfExpression),
@@ -43,7 +42,6 @@ pub enum HirExpression {
     Lambda(HirLambda),
     Quote(Tokens),
     Unquote(Tokens),
-    Comptime(HirBlockExpression),
     Unsafe(HirBlockExpression),
     Error,
 }

compiler/noirc_frontend/src/monomorphization/mod.rs

@@ -606,19 +606,11 @@ impl<'interner> Monomorphizer<'interner> {
 
             HirExpression::Lambda(lambda) => self.lambda(lambda, expr)?,
 
-            HirExpression::MethodCall(hir_method_call) => {
-                unreachable!(
-                    "Encountered HirExpression::MethodCall during monomorphization {hir_method_call:?}"
-                )
-            }
             HirExpression::Error => unreachable!("Encountered Error node during monomorphization"),
             HirExpression::Quote(_) => unreachable!("quote expression remaining in runtime code"),
             HirExpression::Unquote(_) => {
                 unreachable!("unquote expression remaining in runtime code")
             }
-            HirExpression::Comptime(_) => {
-                unreachable!("comptime expression remaining in runtime code")
-            }
             HirExpression::EnumConstructor(constructor) => {
                 self.enum_constructor(constructor, expr)?
             }

compiler/noirc_frontend/src/parser/parser/expression.rs

@@ -147,6 +147,25 @@ impl Parser<'_> {
         self.parse_index(atom, start_location)
     }
 
+    pub(super) fn parse_member_accesses_or_method_calls_after_expression(
+        &mut self,
+        mut atom: Expression,
+        start_location: Location,
+    ) -> Expression {
+        let mut parsed;
+
+        loop {
+            (atom, parsed) = self.parse_member_access_or_method_call(atom, start_location);
+            if parsed {
+                continue;
+            } else {
+                break;
+            }
+        }
+
+        atom
+    }
+
     /// CallExpression = Atom CallArguments
     fn parse_call(&mut self, atom: Expression, start_location: Location) -> (Expression, bool) {
         if let Some(call_arguments) = self.parse_call_arguments() {

compiler/noirc_frontend/src/parser/parser/function.rs

@@ -324,8 +324,8 @@ fn empty_body() -> BlockExpression {
 mod tests {
     use crate::{
         ast::{
-            IntegerBitSize, ItemVisibility, NoirFunction, Signedness, UnresolvedTypeData,
-            Visibility,
+            ExpressionKind, IntegerBitSize, ItemVisibility, NoirFunction, Signedness,
+            StatementKind, UnresolvedTypeData, Visibility,
         },
         parse_program_with_dummy_file,
         parser::{
@@ -577,4 +577,42 @@ mod tests {
             UnresolvedTypeData::Integer(Signedness::Signed, IntegerBitSize::SixtyFour)
         );
     }
+
+    #[test]
+    fn parses_block_followed_by_call() {
+        let src = "fn foo() { { 1 }.bar() }";
+        let noir_function = parse_function_no_error(src);
+        let statements = &noir_function.def.body.statements;
+        assert_eq!(statements.len(), 1);
+
+        let StatementKind::Expression(expr) = &statements[0].kind else {
+            panic!("Expected expression statement");
+        };
+
+        let ExpressionKind::MethodCall(call) = &expr.kind else {
+            panic!("Expected method call expression");
+        };
+
+        assert!(matches!(call.object.kind, ExpressionKind::Block(_)));
+        assert_eq!(call.method_name.to_string(), "bar");
+    }
+
+    #[test]
+    fn parses_if_followed_by_call() {
+        let src = "fn foo() { if 1 { 2 } else { 3 }.bar() }";
+        let noir_function = parse_function_no_error(src);
+        let statements = &noir_function.def.body.statements;
+        assert_eq!(statements.len(), 1);
+
+        let StatementKind::Expression(expr) = &statements[0].kind else {
+            panic!("Expected expression statement");
+        };
+
+        let ExpressionKind::MethodCall(call) = &expr.kind else {
+            panic!("Expected method call expression");
+        };
+
+        assert!(matches!(call.object.kind, ExpressionKind::If(_)));
+        assert_eq!(call.method_name.to_string(), "bar");
+    }
 }