Introduce compilation mode

changelogs/unreleased/988-schaeff

@@ -0,0 +1 @@
+Introduce a check mode flag `--mode` and stop requiring a main function in `lib` mode

zokrates_cli/examples/compile_errors/two_entry_points.zok

@@ -0,0 +1,5 @@
+def main():
+    return
+
+def main(field a):
+    return

zokrates_cli/src/bin.rs

@@ -115,7 +115,7 @@ mod tests {
     use std::fs::File;
     use std::io::{BufReader, Read};
     use std::string::String;
-    use zokrates_core::compile::{compile, CompilationArtifacts, CompileConfig};
+    use zokrates_core::compile::{compile, BinCompilationArtifacts, CompileConfig};
     use zokrates_core::ir;
     use zokrates_field::Bn128Field;
     use zokrates_fs_resolver::FileSystemResolver;
@@ -189,7 +189,7 @@ mod tests {
             let stdlib = std::fs::canonicalize("../zokrates_stdlib/stdlib").unwrap();
             let resolver = FileSystemResolver::with_stdlib_root(stdlib.to_str().unwrap());
 
-            let artifacts: CompilationArtifacts<Bn128Field> =
+            let artifacts: BinCompilationArtifacts<ir::Prog<Bn128Field>> =
                 compile(source, path, Some(&resolver), &CompileConfig::default()).unwrap();
 
             let interpreter = ir::Interpreter::default();
@@ -221,7 +221,7 @@ mod tests {
             let stdlib = std::fs::canonicalize("../zokrates_stdlib/stdlib").unwrap();
             let resolver = FileSystemResolver::with_stdlib_root(stdlib.to_str().unwrap());
 
-            let artifacts: CompilationArtifacts<Bn128Field> =
+            let artifacts: BinCompilationArtifacts<ir::Prog<Bn128Field>> =
                 compile(source, path, Some(&resolver), &CompileConfig::default()).unwrap();
 
             let interpreter = ir::Interpreter::default();

zokrates_cli/src/constants.rs

@@ -9,6 +9,10 @@ pub const UNIVERSAL_SETUP_DEFAULT_PATH: &str = "universal_setup.dat";
 pub const UNIVERSAL_SETUP_DEFAULT_SIZE: &str = "10";
 pub const SMTLIB2_DEFAULT_PATH: &str = "out.smt2";
 
+pub const COMPILATION_MODE_BIN: &str = "bin";
+pub const COMPILATION_MODE_LIB: &str = "lib";
+pub const COMPILATION_MODES: &[&str] = &[COMPILATION_MODE_BIN, COMPILATION_MODE_LIB];
+
 pub const BELLMAN: &str = "bellman";
 pub const LIBSNARK: &str = "libsnark";
 pub const ARK: &str = "ark";

zokrates_cli/src/ops/check.rs

@@ -5,7 +5,7 @@ use std::convert::TryFrom;
 use std::fs::File;
 use std::io::{BufReader, Read};
 use std::path::{Path, PathBuf};
-use zokrates_core::compile::{check, CompileConfig, CompileError};
+use zokrates_core::compile::{check, CompileConfig, CompileError, CompileMode};
 use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field};
 use zokrates_fs_resolver::FileSystemResolver;
 
@@ -46,6 +46,13 @@ pub fn subcommand() -> App<'static, 'static> {
             .help("Isolate the execution of branches: a panic in a branch only makes the program panic if this branch is being logically executed")
             .required(false)
         )
+        .arg(Arg::with_name("mode")
+            .long("mode")
+            .help("In which mode the compiler should be run")
+            .possible_values(constants::COMPILATION_MODES)
+            .required(false)
+            .default_value(constants::COMPILATION_MODE_BIN)
+    )
 }
 
 pub fn exec(sub_matches: &ArgMatches) -> Result<(), String> {
@@ -89,8 +96,15 @@ fn cli_check<T: Field>(sub_matches: &ArgMatches) -> Result<(), String> {
         )),
     }?;
 
