Make polonius_souffle an optional dependency

Author: ecstatic-morse

Cargo.toml

@@ -16,7 +16,7 @@ polonius-parser = { path = "./polonius-parser" }
 [dependencies]
 rustc-hash = "1.0.0"
 polonius-engine = { path = "polonius-engine" }
-polonius-souffle = { path = "polonius-souffle" }
+polonius-souffle = { path = "polonius-souffle", optional = true }
 log = "0.4"
 petgraph = "0.4.13"
 pico-args = "0.2"

polonius-engine/Cargo.toml

@@ -11,6 +11,6 @@ keywords = ["compiler", "borrowck", "datalog"]
 [dependencies]
 datafrog = "2.0.0"
 polonius-facts = { path = "../polonius-facts" }
-polonius-souffle = { path = "../polonius-souffle" }
+polonius-souffle = { path = "../polonius-souffle", optional = true }
 rustc-hash = "1.0.0"
 log = "0.4"

polonius-engine/src/output/mod.rs

@@ -187,6 +187,12 @@ impl<T: FactTypes> Output<T> {
     ///   partial results can also be stored in the context, so that the following
     ///   variant can use it to prune its own input data
     pub fn compute(all_facts: &AllFacts<T>, algorithm: Algorithm, dump_enabled: bool) -> Self {
+        #[cfg(not(feature = "polonius-souffle"))]
+        if algorithm.engine() == Engine::Souffle {
+            panic!("Polonius built without `--feature polonius-souffle`")
+        }
+
+        #[cfg(feature = "polonius-souffle")]
         if algorithm.engine() == Engine::Souffle {
             let name = algorithm
                 .souffle_name()

src/cli.rs

@@ -4,13 +4,14 @@ use polonius_engine::{Algorithm, Engine};
 use std::env;
 use std::error;
 use std::fmt;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::exit;
 use std::str::FromStr;
 use std::time::{Duration, Instant};
 
 use crate::dump;
 use crate::dump::Output;
+use crate::facts::AllFacts;
 use crate::intern;
 use crate::tab_delim;
 
@@ -77,16 +78,9 @@ pub fn main(opt: Options) -> Result<(), Error> {
                 .souffle_name()
                 .expect("Algorithm does not have Soufflé version");
 
-            // FIXME This time includes loading/unloading tuples across the FFI boundary.
-            let (duration, output) = timed(|| polonius_souffle::run_from_facts(name, &all_facts));
-            if !opt.skip_timing {
-                let seconds = duration.as_secs() as f64;
-                let millis = f64::from(duration.subsec_nanos()) * 0.000_000_001_f64;
-                println!("Time: {:0.3}s", seconds + millis);
-            }
-            if opt.show_tuples {
-                dump::dump_souffle_output(&output, &output_directory, tables, opt.verbose)
-                    .expect("Failed to write output");
+            if let Err(e) = run_polonius_souffle(&all_facts, &output_directory, tables, name, &opt)
+            {
+                error!("`{}`: {}", facts_dir, e);
             }
 
             continue;
@@ -115,6 +109,41 @@ pub fn main(opt: Options) -> Result<(), Error> {
     Ok(())
 }
 
+#[cfg(feature = "polonius-souffle")]
+fn run_polonius_souffle(
+    all_facts: &AllFacts,
+    output_directory: &Option<PathBuf>,
+    tables: &intern::InternerTables,
+    souffle_name: &str,
+    opt: &Options,
+) -> Result<(), Error> {
+    // FIXME This time includes loading/unloading tuples across the FFI boundary.
+    let (duration, output) = timed(|| polonius_souffle::run_from_facts(souffle_name, &all_facts));
+    if !opt.skip_timing {
+        let seconds = duration.as_secs() as f64;
+        let millis = f64::from(duration.subsec_nanos()) * 0.000_000_001_f64;
+        println!("Time: {:0.3}s", seconds + millis);
+    }
+    if opt.show_tuples {
+        dump::dump_souffle_output(&output, &output_directory, tables, opt.verbose)
+            .expect("Failed to write output");
+    }
+    Ok(())
+}
+
+#[cfg(not(feature = "polonius-souffle"))]
+fn run_polonius_souffle(
+    _: &AllFacts,
+    _: &Option<PathBuf>,
+    _: &intern::InternerTables,
+    _: &str,
+    _: &Options,
+) -> Result<(), Error> {
+    Err(Error(
+        "`polonius` was compiled without Soufflé backend (`--feature polonius-souffle`)".into(),
+    ))
+}
+
 fn timed<T>(op: impl FnOnce() -> T) -> (Duration, T) {
     let start = Instant::now();
     let output = op();

src/dump.rs

@@ -15,6 +15,7 @@ use std::path::PathBuf;
 
 pub(crate) type Output = PoloniusEngineOutput<LocalFacts>;
 
+#[cfg(feature = "polonius-souffle")]
 pub(crate) fn dump_souffle_output(
     output: &HashMap<String, polonius_souffle::DynTuples>,
     output_dir: &Option<PathBuf>,