Tigher visibility conditions for Lurk (#900)

* fix: make z_data::serde private

* refactor: restrict visibility of CLI backend/config

* make circuit::data pub(crate)

* refactor: make gadgets from #849 explicitly unused

* make interpreter pub(crate)

* refactor: make top-level  expr, cont, hash, package private

* refactor: make ptr pub(crate)

* refactor: make symbol crate-private

* refactor: make syntax crate-private

* refactor: make tag crate-private

* refactor: make uint crate-private

* refactor: make writer crate-private

* refactor: limit visibility in public_params

* refactor: Refactor variant naming in public parameters module

- Renamed `Error::IOError` to `Error::IO` and `Error::CacheError` to `Error::Cache` across multiple files for consistency.

* fix: repair doctest

src/circuit/gadgets/constraints.rs

@@ -404,6 +404,7 @@ pub(crate) fn pick_const<F: PrimeField, CS: ConstraintSystem<F>>(
 }
 
 /// Convert from Boolean to AllocatedNum.
+#[allow(dead_code)]
 pub(crate) fn boolean_to_num<F: PrimeField, CS: ConstraintSystem<F>>(
     mut cs: CS,
     bit: &Boolean,

src/circuit/gadgets/data.rs

@@ -286,7 +286,7 @@ pub(crate) fn hash_poseidon<CS: ConstraintSystem<F>, F: LurkField, A: Arity<F>>(
     }
 }
 
-pub fn allocate_constant<F: LurkField, CS: ConstraintSystem<F>>(
+pub(crate) fn allocate_constant<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     val: F,
 ) -> AllocatedNum<F> {

src/circuit/gadgets/mod.rs

@@ -4,6 +4,6 @@ pub(crate) mod macros;
 pub(crate) mod case;
 pub mod circom;
 pub mod constraints;
-pub mod data;
+pub(crate) mod data;
 pub(crate) mod hashes;
 pub mod pointer;

src/cli/backend.rs

@@ -5,7 +5,7 @@ use serde::Deserialize;
 use crate::field::LanguageField;
 
 #[derive(Clone, Default, Debug, Deserialize, ValueEnum, PartialEq, Eq)]
-pub enum Backend {
+pub(crate) enum Backend {
     #[default]
     Nova,
 }

src/cli/config.rs

@@ -13,7 +13,7 @@ use super::backend::Backend;
 use super::paths::{circom_default_dir, commits_default_dir, proofs_default_dir};
 
 /// Global config varable for `CliSettings`
-pub static CLI_CONFIG: OnceCell<CliSettings> = OnceCell::new();
+pub(crate) static CLI_CONFIG: OnceCell<CliSettings> = OnceCell::new();
 
 /// Gets the `CLI_CONFIG` settings. If uninitialized, sets the global variable
 /// in the following order (greatest to least precedence):
@@ -27,7 +27,7 @@ pub static CLI_CONFIG: OnceCell<CliSettings> = OnceCell::new();
 ///   ```
 ///   Other file formats are supported by the `config` crate, but only TOML is tested
 /// - Default values, e.g. `$HOME/.lurk/proofs`
-pub fn cli_config(
+pub(crate) fn cli_config(
     config_file: Option<&Utf8PathBuf>,
     settings: Option<&HashMap<&str, String>>,
 ) -> &'static CliSettings {
@@ -44,27 +44,27 @@ pub fn cli_config(
 // It's good practice to avoid duplication of shared settings like `public_params_dir`
 // in downstream configs like these to prevent conflicts.
 #[derive(Debug, Deserialize)]
-pub struct CliSettings {
+pub(crate) struct CliSettings {
     /// Cache directory for proofs
-    pub proofs_dir: Utf8PathBuf,
+    pub(crate) proofs_dir: Utf8PathBuf,
     /// Cache directory for commitments
-    pub commits_dir: Utf8PathBuf,
+    pub(crate) commits_dir: Utf8PathBuf,
     /// Cache directory for Circom files
-    pub circom_dir: Utf8PathBuf,
+    pub(crate) circom_dir: Utf8PathBuf,
     /// Proof generation and verification system
-    pub backend: Backend,
+    pub(crate) backend: Backend,
     /// Finite field used for evaluation and proving
-    pub field: LanguageField,
+    pub(crate) field: LanguageField,
     /// Reduction count, which is the number of circuit reductions per step
-    pub rc: usize,
+    pub(crate) rc: usize,
     /// Iteration limit for the program, which is arbitrary to user preferences
     /// Used mainly as a safety check, similar to default stack size
-    pub limit: usize,
+    pub(crate) limit: usize,
 }
 
 impl CliSettings {
     /// Loads config settings from a file or env var, or CLI arg if applicable
-    pub fn from_config(
+    pub(crate) fn from_config(
         config_file: &Utf8PathBuf,
         cli_settings: Option<&HashMap<&str, String>>,
     ) -> Result<Self, ConfigError> {

src/cli/mod.rs

@@ -1,11 +1,11 @@
-pub mod backend;
+mod backend;
 mod circom;
 mod commitment;
-pub mod config;
+mod config;
 mod field_data;
 mod lurk_proof;
 pub mod paths;
-pub mod repl;
+mod repl;
 mod zstore;
 
 use anyhow::{bail, Context, Result};

src/cli/repl/mod.rs

@@ -70,7 +70,7 @@ impl<F: LurkField> Evaluation<F> {
 }
 
 #[allow(dead_code)]
-pub struct Repl<F: LurkField> {
+pub(crate) struct Repl<F: LurkField> {
     store: Store<F>,
     state: Rc<RefCell<State>>,
     env: Ptr<F>,
@@ -144,7 +144,7 @@ impl<F: LurkField> Repl<F> {
 type F = pasta_curves::pallas::Scalar; // TODO: generalize this
 
 impl Repl<F> {
-    pub fn new(store: Store<F>, rc: usize, limit: usize, backend: Backend) -> Repl<F> {
+    pub(crate) fn new(store: Store<F>, rc: usize, limit: usize, backend: Backend) -> Repl<F> {
         let limit = pad(limit, rc);
         info!(
             "Launching REPL with backend {backend}, field {}, rc {rc} and limit {limit}",
@@ -394,7 +394,7 @@ impl Repl<F> {
         Ok(hash)
     }
 
-    pub fn handle_non_meta(&mut self, expr_ptr: Ptr<F>) -> Result<()> {
+    pub(crate) fn handle_non_meta(&mut self, expr_ptr: Ptr<F>) -> Result<()> {
         let (output, iterations) = self.eval_expr_and_memoize(expr_ptr)?;
         let iterations_display = Self::pretty_iterations_display(iterations);
         match output[2].tag() {
@@ -472,7 +472,7 @@ impl Repl<F> {
         Ok(new_input)
     }
 
-    pub fn load_file(&mut self, file_path: &Utf8Path, demo: bool) -> Result<()> {
+    pub(crate) fn load_file(&mut self, file_path: &Utf8Path, demo: bool) -> Result<()> {
         let input = read_to_string(file_path)?;
         if demo {
             println!("Loading {file_path} in demo mode");

src/coprocessor/gadgets.rs

@@ -18,7 +18,8 @@ use crate::{
 };
 
 /// Constructs an `AllocatedPtr` compound by two others
-pub fn construct_tuple2<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
+#[allow(dead_code)]
+pub(crate) fn construct_tuple2<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
     cs: CS,
     g: &GlobalAllocator<F>,
     store: &Store<F>,
@@ -43,7 +44,8 @@ pub fn construct_tuple2<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
 }
 
 /// Constructs an `AllocatedPtr` compound by three others
-pub fn construct_tuple3<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
+#[allow(dead_code)]
+pub(crate) fn construct_tuple3<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
     cs: CS,
     g: &GlobalAllocator<F>,
     store: &Store<F>,
@@ -71,7 +73,8 @@ pub fn construct_tuple3<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
 }
 
 /// Constructs an `AllocatedPtr` compound by four others
-pub fn construct_tuple4<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
+#[allow(dead_code)]
+pub(crate) fn construct_tuple4<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
     cs: CS,
     g: &GlobalAllocator<F>,
     store: &Store<F>,
@@ -102,8 +105,9 @@ pub fn construct_tuple4<F: LurkField, CS: ConstraintSystem<F>, T: Tag>(
 }
 
 /// Constructs a `Cons` pointer
+#[allow(dead_code)]
 #[inline]
-pub fn construct_cons<F: LurkField, CS: ConstraintSystem<F>>(
+pub(crate) fn construct_cons<F: LurkField, CS: ConstraintSystem<F>>(
     cs: CS,
     g: &GlobalAllocator<F>,
     store: &Store<F>,
@@ -115,7 +119,8 @@ pub fn construct_cons<F: LurkField, CS: ConstraintSystem<F>>(
 
 /// Constructs a cons-list with the provided `elts`. The terminating value defaults
 /// to `nil` when `last` is `None`
-pub fn construct_list<F: LurkField, CS: ConstraintSystem<F>>(
+#[allow(dead_code)]
+pub(crate) fn construct_list<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     g: &GlobalAllocator<F>,
     store: &Store<F>,
@@ -136,6 +141,7 @@ pub fn construct_list<F: LurkField, CS: ConstraintSystem<F>>(
 
 /// Retrieves the `Ptr` that corresponds to `a_ptr` by using the `Store` as the
 /// hint provider
+#[allow(dead_code)]
 fn get_ptr<F: LurkField>(
     a_ptr: &AllocatedPtr<F>,
     store: &Store<F>,
@@ -160,7 +166,8 @@ fn get_ptr<F: LurkField>(
 ///
 /// # Panics
 /// Panics if the store can't deconstruct the tuple pointer
-pub fn deconstruct_tuple2<F: LurkField, CS: ConstraintSystem<F>>(
+#[allow(dead_code)]
+pub(crate) fn deconstruct_tuple2<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     store: &Store<F>,
     not_dummy: &Boolean,
@@ -202,7 +209,8 @@ pub fn deconstruct_tuple2<F: LurkField, CS: ConstraintSystem<F>>(
 ///
 /// # Panics
 /// Panics if the store can't deconstruct the tuple pointer
-pub fn deconstruct_tuple3<F: LurkField, CS: ConstraintSystem<F>>(
+#[allow(dead_code)]
+pub(crate) fn deconstruct_tuple3<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     store: &Store<F>,
     not_dummy: &Boolean,
@@ -247,7 +255,8 @@ pub fn deconstruct_tuple3<F: LurkField, CS: ConstraintSystem<F>>(
 ///
 /// # Panics
 /// Panics if the store can't deconstruct the tuple pointer
-pub fn deconstruct_tuple4<F: LurkField, CS: ConstraintSystem<F>>(
+#[allow(dead_code)]
+pub(crate) fn deconstruct_tuple4<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     store: &Store<F>,
     not_dummy: &Boolean,
@@ -308,7 +317,8 @@ pub fn deconstruct_tuple4<F: LurkField, CS: ConstraintSystem<F>>(
 ///
 /// # Panics
 /// Panics if the store can't deconstruct `data` with `car_cdr`
-pub fn car_cdr<F: LurkField, CS: ConstraintSystem<F>>(
+#[allow(dead_code)]
+pub(crate) fn car_cdr<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     g: &GlobalAllocator<F>,
     store: &Store<F>,
@@ -469,6 +479,7 @@ pub fn car_cdr<F: LurkField, CS: ConstraintSystem<F>>(
 /// assert_eq!(a_ptr_as_z_ptr(&cdr), Some(z_empty_str));
 /// assert_eq!(length.get_value(), Some(Fq::from_u64(2)));
 /// ```
+#[allow(dead_code)]
 pub fn chain_car_cdr<F: LurkField, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     g: &GlobalAllocator<F>,
@@ -500,7 +511,6 @@ pub fn chain_car_cdr<F: LurkField, CS: ConstraintSystem<F>>(
 }
 
 #[inline]
-#[allow(dead_code)]
 pub fn a_ptr_as_z_ptr<T: Tag, F: LurkField>(
     a: &AllocatedPtr<F>,
 ) -> Option<crate::z_ptr::ZPtr<T, F>> {

src/lem/mod.rs

@@ -61,7 +61,7 @@
 
 pub mod circuit;
 pub mod eval;
-pub mod interpreter;
+pub(crate) mod interpreter;
 mod macros;
 pub mod multiframe;
 mod path;

src/lib.rs

@@ -5,29 +5,29 @@
 pub mod circuit;
 pub mod cli;
 pub mod config;
-pub mod cont;
+mod cont;
 pub mod coprocessor;
 pub mod error;
 pub mod eval;
-pub mod expr;
+mod expr;
 pub mod field;
-pub mod hash;
+mod hash;
 pub mod hash_witness;
 pub mod lem;
 mod num;
-pub mod package;
+mod package;
 pub mod parser;
 pub mod proof;
-pub mod ptr;
+mod ptr;
 pub mod public_parameters;
 pub mod state;
 pub mod store;
-pub mod symbol;
-pub mod syntax;
+mod symbol;
+mod syntax;
 mod syntax_macros;
-pub mod tag;
-pub mod uint;
-pub mod writer;
+mod tag;
+mod uint;
+mod writer;
 pub mod z_data;
 pub use num::Num;
 pub use symbol::Symbol;

src/package.rs

@@ -6,7 +6,7 @@ use std::{
 
 use crate::Symbol;
 
-pub type SymbolRef = Arc<Symbol>;
+pub(crate) type SymbolRef = Arc<Symbol>;
 
 #[derive(Debug)]
 pub struct Package {

src/ptr.rs

@@ -72,8 +72,8 @@ impl<F: LurkField, T: Tag> Hash for GPtr<F, T> {
     }
 }
 
-pub type Ptr<F> = GPtr<F, ExprTag>;
-pub type ContPtr<F> = GPtr<F, ContTag>;
+pub(crate) type Ptr<F> = GPtr<F, ExprTag>;
+pub(crate) type ContPtr<F> = GPtr<F, ContTag>;
 
 impl<F: LurkField, T: Tag> GPtr<F, T> {
     /// check if a Ptr is an opaque pointer
@@ -184,7 +184,7 @@ impl<F: LurkField> ContPtr<F> {
     }
 }
 
-pub trait TypePredicates {
+pub(crate) trait TypePredicates {
     fn is_fun(&self) -> bool;
     fn is_self_evaluating(&self) -> bool;
     fn is_potentially(&self, tag: ExprTag) -> bool;

src/public_parameters/disk_cache.rs

@@ -52,9 +52,8 @@ where
     ) -> Result<PublicParams<F, M>, Error> {
         let file = instance.open(&self.dir)?;
         let reader = BufReader::new(file);
-        bincode::deserialize_from(reader).map_err(|e| {
-            Error::CacheError(format!("Public param cache deserialization error: {}", e))
-        })
+        bincode::deserialize_from(reader)
+            .map_err(|e| Error::Cache(format!("Public param cache deserialization error: {}", e)))
     }
 
     pub(crate) fn read_bytes(
@@ -75,9 +74,8 @@ where
     ) -> Result<(), Error> {
         let file = instance.create(&self.dir)?;
         let writer = BufWriter::new(&file);
-        bincode::serialize_into(writer, &data).map_err(|e| {
-            Error::CacheError(format!("Public param cache serialization error: {}", e))
-        })
+        bincode::serialize_into(writer, &data)
+            .map_err(|e| Error::Cache(format!("Public param cache serialization error: {}", e)))
     }
 
     pub(crate) fn write_abomonated<V: Abomonation>(

src/public_parameters/error.rs

@@ -5,9 +5,9 @@ use thiserror::Error;
 #[derive(Error, Debug)]
 pub enum Error {
     #[error("IO error: {0}")]
-    IOError(#[from] io::Error),
+    IO(#[from] io::Error),
     #[error("Cache error: {0}")]
-    CacheError(String),
+    Cache(String),
     #[error("JSON error: {0}")]
-    JsonError(#[from] serde_json::Error),
+    Json(#[from] serde_json::Error),
 }

src/public_parameters/mem_cache.rs

@@ -67,7 +67,7 @@ impl PublicParamMemCache {
                     assert!(rest.is_empty());
                     Ok(Arc::new(pp.clone())) // this clone is VERY expensive
                 }
-                Err(Error::IOError(e)) => {
+                Err(Error::IO(e)) => {
                     warn!("{e}");
                     info!("Generating fresh public parameters");
                     let pp = default(instance);
@@ -77,7 +77,7 @@ impl PublicParamMemCache {
                         .tap_ok(|_| {
                             info!("writing public params to disk-cache: {}", instance.key())
                         })
-                        .map_err(|e| Error::CacheError(format!("Disk write error: {e}")))?;
+                        .map_err(|e| Error::Cache(format!("Disk write error: {e}")))?;
                     Ok(pp)
                 }
                 _ => unreachable!(),
@@ -92,7 +92,7 @@ impl PublicParamMemCache {
                 disk_cache
                     .write(instance, &*pp)
                     .tap_ok(|_| info!("writing public params to disk-cache: {}", instance.key()))
-                    .map_err(|e| Error::CacheError(format!("Disk write error: {e}")))?;
+                    .map_err(|e| Error::Cache(format!("Disk write error: {e}")))?;
                 Ok(pp)
             }
         }