-    let config =
-        CompileConfig::default().isolate_branches(sub_matches.is_present("isolate-branches"));
+    let mode = match sub_matches.value_of("mode").unwrap() {
+        constants::COMPILATION_MODE_BIN => CompileMode::Bin,
+        constants::COMPILATION_MODE_LIB => CompileMode::Lib,
+        _ => unreachable!(),
+    };
+
+    let config = CompileConfig::default()
+        .isolate_branches(sub_matches.is_present("isolate-branches"))
+        .mode(mode);
 
     let resolver = FileSystemResolver::with_stdlib_root(stdlib_path);
     let _ = check::<T, _>(source, path, Some(&resolver), &config).map_err(|e| {

zokrates_cli/src/ops/compile.rs

@@ -6,7 +6,10 @@ use std::convert::TryFrom;
 use std::fs::File;
 use std::io::{BufReader, BufWriter, Read, Write};
 use std::path::{Path, PathBuf};
-use zokrates_core::compile::{compile, CompilationArtifacts, CompileConfig, CompileError};
+use zokrates_core::{
+    compile::{compile, BinCompilationArtifacts, CompileConfig, CompileError, CompileMode},
+    ir::Prog,
+};
 use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field};
 use zokrates_fs_resolver::FileSystemResolver;
 
@@ -130,14 +133,15 @@ fn cli_compile<T: Field>(sub_matches: &ArgMatches) -> Result<(), String> {
 
     let config = CompileConfig::default()
         .allow_unconstrained_variables(sub_matches.is_present("allow-unconstrained-variables"))
-        .isolate_branches(sub_matches.is_present("isolate-branches"));
+        .isolate_branches(sub_matches.is_present("isolate-branches"))
+        .mode(CompileMode::Bin);
 
     let resolver = FileSystemResolver::with_stdlib_root(stdlib_path);
 
     log::debug!("Compile");
 
-    let artifacts: CompilationArtifacts<T> = compile(source, path, Some(&resolver), &config)
-        .map_err(|e| {
+    let artifacts: BinCompilationArtifacts<Prog<T>> =
+        compile(source, path, Some(&resolver), &config).map_err(|e| {
             format!(
                 "Compilation failed:\n\n{}",
                 e.0.iter()

zokrates_core/src/compile.rs

@@ -25,13 +25,19 @@ use zokrates_field::Field;
 use zokrates_pest_ast as pest;
 
 #[derive(Debug)]
-pub struct CompilationArtifacts<T: Field> {
-    prog: ir::Prog<T>,
+pub struct BinCompilationArtifacts<P> {
+    prog: P,
     abi: Abi,
 }
 
-impl<T: Field> CompilationArtifacts<T> {
-    pub fn prog(&self) -> &ir::Prog<T> {
+#[derive(Debug)]
+pub enum CompilationArtifacts<P> {
+    Bin(BinCompilationArtifacts<P>),
+    Lib,
+}
+
+impl<P> BinCompilationArtifacts<P> {
+    pub fn prog(&self) -> &P {
         &self.prog
     }
 
@@ -162,9 +168,25 @@ impl fmt::Display for CompileErrorInner {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
+pub enum CompileMode {
+    Bin,
+    Lib,
+}
+
+impl Default for CompileMode {
+    fn default() -> Self {
+        Self::Bin
+    }
+}
+
 #[derive(Debug, Default, Serialize, Deserialize, Clone)]
 pub struct CompileConfig {
+    #[serde(default)]
+    pub mode: CompileMode,
+    #[serde(default)]
     pub allow_unconstrained_variables: bool,
+    #[serde(default)]
     pub isolate_branches: bool,
 }
 
@@ -177,6 +199,10 @@ impl CompileConfig {
         self.isolate_branches = flag;
         self
     }
+    pub fn mode(mut self, mode: CompileMode) -> Self {
+        self.mode = mode;
+        self
+    }
 }
 
 type FilePath = PathBuf;
@@ -186,37 +212,42 @@ pub fn compile<T: Field, E: Into<imports::Error>>(
     location: FilePath,
     resolver: Option<&dyn Resolver<E>>,
     config: &CompileConfig,
-) -> Result<CompilationArtifacts<T>, CompileErrors> {
+) -> Result<BinCompilationArtifacts<ir::Prog<T>>, CompileErrors> {
     let arena = Arena::new();
 
-    let (typed_ast, abi) = check_with_arena(source, location.clone(), resolver, config, &arena)?;
-
-    // flatten input program
-    log::debug!("Flatten");
-    let program_flattened = Flattener::flatten(typed_ast, config);
-
-    // constant propagation after call resolution
-    log::debug!("Propagate flat program");
-    let program_flattened = program_flattened.propagate();
-
-    // convert to ir
-    log::debug!("Convert to IR");
-    let ir_prog = ir::Prog::from(program_flattened);
-
-    // optimize
-    log::debug!("Optimise IR");
-    let optimized_ir_prog = ir_prog.optimize();
-
-    // analyse ir (check constraints)
-    log::debug!("Analyse IR");
-    let optimized_ir_prog = optimized_ir_prog
-        .analyse()
-        .map_err(|e| CompileErrorInner::from(e).in_file(location.as_path()))?;
-
-    Ok(CompilationArtifacts {
-        prog: optimized_ir_prog,
-        abi,
-    })
+    let artifacts = check_with_arena(source, location.clone(), resolver, config, &arena)?;
+
+    match artifacts {
+        CompilationArtifacts::Lib => unreachable!(),
+        CompilationArtifacts::Bin(artifacts) => {
+            // flatten input program
+            log::debug!("Flatten");
+            let program_flattened = Flattener::flatten(artifacts.prog, config);
+
+            // constant propagation after call resolution
+            log::debug!("Propagate flat program");
+            let program_flattened = program_flattened.propagate();
+
+            // convert to ir
+            log::debug!("Convert to IR");
+            let ir_prog = ir::Prog::from(program_flattened);
+
+            // optimize
+            log::debug!("Optimise IR");
+            let optimized_ir_prog = ir_prog.optimize();
+
+            // analyse ir (check constraints)
+            log::debug!("Analyse IR");
+            let optimized_ir_prog = optimized_ir_prog
+                .analyse()
+                .map_err(|e| CompileErrorInner::from(e).in_file(location.as_path()))?;
+
+            Ok(BinCompilationArtifacts {
+                prog: optimized_ir_prog,
+                abi: artifacts.abi,
+            })
+        }
+    }
 }
 
 pub fn check<T: Field, E: Into<imports::Error>>(
@@ -236,7 +267,7 @@ fn check_with_arena<'ast, T: Field, E: Into<imports::Error>>(
     resolver: Option<&dyn Resolver<E>>,
     config: &CompileConfig,
     arena: &'ast Arena<String>,
-) -> Result<(ZirProgram<'ast, T>, Abi), CompileErrors> {
+) -> Result<CompilationArtifacts<ZirProgram<'ast, T>>, CompileErrors> {
     let source = arena.alloc(source);
 
     log::debug!("Parse program with entry file {}", location.display());
@@ -246,17 +277,27 @@ fn check_with_arena<'ast, T: Field, E: Into<imports::Error>>(
     log::debug!("Check semantics");
 
     // check semantics
-    let typed_ast = Checker::check(compiled)
+    let typed_ast = Checker::check(compiled, config.mode)
         .map_err(|errors| CompileErrors(errors.into_iter().map(CompileError::from).collect()))?;
 
-    let main_module = typed_ast.main.clone();
+    match config.mode {
+        CompileMode::Bin => {
+            let main_module = typed_ast.main.clone();
+
+            log::debug!("Run static analysis");
 
-    log::debug!("Run static analysis");
+            // analyse (unroll and constant propagation)
+            let (prog, abi) = typed_ast.analyse(config).map_err(|e| {
+                CompileErrors(vec![CompileErrorInner::from(e).in_file(&main_module)])
+            })?;
 
-    // analyse (unroll and constant propagation)
-    typed_ast
-        .analyse(config)
-        .map_err(|e| CompileErrors(vec![CompileErrorInner::from(e).in_file(&main_module)]))
+            Ok(CompilationArtifacts::Bin(BinCompilationArtifacts {
+                prog,
+                abi,
+            }))
+        }
+        CompileMode::Lib => Ok(CompilationArtifacts::Lib),
+    }
 }
 
 pub fn parse_program<'ast, T: Field, E: Into<imports::Error>>(
@@ -322,7 +363,7 @@ mod test {
 			   return foo()
 		"#
         .to_string();
-        let res: Result<CompilationArtifacts<Bn128Field>, CompileErrors> = compile(
+        let res: Result<BinCompilationArtifacts<ir::Prog<Bn128Field>>, CompileErrors> = compile(
             source,
             "./path/to/file".into(),
             None::<&dyn Resolver<io::Error>>,
@@ -341,7 +382,7 @@ mod test {
 			   return 1
 		"#
         .to_string();
-        let res: Result<CompilationArtifacts<Bn128Field>, CompileErrors> = compile(
+        let res: Result<BinCompilationArtifacts<ir::Prog<Bn128Field>>, CompileErrors> = compile(
             source,
             "./path/to/file".into(),
             None::<&dyn Resolver<io::Error>>,