Remove AST-to-JSON snapshot export feature and its tests (#29597)

Remove the extensive but unused AST export feature
along with its very large tests.

Author: IGI-111

crates/ast/src/errors.rs

@@ -14,52 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
-use std::{
-    error::Error as ErrorArg,
-    fmt::{Debug, Display},
-};
+use std::fmt::Display;
 
 use leo_errors::Backtraced;
 
 const CODE_PREFIX: &str = "AST";
 const CODE_MASK: i32 = 2000;
 
-pub(crate) fn failed_to_convert_ast_to_json_string(error: &dyn ErrorArg) -> Backtraced {
-    Backtraced::error(CODE_PREFIX, CODE_MASK, format!("failed to convert the AST to a JSON string: {error}"))
-        .with_help("This is an internal serialization failure. Re-run the build; if it persists, please file an issue.")
-}
-
-pub(crate) fn failed_to_create_ast_json_file(path: &dyn Debug, error: &dyn ErrorArg) -> Backtraced {
-    Backtraced::error(CODE_PREFIX, CODE_MASK + 1, format!("failed to create AST JSON file `{path:?}`: {error}"))
-        .with_help("Check that the build output directory exists and is writable.")
-}
-
-pub(crate) fn failed_to_write_ast_to_json_file(path: &dyn Debug, error: &dyn ErrorArg) -> Backtraced {
-    Backtraced::error(CODE_PREFIX, CODE_MASK + 2, format!("failed to write the AST to JSON file `{path:?}`: {error}"))
-        .with_help("Check that the build output directory is writable and has enough free space.")
-}
-
-pub(crate) fn failed_to_read_json_string_to_ast(error: &dyn ErrorArg) -> Backtraced {
-    Backtraced::error(CODE_PREFIX, CODE_MASK + 3, format!("failed to deserialize a JSON string into an AST: {error}"))
-        .with_help("The cached AST JSON is corrupt or was produced by an incompatible Leo version. Run `leo clean` and rebuild.")
-}
-
-pub(crate) fn failed_to_read_json_file(path: &dyn Debug, error: &dyn ErrorArg) -> Backtraced {
-    Backtraced::error(
-        CODE_PREFIX,
-        CODE_MASK + 4,
-        format!("failed to deserialize JSON file `{path:?}` into an AST: {error}"),
-    )
-    .with_help(
-        "The cached AST JSON is corrupt or was produced by an incompatible Leo version. Run `leo clean` and rebuild.",
-    )
-}
-
-pub(crate) fn failed_to_convert_ast_to_json_value(error: &dyn ErrorArg) -> Backtraced {
-    Backtraced::error(CODE_PREFIX, CODE_MASK + 5, format!("failed to convert the AST to a JSON value: {error}"))
-        .with_help("This is an internal serialization failure. Re-run the build; if it persists, please file an issue.")
-}
-
 pub(crate) fn invalid_network_name(network: impl Display) -> Backtraced {
     Backtraced::error(CODE_PREFIX, CODE_MASK + 18, format!("invalid network name: `{network}`"))
         .with_help("Valid network names are `testnet`, `mainnet`, and `canary`.")

crates/ast/src/program/mod.rs

@@ -19,7 +19,6 @@
 mod program_scope;
 pub use program_scope::*;
 
-use leo_errors::Result;
 use leo_span::Symbol;
 
 use crate::{Module, ProgramId, Stub};
@@ -70,49 +69,6 @@ impl Default for Program {
     }
 }
 
-impl Program {
-    /// Serializes the ast into a JSON string.
-    pub fn to_json_string(&self) -> Result<String> {
-        Ok(serde_json::to_string_pretty(&self).map_err(|e| crate::errors::failed_to_convert_ast_to_json_string(&e))?)
-    }
-
-    // Converts the ast into a JSON value.
-    // Note that there is no corresponding `from_json_value` function
-    // since we modify JSON values leaving them unable to be converted
-    // back into Programs.
-    pub fn to_json_value(&self) -> Result<serde_json::Value> {
-        Ok(serde_json::to_value(self).map_err(|e| crate::errors::failed_to_convert_ast_to_json_value(&e))?)
-    }
-
-    /// Serializes the ast into a JSON file.
-    pub fn to_json_file(&self, path: std::path::PathBuf, file_name: &str) -> Result<()> {
-        write_ast_json(self, path, file_name)
-    }
-
-    /// Serializes the ast into a JSON value and removes keys from object mappings before writing to a file.
-    pub fn to_json_file_without_keys(
-        &self,
-        path: std::path::PathBuf,
-        file_name: &str,
-        excluded_keys: &[&str],
-    ) -> Result<()> {
-        write_ast_json_filtered(self, path, file_name, excluded_keys)
-    }
-
-    /// Deserializes the JSON string into a ast.
-    pub fn from_json_string(json: &str) -> Result<Self> {
-        let ast: Program =
-            serde_json::from_str(json).map_err(|e| crate::errors::failed_to_read_json_string_to_ast(&e))?;
-        Ok(ast)
-    }
-
-    /// Deserializes the JSON string into a ast from a file.
-    pub fn from_json_file(path: std::path::PathBuf) -> Result<Self> {
-        let data = std::fs::read_to_string(&path).map_err(|e| crate::errors::failed_to_read_json_file(&path, &e))?;
-        Self::from_json_string(&data)
-    }
-}
-
 /// Helper function to recursively filter keys from AST JSON.
 pub fn remove_key_from_json(value: serde_json::Value, key: &str) -> serde_json::Value {
     match value {
@@ -157,36 +113,6 @@ pub fn normalize_json_value(value: serde_json::Value) -> serde_json::Value {
     }
 }
 
-/// Serializes an AST node (`Program` or `Library`) into a pretty JSON file, spans included.
-pub fn write_ast_json<T: Serialize>(value: &T, mut path: std::path::PathBuf, file_name: &str) -> Result<()> {
-    path.push(file_name);
-    let file = std::fs::File::create(&path).map_err(|e| crate::errors::failed_to_create_ast_json_file(&path, &e))?;
-    let writer = std::io::BufWriter::new(file);
-    Ok(serde_json::to_writer_pretty(writer, value)
-        .map_err(|e| crate::errors::failed_to_write_ast_to_json_file(&path, &e))?)
-}
-
-/// Serializes an AST node to a JSON file, stripping `excluded_keys` and normalizing first.
-pub fn write_ast_json_filtered<T: Serialize>(
-    value: &T,
-    mut path: std::path::PathBuf,
-    file_name: &str,
-    excluded_keys: &[&str],
-) -> Result<()> {
-    path.push(file_name);
-    let file = std::fs::File::create(&path).map_err(|e| crate::errors::failed_to_create_ast_json_file(&path, &e))?;
-    let writer = std::io::BufWriter::new(file);
-
-    let mut value = serde_json::to_value(value).map_err(|e| crate::errors::failed_to_convert_ast_to_json_value(&e))?;
-    for key in excluded_keys {
-        value = remove_key_from_json(value, key);
-    }
-    value = normalize_json_value(value);
-
-    Ok(serde_json::to_writer_pretty(writer, &value)
-        .map_err(|e| crate::errors::failed_to_write_ast_to_json_file(&path, &e))?)
-}
-
 /// Serde helpers for `IndexMap<Vec<Symbol>, V>` maps keyed by module paths.
 ///
 /// JSON object keys must be strings, so the `Vec<Symbol>` path is joined into a single

crates/compiler/benchmarks/src/lib.rs

@@ -28,11 +28,7 @@ use leo_parser::parse_program;
 use leo_span::{Symbol, source_map::FileName, with_session_globals};
 use snarkvm::prelude::{CanaryV0, MainnetV0, TestnetV0};
 
-use std::{
-    fs,
-    path::{Path, PathBuf},
-    rc::Rc,
-};
+use std::{fs, path::Path, rc::Rc};
 
 use indexmap::IndexMap;
 use walkdir::WalkDir;
@@ -278,7 +274,6 @@ pub fn create_compiler(fixture: &FixtureData) -> Compiler {
         false,
         Handler::default(),
         Rc::new(NodeBuilder::default()),
-        PathBuf::default(),
         Some(CompilerOptions::default()),
         fixture.import_stubs.clone(),
         fixture.network,
@@ -294,7 +289,6 @@ pub fn create_parse_only_compiler(fixture: &FixtureData) -> Compiler {
         false,
         Handler::default(),
         Rc::new(NodeBuilder::default()),
-        PathBuf::default(),
         Some(CompilerOptions::default()),
         IndexMap::new(),
         fixture.network,

crates/compiler/src/compiler.rs

@@ -18,7 +18,7 @@
 //!
 //! The [`Compiler`] type compiles Leo programs into R1CS circuits.
 
-use crate::{AstSnapshots, CompilerOptions, errors};
+use crate::{CompilerOptions, errors};
 
 use leo_ast::{AleoProgram, FunctionStub, Identifier, Library, NetworkName, NodeBuilder, ProgramId, Stub};
 pub use leo_ast::{Ast, DiGraph, Program};
@@ -92,8 +92,6 @@ pub struct Compiled {
 
 /// The primary entry point of the Leo compiler.
 pub struct Compiler {
-    /// The path to where the compiler outputs all generated files.
-    output_directory: PathBuf,
     /// The name of the compilation unit (program or library).
     pub unit_name: Option<String>,
     /// When set, recompile under this on-chain name instead of the one the source
@@ -178,11 +176,6 @@ impl Compiler {
 
         self.state.ast = Ast::Program(program);
 
-        if self.compiler_options.initial_ast {
-            self.write_ast_to_json("initial.json")?;
-            self.write_ast("initial.ast")?;
-        }
-
         Ok(())
     }
 
@@ -253,11 +246,6 @@ impl Compiler {
             self.unit_name = Some(library_name.to_string());
         }
 
-        if self.compiler_options.initial_ast {
-            self.write_ast_to_json("initial.json")?;
-            self.write_ast("initial.ast")?;
-        }
-
         Ok(())
     }
 
@@ -329,7 +317,6 @@ impl Compiler {
         is_test: bool,
         handler: Handler,
         node_builder: Rc<NodeBuilder>,
-        output_directory: PathBuf,
         compiler_options: Option<CompilerOptions>,
         import_stubs: IndexMap<Symbol, Stub>,
         network: NetworkName,
@@ -342,7 +329,6 @@ impl Compiler {
                 network,
                 ..Default::default()
             },
-            output_directory,
             unit_name: expected_unit_name,
             rename: None,
             compiler_options: compiler_options.unwrap_or_default(),
@@ -356,23 +342,13 @@ impl Compiler {
     }
 
     /// Runs a compiler pass and checks whether the caller still wants the
-    /// result once the pass and any requested snapshots have completed.
+    /// result once the pass has completed.
     fn do_pass_with_check<P: Pass, C>(&mut self, input: P::Input, should_continue: &mut C) -> Result<P::Output>
     where
         C: FnMut() -> Result<()>,
     {
         let output = P::do_pass(input, &mut self.state)?;
 
-        let write = match &self.compiler_options.ast_snapshots {
-            AstSnapshots::All => true,
-            AstSnapshots::Some(passes) => passes.contains(P::NAME),
-        };
-
-        if write {
-            self.write_ast_to_json(&format!("{}.json", P::NAME))?;
-            self.write_ast(&format!("{}.ast", P::NAME))?;
-        }
-
         should_continue()?;
         Ok(output)
     }
@@ -738,48 +714,6 @@ impl Compiler {
         }
     }
 
-    /// Writes the AST to a JSON file under the unit's snapshots directory.
-    fn write_ast_to_json(&self, filename: &str) -> Result<()> {
-        // No snapshots directory configured (parse-only preflight or LSP); skip rather than dump into the CWD.
-        if self.output_directory.as_os_str().is_empty() {
-            return Ok(());
-        }
-        // Snapshots are opt-in; create the directory lazily on first write.
-        fs::create_dir_all(&self.output_directory)
-            .map_err(|e| crate::errors::failed_ast_file(self.output_directory.display(), e))?;
-        let dir = self.output_directory.clone();
-        if self.compiler_options.ast_spans_enabled {
-            match &self.state.ast {
-                Ast::Program(program) => leo_ast::write_ast_json(program, dir, filename)?,
-                Ast::Library(library) => leo_ast::write_ast_json(library, dir, filename)?,
-            }
-        } else {
-            match &self.state.ast {
-                Ast::Program(program) => leo_ast::write_ast_json_filtered(program, dir, filename, &["_span", "span"])?,
-                Ast::Library(library) => leo_ast::write_ast_json_filtered(library, dir, filename, &["_span", "span"])?,
-            }
-        }
-        Ok(())
-    }
-
-    /// Writes the AST to a file (Leo syntax, not JSON) under the unit's snapshots directory.
-    fn write_ast(&self, filename: &str) -> Result<()> {
-        // No snapshots directory configured (parse-only preflight or LSP); skip rather than dump into the CWD.
-        if self.output_directory.as_os_str().is_empty() {
-            return Ok(());
-        }
-        // Snapshots are opt-in; create the directory lazily on first write.
-        fs::create_dir_all(&self.output_directory)
-            .map_err(|e| crate::errors::failed_ast_file(self.output_directory.display(), e))?;
-        let full_filename = self.output_directory.join(filename);
-
-        let contents = self.state.ast.to_string();
-
-        fs::write(&full_filename, contents).map_err(|e| crate::errors::failed_ast_file(full_filename.display(), e))?;
-
-        Ok(())
-    }
-
     /// Resolves and registers all import stubs for the current program.
     ///
     /// This method performs a graph traversal over the program’s import relationships to:
@@ -914,11 +848,9 @@ impl Compiler {
             false,
             handler,
             node_builder,
-            PathBuf::new(),
             Some(CompilerOptions {
                 // avoid infinite recursion
                 no_std: true,
-                ..CompilerOptions::default()
             }),
             IndexMap::new(),
             network,
@@ -1228,7 +1160,6 @@ fn load_source_dependency_stub(
         false,
         handler,
         node_builder,
-        PathBuf::default(),
         Some(CompilerOptions::default()),
         IndexMap::new(),
         network,
@@ -1351,16 +1282,8 @@ mod tests {
 
             let handler = Handler::default();
             let node_builder = Rc::new(NodeBuilder::default());
-            let mut compiler = Compiler::new(
-                None,
-                false,
-                handler,
-                node_builder,
-                PathBuf::from("/unused"),
-                None,
-                IndexMap::new(),
-                NetworkName::TestnetV0,
-            );
+            let mut compiler =
+                Compiler::new(None, false, handler, node_builder, None, IndexMap::new(), NetworkName::TestnetV0);
 
             let library = compiler
                 .parse_library_from_directory_with_file_source(
@@ -1402,7 +1325,6 @@ mod tests {
                 false,
                 handler,
                 node_builder,
-                PathBuf::from("/unused"),
                 None,
                 IndexMap::new(),
                 NetworkName::TestnetV0,
@@ -1447,7 +1369,6 @@ mod tests {
                 false,
                 handler,
                 node_builder,
-                PathBuf::from("/unused"),
                 None,
                 IndexMap::new(),
                 NetworkName::TestnetV0,
@@ -1479,7 +1400,6 @@ mod tests {
                 false,
                 handler,
                 node_builder,
-                PathBuf::from("/unused"),
                 None,
                 IndexMap::new(),
                 NetworkName::TestnetV0,
@@ -1528,9 +1448,8 @@ mod tests {
                 false,
                 handler,
                 node_builder,
-                PathBuf::new(),
                 // `no_std` avoids injecting `std` into itself.
-                Some(crate::CompilerOptions { no_std: true, ..Default::default() }),
+                Some(crate::CompilerOptions { no_std: true }),
                 IndexMap::new(),
                 NetworkName::TestnetV0,
             );

crates/compiler/src/errors.rs

@@ -60,11 +60,6 @@ pub(crate) fn imported_program_not_found(
     .with_help(format!("Add `{dependency_name}` as a dependency in `program.json`. Run `leo add --help` for details."))
 }
 
-pub(crate) fn failed_ast_file(filename: impl Display, error: impl Display) -> Backtraced {
-    Backtraced::error(CODE_PREFIX, CODE_MASK + 11, format!("failed to write AST to file `{filename}`: {error}"))
-        .with_help("Verify the build output directory exists, is writable, and has enough free space.")
-}
-
 // Duplicated from package — same message, different code.
 pub(crate) fn failed_path(path: impl Display, err: impl Display) -> Backtraced {
     Backtraced::error(CODE_PREFIX, CODE_MASK + 16, format!("cannot find path `{path}`: {err}"))