fix: Divide by zero should fail to satisfy constraints for Field and ints

Cargo.toml

@@ -59,3 +59,6 @@ url = "2.2.0"
 wasm-bindgen = { version = "=0.2.86", features = ["serde-serialize"] }
 wasm-bindgen-test = "0.3.33"
 base64 = "0.21.2"
+
+# [patch.crates-io]
+# acvm = { path = "/mnt/user-data/maxim/acvm/acvm" }

crates/nargo_cli/tests/compile_failure/divide_by_zero/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "divide_by_zero"
+type = "bin"
+authors = [""]
+compiler_version = "0.10.3"
+
+[dependencies]

crates/nargo_cli/tests/compile_failure/divide_by_zero/src/main.nr

@@ -0,0 +1,6 @@
+use dep::std;
+
+fn main() {
+    let a: Field = 3 / 0;
+    std::println(a);
+}

crates/noirc_evaluator/src/ssa/ir/instruction.rs

@@ -580,6 +580,9 @@ impl Binary {
         let operand_type = dfg.type_of_value(self.lhs);
 
         if let (Some(lhs), Some(rhs)) = (lhs, rhs) {
+            if rhs == FieldElement::zero() {
+                return SimplifyResult::None;
+            }
             return match self.eval_constants(dfg, lhs, rhs, operand_type) {
                 Some(value) => SimplifyResult::SimplifiedTo(value),
                 None => SimplifyResult::None,

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

@@ -301,6 +301,15 @@ impl<'a> FunctionContext<'a> {
             {
                 return self.insert_array_equality(lhs, operator, rhs, location)
             }
+            BinaryOpKind::Divide => {
+                let zero = self.builder.numeric_constant(FieldElement::zero(), Type::field());
+                let divisor_is_zero = self.builder.insert_binary(zero, BinaryOp::Eq, rhs);
+                let divisor_is_not_zero = self.builder.insert_not(divisor_is_zero);
+                self.builder.set_location(location).insert_constrain(divisor_is_not_zero);
+
+                let op = convert_operator(operator);
+                self.builder.set_location(location).insert_binary(lhs, op, rhs)
+            }
             _ => {
                 let op = convert_operator(operator);
                 if operator_requires_swapped_operands(operator) {

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

@@ -371,7 +371,8 @@ impl<'a> Resolver<'a> {
                 // expect() here is valid, because the only places we don't have a span are omitted types
                 // e.g. a function without return type implicitly has a spanless UnresolvedType::Unit return type
                 // To get an invalid env type, the user must explicitly specify the type, which will have a span
-                let env_span = env.span.expect("Unexpected missing span for closure environment type");
+                let env_span =
+                    env.span.expect("Unexpected missing span for closure environment type");
 
                 let env = Box::new(self.resolve_type_inner(*env, new_variables));
 

crates/noirc_frontend/src/parser/parser.rs

@@ -40,8 +40,8 @@ use crate::{
     BinaryOp, BinaryOpKind, BlockExpression, ConstrainStatement, Distinctness, FunctionDefinition,
     FunctionReturnType, Ident, IfExpression, InfixExpression, LValue, Lambda, Literal,
     NoirFunction, NoirStruct, NoirTrait, NoirTypeAlias, Path, PathKind, Pattern, Recoverable,
-    TraitConstraint, TraitImpl, TraitImplItem, TraitItem, TypeImpl, UnaryOp,
-    UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility, TraitBound,
+    TraitBound, TraitConstraint, TraitImpl, TraitImplItem, TraitItem, TypeImpl, UnaryOp,
+    UnresolvedTypeExpression, UseTree, UseTreeKind, Visibility,
 };
 
 use chumsky::prelude::*;
@@ -527,19 +527,17 @@ fn trait_implementation_body() -> impl NoirParser<Vec<TraitImplItem>> {
 }
 
 fn where_clause() -> impl NoirParser<Vec<TraitConstraint>> {
-
     struct MultiTraitConstraint {
         typ: UnresolvedType,
         trait_bounds: Vec<TraitBound>,
     }
 
-    let constraints = parse_type()
-        .then_ignore(just(Token::Colon))
-        .then(trait_bounds())
-        .validate(|(typ, trait_bounds), span, emit| {
+    let constraints = parse_type().then_ignore(just(Token::Colon)).then(trait_bounds()).validate(
+        |(typ, trait_bounds), span, emit| {
             emit(ParserError::with_reason(ParserErrorReason::ExperimentalFeature("Traits"), span));
             MultiTraitConstraint { typ, trait_bounds }
-        });
+        },
+    );
 
     keyword(Keyword::Where)
         .ignore_then(constraints.separated_by(just(Token::Comma)))
@@ -549,18 +547,16 @@ fn where_clause() -> impl NoirParser<Vec<TraitConstraint>> {
             let mut result: Vec<TraitConstraint> = Vec::new();
             for constraint in x {
                 for bound in constraint.trait_bounds {
-                    result.push(TraitConstraint { typ:constraint.typ.clone(), trait_bound:bound } );
+                    result
+                        .push(TraitConstraint { typ: constraint.typ.clone(), trait_bound: bound });
                 }
             }
             result
         })
 }
 
 fn trait_bounds() -> impl NoirParser<Vec<TraitBound>> {
-    trait_bound()
-        .separated_by(just(Token::Plus))
-        .at_least(1)
-        .allow_trailing()
+    trait_bound().separated_by(just(Token::Plus)).at_least(1).allow_trailing()
 }
 
 fn trait_bound() -> impl NoirParser<TraitBound> {