chore: move a couple of test_utils functions into a module

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -24,7 +24,7 @@ use crate::{
     graph::CrateId,
     hir::{
         Context,
-        comptime::{ComptimeError, InterpreterError},
+        comptime::ComptimeError,
         def_collector::{
             dc_crate::{
                 CollectedItems, CompilationError, ImplMap, UnresolvedEnum, UnresolvedFunctions,
@@ -2411,96 +2411,112 @@ impl Visitor for RemoveGenericsAppearingInTypeVisitor<'_> {
     }
 }
 
-/// The possible errors of interpreting given code
-/// into a monomorphized AST expression.
 #[cfg(feature = "test_utils")]
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ElaboratorError {
-    Parse(Vec<ParserError>),
-    Compile(Vec<CompilationError>),
-    Interpret(InterpreterError),
-    HIRConvert(InterpreterError),
-}
+pub mod test_utils {
+    use crate::hir::comptime::InterpreterError;
+    use crate::{hir::def_collector::dc_crate::CompilationError, parser::ParserError};
+
+    /// The possible errors of interpreting given code
+    /// into a monomorphized AST expression.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub enum ElaboratorError {
+        Parse(Vec<ParserError>),
+        Compile(Vec<CompilationError>),
+        Interpret(InterpreterError),
+        HIRConvert(InterpreterError),
+    }
+
+    /// Interpret source code using the elaborator, without
+    /// parsing and compiling it with nargo, converting
+    /// the result into a monomorphized AST expression.
+    pub fn interpret(
+        src: &str,
+    ) -> Result<crate::monomorphization::ast::Expression, ElaboratorError> {
+        use crate::elaborator::ElaboratorOptions;
+        use crate::monomorphization::{Monomorphizer, debug_types::DebugTypeTracker};
+        use crate::parse_program;
+        use crate::{
+            elaborator::Elaborator,
+            hir::{
+                Context, ParsedFiles,
+                def_collector::{dc_crate::DefCollector, dc_mod::collect_defs},
+                def_map::{CrateDefMap, ModuleData},
+            },
+        };
+        use fm::{FileId, FileManager};
+        use noirc_errors::Location;
+        use std::path::PathBuf;
 
-/// Interpret source code using the elaborator, without
-/// parsing and compiling it with nargo, converting
-/// the result into a monomorphized AST expression.
-#[cfg(feature = "test_utils")]
-pub fn interpret(src: &str) -> Result<crate::monomorphization::ast::Expression, ElaboratorError> {
-    use crate::hir::{
-        Context, ParsedFiles,
-        def_collector::{dc_crate::DefCollector, dc_mod::collect_defs},
-        def_map::{CrateDefMap, ModuleData},
-    };
-    use crate::monomorphization::{Monomorphizer, debug_types::DebugTypeTracker};
-    use crate::parse_program;
-    use fm::{FileId, FileManager};
-    use std::path::PathBuf;
-
-    let file = FileId::default();
-
-    let location = Location::new(Default::default(), file);
-    let root_module = ModuleData::new(
-        None,
-        location,
-        Vec::new(),
-        Vec::new(),
-        false, // is contract
-        false, // is struct
-    );
-
-    let file_manager = FileManager::new(&PathBuf::new());
-    let parsed_files = ParsedFiles::new();
-    let mut context = Context::new(file_manager, parsed_files);
-    context.def_interner.populate_dummy_operator_traits();
-
-    let krate = context.crate_graph.add_crate_root(FileId::dummy());
-
-    let (module, errors) = parse_program(src, file);
-    // Skip parser warnings
-    let errors: Vec<_> = errors.iter().filter(|e| !e.is_warning()).cloned().collect();
-    if !errors.is_empty() {
-        return Err(ElaboratorError::Parse(errors));
-    }
-
-    let ast = module.into_sorted();
-
-    let def_map = CrateDefMap::new(krate, root_module);
-    let root_module_id = def_map.root();
-    let mut collector = DefCollector::new(def_map);
-
-    collect_defs(&mut collector, ast, FileId::dummy(), root_module_id, krate, &mut context);
-    context.def_maps.insert(krate, collector.def_map);
-
-    let main = context.get_main_function(&krate).expect("Expected 'main' function");
-
-    let mut elaborator = Elaborator::elaborate_and_return_self(
-        &mut context,
-        krate,
-        collector.items,
-        ElaboratorOptions::test_default(),
-    );
-
-    // Skip the elaborator's compilation warnings
-    let errors: Vec<_> = elaborator.errors.iter().filter(|&e| e.is_error()).cloned().collect();
-    if !errors.is_empty() {
-        return Err(ElaboratorError::Compile(errors));
-    }
-
-    let mut interpreter = elaborator.setup_interpreter();
-
-    // The most straightforward way to convert the interpreter result into
-    // an acceptable monomorphized AST expression seems to be converting it
-    // into HIR first and then processing it with the monomorphizer
-    let expr_id =
-        match interpreter.call_function(main, Vec::new(), Default::default(), Location::dummy()) {
+        let file = FileId::default();
+
+        let location = Location::new(Default::default(), file);
+        let root_module = ModuleData::new(
+            None,
+            location,
+            Vec::new(),
+            Vec::new(),
+            false, // is contract
+            false, // is struct
+        );
+
+        let file_manager = FileManager::new(&PathBuf::new());
+        let parsed_files = ParsedFiles::new();
+        let mut context = Context::new(file_manager, parsed_files);
+        context.def_interner.populate_dummy_operator_traits();
+
+        let krate = context.crate_graph.add_crate_root(FileId::dummy());
+
+        let (module, errors) = parse_program(src, file);
+        // Skip parser warnings
+        let errors: Vec<_> = errors.iter().filter(|e| !e.is_warning()).cloned().collect();
+        if !errors.is_empty() {
+            return Err(ElaboratorError::Parse(errors));
+        }
+
+        let ast = module.into_sorted();
+
+        let def_map = CrateDefMap::new(krate, root_module);
+        let root_module_id = def_map.root();
+        let mut collector = DefCollector::new(def_map);
+
+        collect_defs(&mut collector, ast, FileId::dummy(), root_module_id, krate, &mut context);
+        context.def_maps.insert(krate, collector.def_map);
+
+        let main = context.get_main_function(&krate).expect("Expected 'main' function");
+
+        let mut elaborator = Elaborator::elaborate_and_return_self(
+            &mut context,
+            krate,
+            collector.items,
+            ElaboratorOptions::test_default(),
+        );
+
+        // Skip the elaborator's compilation warnings
+        let errors: Vec<_> = elaborator.errors.iter().filter(|&e| e.is_error()).cloned().collect();
+        if !errors.is_empty() {
+            return Err(ElaboratorError::Compile(errors));
+        }
+
+        let mut interpreter = elaborator.setup_interpreter();
+
+        // The most straightforward way to convert the interpreter result into
+        // an acceptable monomorphized AST expression seems to be converting it
+        // into HIR first and then processing it with the monomorphizer
+        let expr_id = match interpreter.call_function(
+            main,
+            Vec::new(),
+            Default::default(),
+            Location::dummy(),
+        ) {
             Err(e) => return Err(ElaboratorError::Interpret(e)),
             Ok(value) => match value.into_hir_expression(elaborator.interner, Location::dummy()) {
                 Err(e) => return Err(ElaboratorError::HIRConvert(e)),
                 Ok(expr_id) => expr_id,
             },
         };
 
-    let mut monomorphizer = Monomorphizer::new(elaborator.interner, DebugTypeTracker::default());
-    Ok(monomorphizer.expr(expr_id).expect("monomorphization error while converting interpreter execution result, should not be possible"))
+        let mut monomorphizer =
+            Monomorphizer::new(elaborator.interner, DebugTypeTracker::default());
+        Ok(monomorphizer.expr(expr_id).expect("monomorphization error while converting interpreter execution result, should not be possible"))
+    }
 }

tooling/ast_fuzzer/src/compare/comptime.rs

@@ -19,9 +19,11 @@ use noirc_driver::{
 };
 use noirc_errors::CustomDiagnostic;
 use noirc_evaluator::ssa::SsaProgramArtifact;
-use noirc_frontend::elaborator::ElaboratorError;
+use noirc_frontend::elaborator::test_utils::ElaboratorError;
 use noirc_frontend::hir::def_collector::dc_crate::CompilationError;
-use noirc_frontend::{elaborator::interpret, hir::Context, monomorphization::ast::Program};
+use noirc_frontend::{
+    elaborator::test_utils::interpret, hir::Context, monomorphization::ast::Program,
+};
 
 use super::{CompareArtifact, CompareCompiledResult, CompareOptions, HasPrograms};
 use crate::compare::compiled::ExecResult;