minor refactor

zokrates_analysis/src/flatten_complex_types.rs

@@ -455,8 +455,7 @@ fn fold_assembly_statement<'ast, T: Field>(
             let mut statements_buffer: Vec<zir::ZirStatement<'ast, T>> = statements_buffer
                 .into_iter()
                 .rev()
-                .map(|s| finder.fold_statement(s))
+                .flat_map(|s| finder.fold_statement(s))
-                .flatten()
                 .collect();
             statements_buffer.reverse();
 

zokrates_ast/src/common/solvers.rs

@@ -23,7 +23,7 @@ pub enum Solver<'ast, T> {
 impl<'ast, T: fmt::Debug + fmt::Display> fmt::Display for Solver<'ast, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Solver::Zir(func) => write!(f, "Zir({})", "ignored"),
+            Solver::Zir(_) => write!(f, "Zir(ignored)"),
             _ => write!(f, "{:?}", self),
         }
     }

zokrates_ast/src/typed/mod.rs

@@ -1334,11 +1334,10 @@ impl<'ast, T> FieldElementExpression<'ast, T> {
             FieldElementExpression::Sub(box left, box right) => {
                 left.is_linear() && right.is_linear()
             }
-            FieldElementExpression::Mult(box left, box right) => match (left, right) {
+            FieldElementExpression::Mult(box left, box right) => matches!(
-                (FieldElementExpression::Number(_), _) => true,
+                (left, right),
-                (_, FieldElementExpression::Number(_)) => true,
+                (FieldElementExpression::Number(_), _) | (_, FieldElementExpression::Number(_))
-                _ => false,
+            ),
-            },
             FieldElementExpression::Div(_, _) => false,
             FieldElementExpression::Pow(_, _) => false,
             FieldElementExpression::Conditional(_) => false,

zokrates_ast/src/zir/mod.rs

@@ -209,7 +209,7 @@ impl<'ast, T: fmt::Display> ZirStatement<'ast, T> {
         match self {
             ZirStatement::Return(ref exprs) => {
                 write!(f, "return")?;
-                if exprs.len() > 0 {
+                if !exprs.is_empty() {
                     write!(
                         f,
                         " {}",

zokrates_codegen/src/lib.rs

@@ -1579,8 +1579,6 @@ impl<'ast, T: Field> Flattener<'ast, T> {
                 let left_metadata = left.metadata.clone().unwrap();
                 let right_metadata = right.metadata.clone().unwrap();
 
-                println!("left {}, right {}", left, right);
-
                 match (left.into_inner(), right.into_inner()) {
                     (UExpressionInner::And(box a, box b), UExpressionInner::And(box aa, box c)) => {
                         if aa.clone().into_inner() == UExpressionInner::Not(box a.clone()) {

zokrates_core/src/optimizer/directive.rs

@@ -14,9 +14,11 @@ use zokrates_ast::ir::folder::*;
 use zokrates_ast::ir::*;
 use zokrates_field::Field;
 
+type SolverCall<'ast, T> = (Solver<'ast, T>, Vec<QuadComb<T>>);
+
 #[derive(Debug, Default)]
 pub struct DirectiveOptimizer<'ast, T> {
-    calls: HashMap<(Solver<'ast, T>, Vec<QuadComb<T>>), Vec<Variable>>,
+    calls: HashMap<SolverCall<'ast, T>, Vec<Variable>>,
     /// Map of renamings for reassigned variables while processing the program.
     substitution: HashMap<Variable, Variable>,
 }

zokrates_core/src/semantics.rs

@@ -1791,7 +1791,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
 
                 let e = match checked_e {
                     TypedExpression::FieldElement(e) => Ok(e),
-                    TypedExpression::Int(e) => Ok(FieldElementExpression::try_from_int(e).unwrap()), // todo: handle properly
+                    TypedExpression::Int(e) => Ok(FieldElementExpression::try_from_int(e).unwrap()),
                     _ => Err(ErrorInner {
                         pos: Some(pos),
                         message: "Only field element expressions are allowed in the assembly"
@@ -3718,7 +3718,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
             ty,
             is_mutable,
         };
-        self.scope.insert(id.into(), info)
+        self.scope.insert(id, info)
     }
 
     fn find_functions(

zokrates_interpreter/src/lib.rs

@@ -82,7 +82,7 @@ impl Interpreter {
                         }
                         _ => Self::execute_solver(&d.solver, &inputs),
                     }
-                    .map_err(|e| Error::Solver(e))?;
+                    .map_err(Error::Solver)?;
 
                     for (i, o) in d.outputs.iter().enumerate() {
                         witness.insert(*o, res[i].clone());
@@ -193,8 +193,8 @@ impl Interpreter {
                     .fold_function(func.clone())
                     .map_err(|e| e.to_string())?;
 
-                assert!(folded_function.statements.len() == 1);
+                assert_eq!(folded_function.statements.len(), 1);
-                let res = if let zokrates_ast::zir::ZirStatement::Return(v) =
+                if let zokrates_ast::zir::ZirStatement::Return(v) =
                     folded_function.statements[0].clone()
                 {
                     v.into_iter()
@@ -207,9 +207,7 @@ impl Interpreter {
                         .collect()
                 } else {
                     unreachable!()
-                };
+                }
-
-                res
             }
             Solver::ConditionEq => match inputs[0].is_zero() {
                 true => vec![T::zero(), T::one()],

zokrates_js/index.d.ts

@@ -60,7 +60,7 @@ declare module "zokrates-js" {
     snarkjs?: {
       program: Uint8Array;
     };
-    constraint_count: number;
+    constraintCount?: number;
   }
 
   export interface SetupKeypair {

zokrates_js/lib.js

@@ -16,7 +16,7 @@ module.exports = (pkg) => {
         {
           program: ptr.program(),
           abi: ptr.abi(),
-          constraint_count: ptr.constraint_count(),
+          constraintCount: ptr.constraint_count(),
         },
         snarkjs ? { snarkjs: { program: ptr.snarkjs_program() } } : {},
       );

zokrates_js/package.json

@@ -32,9 +32,9 @@
     "prebuild": "npm install",
     "build": "npm run build:bundler && npm run build:node",
     "build:dev": "npm run build:bundler:dev && npm run build:node:dev",
-    "build:bundler": "rimraf pkg && npm run wasm-pack -- --target bundler && npm run clean-pkg",
+    "build:bundler": "rimraf pkg && npm run wasm-pack -- --target bundler --release && npm run clean-pkg",
     "build:bundler:dev": "rimraf pkg && npm run wasm-pack -- --target bundler --dev && npm run clean-pkg",
-    "build:node": "rimraf node/pkg && npm run wasm-pack -- --target nodejs -d node/pkg && npm run clean-node-pkg",
+    "build:node": "rimraf node/pkg && npm run wasm-pack -- --target nodejs -d node/pkg --release && npm run clean-node-pkg",
     "build:node:dev": "rimraf node/pkg && npm run wasm-pack -- --target nodejs -d node/pkg --dev && npm run clean-node-pkg",
     "clean-pkg": "rimraf pkg/README.md pkg/.gitignore pkg/package.json pkg/*.d.ts",
     "clean-node-pkg": "rimraf node/pkg/README.md node/pkg/.gitignore node/pkg/package.json node/pkg/*.d.ts",

zokrates_js/tests/tests.js

@@ -44,6 +44,7 @@ describe("tests", () => {
         );
         assert.ok(artifacts);
         assert.ok(artifacts.snarkjs === undefined);
+        assert.eq(artifacts.constraintCount === 1);
       });
     });
 

zokrates_proof_systems/src/lib.rs

@@ -126,7 +126,7 @@ pub trait MpcBackend<T: Field, S: Scheme<T>> {
         output: &mut W,
     ) -> Result<(), String>;
 
-    fn contribute<'a, R: Read, W: Write, G: Rng>(
+    fn contribute<R: Read, W: Write, G: Rng>(
         params: &mut R,
         rng: &mut G,
         output: &mut W,