chore: Run cargo fmt (#2455)

noir-lang · Aug 28, 2023 · b1ccd71 · b1ccd71
1 parent 168e0db
commit b1ccd71
Show file tree

Hide file tree

Showing 4 changed files with 26 additions and 9 deletions.
diff --git a/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/crates/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -207,7 +207,12 @@ impl<'a> FunctionContext<'a> {
                 let rhs = rhs.into_leaf().eval(self);
                 let typ = self.builder.type_of_value(rhs);
                 let zero = self.builder.numeric_constant(0u128, typ);
-                self.insert_binary(zero, noirc_frontend::BinaryOpKind::Subtract, rhs, unary.location)
+                self.insert_binary(
+                    zero,
+                    noirc_frontend::BinaryOpKind::Subtract,
+                    rhs,
+                    unary.location,
+                )
             }
             noirc_frontend::UnaryOp::MutableReference => {
                 self.codegen_reference(&unary.rhs).map(|rhs| {

diff --git a/crates/noirc_frontend/src/hir/resolution/resolver.rs b/crates/noirc_frontend/src/hir/resolution/resolver.rs
@@ -700,8 +700,7 @@ impl<'a> Resolver<'a> {
             self.push_err(ResolverError::DistinctNotAllowed { ident: func.name_ident().clone() });
         }
 
-        if matches!(attributes, Some(Attribute::Test { .. })) && !parameters.is_empty()
-        {
+        if matches!(attributes, Some(Attribute::Test { .. })) && !parameters.is_empty() {
             self.push_err(ResolverError::TestFunctionHasParameters {
                 span: func.name_ident().span(),
             });

diff --git a/crates/noirc_frontend/src/hir/type_check/expr.rs b/crates/noirc_frontend/src/hir/type_check/expr.rs
@@ -343,7 +343,11 @@ impl<'interner> TypeChecker<'interner> {
                                 rhs: method_call.object,
                             }));
                         self.interner.push_expr_type(&method_call.object, new_type);
-                        self.interner.push_expr_location(method_call.object, location.span, location.file);
+                        self.interner.push_expr_location(
+                            method_call.object,
+                            location.span,
+                            location.file,
+                        );
                     }
                 }
             }

diff --git a/crates/noirc_frontend/src/monomorphization/mod.rs b/crates/noirc_frontend/src/monomorphization/mod.rs
@@ -1187,7 +1187,11 @@ impl<'interner> Monomorphizer<'interner> {
     /// Implements std::unsafe::zeroed by returning an appropriate zeroed
     /// ast literal or collection node for the given type. Note that for functions
     /// there is no obvious zeroed value so this should be considered unsafe to use.
-    fn zeroed_value_of_type(&mut self, typ: &ast::Type, location: noirc_errors::Location) -> ast::Expression {
+    fn zeroed_value_of_type(
+        &mut self,
+        typ: &ast::Type,
+        location: noirc_errors::Location,
+    ) -> ast::Expression {
         match typ {
             ast::Type::Field | ast::Type::Integer(..) => {
                 ast::Expression::Literal(ast::Literal::Integer(0_u128.into(), typ.clone()))
@@ -1218,9 +1222,9 @@ impl<'interner> Monomorphizer<'interner> {
                     Box::new(zeroed_tuple),
                 ))
             }
-            ast::Type::Tuple(fields) => {
-                ast::Expression::Tuple(vecmap(fields, |field| self.zeroed_value_of_type(field, location)))
-            }
+            ast::Type::Tuple(fields) => ast::Expression::Tuple(vecmap(fields, |field| {
+                self.zeroed_value_of_type(field, location)
+            })),
             ast::Type::Function(parameter_types, ret_type, env) => {
                 self.create_zeroed_function(parameter_types, ret_type, env, location)
             }
@@ -1234,7 +1238,12 @@ impl<'interner> Monomorphizer<'interner> {
                 use crate::UnaryOp::MutableReference;
                 let rhs = Box::new(self.zeroed_value_of_type(element, location));
                 let result_type = typ.clone();
-                ast::Expression::Unary(ast::Unary { rhs, result_type, operator: MutableReference, location })
+                ast::Expression::Unary(ast::Unary {
+                    rhs,
+                    result_type,
+                    operator: MutableReference,
+                    location,
+                })
             }
         }
     }