Something went wrong. Try again.
forked from tvlfyi/tvix
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257use std::path::PathBuf;use std::rc::Rc;use std::str::FromStr;
use rustc_hash::FxHashMap;use smol_str::SmolStr;use std::fmt::Write;use tracing::instrument;use tvix_eval::{ ErrorKind, EvalIO, EvalMode, GlobalsMap, SourceCode, Value, builtins::impure_builtins, observer::{DisassemblingObserver, TracingObserver},};use tvix_glue::{ builtins::{add_derivation_builtins, add_import_builtins}, configure_nix_path, tvix_io::TvixIO, tvix_store_io::TvixStoreIO,};use tvix_simstore::simulated_store_builtins;
pub mod args;pub mod assignment;pub mod repl;
pub use args::Args;pub use repl::Repl;
pub fn init_io_handle(args: &Args) -> Rc<TvixStoreIO> { // TODO(tazjin): ugly for now, but this is temporary while we drop the old // store, this whole function will go away probably. let mut simstore = tvix_simstore::SimulatedStoreIO::default(); if let (Some(nix_path), Some(store_dir)) = (args.nix_path(), simstore.store_dir()) { let search_path = tvix_eval::NixSearchPath::from_str(&nix_path).expect("NIX_PATH was invalid"); for entry in search_path.get_entries() { let path = entry.get_path(); if !path.starts_with(&store_dir) { continue; }
simstore .add_passthru(&path.to_string_lossy(), path.to_path_buf()) .expect("setting passthru failed"); } }
Rc::new(TvixStoreIO::new(simstore))}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]pub enum AllowIncomplete { Allow, #[default] RequireComplete,}
impl AllowIncomplete { fn allow(&self) -> bool { matches!(self, Self::Allow) }}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct IncompleteInput;
pub struct EvalResult { value: Option<Value>, globals: Rc<GlobalsMap>,}
/// Interprets the given code snippet, printing out warnings and errors and returning the result#[allow(clippy::too_many_arguments)]pub fn evaluate( tvix_store_io: Rc<TvixStoreIO>, code: &str, path: Option<PathBuf>, args: &Args, allow_incomplete: AllowIncomplete, env: Option<&FxHashMap<SmolStr, Value>>, globals: Option<Rc<GlobalsMap>>, source_map: Option<SourceCode>,) -> Result<EvalResult, IncompleteInput> { let mut eval_builder = tvix_eval::Evaluation::builder(Rc::new(TvixIO::new( tvix_store_io.clone() as Rc<dyn EvalIO>, )) as Rc<dyn EvalIO>) .enable_import() .env(env);
if args.strict { eval_builder = eval_builder.mode(EvalMode::Strict); }
match globals { Some(globals) => { eval_builder = eval_builder.with_globals(globals); } None => { eval_builder = eval_builder.add_builtins(impure_builtins()); eval_builder = eval_builder.add_builtins(simulated_store_builtins()); eval_builder = add_derivation_builtins(eval_builder, Rc::clone(&tvix_store_io)); // eval_builder = add_fetcher_builtins(eval_builder, Rc::clone(&tvix_store_io)); eval_builder = add_import_builtins(eval_builder, Rc::clone(&tvix_store_io)); } }; eval_builder = configure_nix_path(eval_builder, &args.nix_path());
if let Some(source_map) = source_map { eval_builder = eval_builder.with_source_map(source_map); }
let source_map = eval_builder.source_map().clone(); let (result, globals) = { let mut compiler_observer = DisassemblingObserver::new(source_map.clone(), std::io::stderr()); if args.dump_bytecode { eval_builder.set_compiler_observer(Some(&mut compiler_observer)); }
let mut runtime_observer = TracingObserver::new(std::io::stderr()); if args.trace_runtime { if args.trace_runtime_timing { runtime_observer.enable_timing() } eval_builder.set_runtime_observer(Some(&mut runtime_observer)); }
let eval = eval_builder.build(); let globals = eval.globals(); let result = eval.evaluate(code, path); (result, globals) };
if allow_incomplete.allow() && result.errors.iter().any(|err| { matches!( &err.kind, ErrorKind::ParseErrors(pes) if pes.iter().any(|pe| matches!(pe, rnix::parser::ParseError::UnexpectedEOF)) ) }) { return Err(IncompleteInput); }
if args.display_ast { if let Some(ref expr) = result.expr { eprintln!("AST: {}", tvix_eval::pretty_print_expr(expr)); } }
for error in &result.errors { error.fancy_format_stderr(); }
if !args.no_warnings { for warning in &result.warnings { warning.fancy_format_stderr(&source_map); } }
if let Some(dumpdir) = &args.drv_dumpdir { // Dump all known derivations files to `dumpdir`. std::fs::create_dir_all(dumpdir).expect("failed to create drv dumpdir"); tvix_store_io .known_paths .borrow() .get_derivations() // Skip already dumped derivations. .filter(|(drv_path, _)| !dumpdir.join(drv_path.to_string()).exists()) .for_each(|(drv_path, drv)| { std::fs::write(dumpdir.join(drv_path.to_string()), drv.to_aterm_bytes()) .expect("failed to write drv to dumpdir"); }) }
Ok(EvalResult { globals, value: result.value, })}
pub struct InterpretResult { output: String, success: bool, pub(crate) globals: Option<Rc<GlobalsMap>>,}
impl InterpretResult { pub fn empty_success(globals: Option<Rc<GlobalsMap>>) -> Self { Self { output: String::new(), success: true, globals, } }
pub fn finalize(self) -> bool { print!("{}", self.output); self.success }
pub fn output(&self) -> &str { &self.output }
pub fn success(&self) -> bool { self.success }}
/// Interprets the given code snippet, printing out warnings, errors/// and the result itself. The return value indicates whether/// evaluation succeeded.#[instrument(skip_all, fields(indicatif.pb_show=tracing::field::Empty))]#[allow(clippy::too_many_arguments)]pub fn interpret( tvix_store_io: Rc<TvixStoreIO>, code: &str, path: Option<PathBuf>, args: &Args, explain: bool, allow_incomplete: AllowIncomplete, env: Option<&FxHashMap<SmolStr, Value>>, globals: Option<Rc<GlobalsMap>>, source_map: Option<SourceCode>,) -> Result<InterpretResult, IncompleteInput> { let mut output = String::new(); let result = evaluate( tvix_store_io, code, path, args, allow_incomplete, env, globals, source_map, )?;
if let Some(value) = result.value.as_ref() { if explain { writeln!(&mut output, "=> {}", value.explain()).unwrap(); } else if args.raw { writeln!(&mut output, "{}", value.to_contextful_str().unwrap()).unwrap(); } else { writeln!(&mut output, "=> {} :: {}", value, value.type_of()).unwrap(); } }
// inform the caller about any errors Ok(InterpretResult { output, success: result.value.is_some(), globals: Some(result.globals), })}