Add check for unused/unconstrained parameters

zokrates_core/src/compile.rs

@@ -164,6 +164,9 @@ pub fn compile<T: Field, E: Into<imports::Error>>(
     // optimize
     let optimized_ir_prog = ir_prog.optimize();
 
+    // analyse (check for unused constraints)
+    let optimized_ir_prog = optimized_ir_prog.analyse();
+
     Ok(CompilationArtifacts {
         prog: optimized_ir_prog,
         abi,

zokrates_core/src/static_analysis/constraint_analyser.rs

@@ -0,0 +1,44 @@
+use crate::ir::{Prog, Statement};
+use flat_absy::{FlatParameter, FlatVariable};
+use zokrates_field::field::Field;
+
+pub struct ConstraintAnalyser;
+
+impl ConstraintAnalyser {
+    pub fn analyse<T: Field>(p: Prog<T>) -> Prog<T> {
+        Self::check_unconstrained_variables(p.parameters(), &p.main.statements);
+        p
+    }
+
+    fn check_unconstrained_variables<T: Field>(
+        parameters: Vec<FlatParameter>,
+        statements: &Vec<Statement<T>>,
+    ) {
+        let mut variables: Vec<FlatVariable> = parameters
+            .iter()
+            .filter(|fp| fp.private) // we care only about private parameters
+            .map(|fp| fp.id)
+            .collect();
+
+        for s in statements {
+            match s {
+                Statement::Constraint(quad, _) => {
+                    let quad_left: Vec<FlatVariable> = quad.left.0.iter().map(|l| l.0).collect();
+                    let quad_right: Vec<FlatVariable> = quad.right.0.iter().map(|l| l.0).collect();
+
+                    variables.retain(|e| !(quad_left.contains(e) || quad_right.contains(e)));
+                }
+                _ => {}
+            }
+        }
+
+        // we should handle this error instead of asserting?
+        assert!(
+            variables.is_empty(),
+            format!(
+                "Unconstrained private parameters are not allowed (found {})",
+                variables.len()
+            )
+        );
+    }
+}

zokrates_core/src/static_analysis/mod.rs

@@ -5,6 +5,7 @@
 //! @date 2018
 
 mod constrain_inputs;
+mod constraint_analyser;
 mod flat_propagation;
 mod inline;
 mod propagate_unroll;
@@ -12,11 +13,13 @@ mod propagation;
 mod unroll;
 
 use self::constrain_inputs::InputConstrainer;
+use self::constraint_analyser::ConstraintAnalyser;
 use self::inline::Inliner;
 use self::propagate_unroll::PropagatedUnroller;
 use self::propagation::Propagator;
 use crate::flat_absy::FlatProg;
 use crate::typed_absy::TypedProgram;
+use ir::Prog;
 use zokrates_field::field::Field;
 
 pub trait Analyse {
@@ -43,3 +46,10 @@ impl<T: Field> Analyse for FlatProg<T> {
         self.propagate()
     }
 }
+
+impl<T: Field> Analyse for Prog<T> {
+    fn analyse(self) -> Self {
+        let r = ConstraintAnalyser::analyse(self);
+        r
+    }
+}