snix_cli/
lib.rs

1use std::path::PathBuf;
2use std::rc::Rc;
3
4use rustc_hash::FxHashMap;
5use smol_str::SmolStr;
6use snix_build::buildservice;
7use snix_eval::{
8    ErrorKind, EvalIO, EvalMode, GlobalsMap, SourceCode, Value,
9    builtins::impure_builtins,
10    observer::{DisassemblingObserver, TracingObserver},
11};
12use snix_glue::{
13    builtins::{add_derivation_builtins, add_fetcher_builtins, add_import_builtins},
14    configure_nix_path,
15    snix_io::SnixIO,
16    snix_store_io::SnixStoreIO,
17};
18use std::fmt::Write;
19use tracing::{Span, info_span};
20use tracing_indicatif::span_ext::IndicatifSpanExt;
21
22pub mod args;
23pub mod assignment;
24pub mod repl;
25
26pub use args::Args;
27pub use repl::Repl;
28
29pub fn init_io_handle(tokio_runtime: &tokio::runtime::Runtime, args: &Args) -> Rc<SnixStoreIO> {
30    let (blob_service, directory_service, path_info_service, nar_calculation_service) =
31        tokio_runtime
32            .block_on(snix_store::utils::construct_services(
33                args.service_addrs.clone(),
34            ))
35            .expect("unable to setup {blob|directory|pathinfo}service before interpreter setup");
36
37    let build_service = tokio_runtime
38        .block_on({
39            let blob_service = blob_service.clone();
40            let directory_service = directory_service.clone();
41            async move {
42                buildservice::from_addr(
43                    &args.build_service_addr,
44                    blob_service.clone(),
45                    directory_service.clone(),
46                )
47                .await
48            }
49        })
50        .expect("unable to setup buildservice before interpreter setup");
51
52    Rc::new(SnixStoreIO::new(
53        blob_service.clone(),
54        directory_service.clone(),
55        path_info_service,
56        nar_calculation_service.into(),
57        build_service.into(),
58        tokio_runtime.handle().clone(),
59        args.hashed_mirrors.clone(),
60    ))
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
64pub enum AllowIncomplete {
65    Allow,
66    #[default]
67    RequireComplete,
68}
69
70impl AllowIncomplete {
71    fn allow(&self) -> bool {
72        matches!(self, Self::Allow)
73    }
74}
75
76#[derive(Debug, Clone, Copy, PartialEq, Eq)]
77pub struct IncompleteInput;
78
79pub struct EvalResult {
80    value: Option<Value>,
81    globals: Rc<GlobalsMap>,
82}
83
84/// Interprets the given code snippet, printing out warnings and errors and returning the result
85#[allow(clippy::too_many_arguments)]
86pub fn evaluate<E: std::io::Write + Clone + Send>(
87    stderr: &mut E,
88    snix_store_io: Rc<SnixStoreIO>,
89    code: &str,
90    path: Option<PathBuf>,
91    args: &Args,
92    allow_incomplete: AllowIncomplete,
93    env: Option<&FxHashMap<SmolStr, Value>>,
94    globals: Option<Rc<GlobalsMap>>,
95    source_map: Option<SourceCode>,
96) -> Result<EvalResult, IncompleteInput> {
97    let mut eval_builder = snix_eval::Evaluation::builder(Box::new(SnixIO::new(
98        snix_store_io.clone() as Rc<dyn EvalIO>,
99    )) as Box<dyn EvalIO>)
100    .enable_import()
101    .env(env);
102
103    if args.strict {
104        eval_builder = eval_builder.mode(EvalMode::Strict);
105    }
106
107    match globals {
108        Some(globals) => {
109            eval_builder = eval_builder.with_globals(globals);
110        }
111        None => {
112            eval_builder = eval_builder.add_builtins(impure_builtins());
113            eval_builder = add_derivation_builtins(eval_builder, Rc::clone(&snix_store_io));
114            eval_builder = add_fetcher_builtins(eval_builder, Rc::clone(&snix_store_io));
115            eval_builder = add_import_builtins(eval_builder, Rc::clone(&snix_store_io));
116        }
117    };
118    eval_builder = configure_nix_path(eval_builder, &args.nix_path());
119
120    if let Some(source_map) = source_map {
121        eval_builder = eval_builder.with_source_map(source_map);
122    }
123
124    let source_map = eval_builder.source_map().clone();
125
126    let mut compiler_observer = DisassemblingObserver::new(source_map.clone(), stderr.clone());
127    if args.dump_bytecode {
128        eval_builder.set_compiler_observer(Some(&mut compiler_observer));
129    }
130
131    let mut runtime_observer = TracingObserver::new(stderr.clone());
132    if args.trace_runtime {
133        if args.trace_runtime_timing {
134            runtime_observer.enable_timing()
135        }
136        eval_builder.set_runtime_observer(Some(&mut runtime_observer));
137    }
138
139    let eval = eval_builder.build();
140
141    let (result, globals) = info_span!("evaluate", indicatif.pb_show = tracing::field::Empty)
142        .in_scope(|| {
143            let span = Span::current();
144
145            if !args.trace_runtime && !args.dump_bytecode {
146                span.pb_set_message("Evaluating…");
147                span.pb_start();
148            }
149
150            let globals = eval.globals();
151            let result = eval.evaluate(code, path);
152            (result, globals)
153        });
154
155    if allow_incomplete.allow()
156        && result.errors.iter().any(|err| {
157            matches!(
158                &err.kind,
159                ErrorKind::ParseErrors(pes)
160                    if pes.iter().any(|pe| matches!(pe, rnix::parser::ParseError::UnexpectedEOF))
161            )
162        })
163    {
164        return Err(IncompleteInput);
165    }
166
167    if args.display_ast {
168        if let Some(ref expr) = result.expr {
169            writeln!(stderr, "AST: {}", snix_eval::pretty_print_expr(expr)).unwrap();
170        }
171    }
172
173    for error in &result.errors {
174        error.fancy_format_write(stderr);
175    }
176
177    if !args.no_warnings {
178        for warning in &result.warnings {
179            warning.fancy_format_write(stderr, &source_map);
180        }
181    }
182
183    if let Some(dumpdir) = &args.drv_dumpdir {
184        // Dump all known derivations files to `dumpdir`.
185        std::fs::create_dir_all(dumpdir).expect("failed to create drv dumpdir");
186        snix_store_io
187            .known_paths
188            .borrow()
189            .get_derivations()
190            // Skip already dumped derivations.
191            .filter(|(drv_path, _)| !dumpdir.join(drv_path.to_string()).exists())
192            .for_each(|(drv_path, drv)| {
193                std::fs::write(dumpdir.join(drv_path.to_string()), drv.to_aterm_bytes())
194                    .expect("failed to write drv to dumpdir");
195            })
196    }
197
198    Ok(EvalResult {
199        globals,
200        value: result.value,
201    })
202}
203
204pub struct InterpretResult {
205    output: String,
206    success: bool,
207    pub(crate) globals: Option<Rc<GlobalsMap>>,
208}
209
210impl InterpretResult {
211    pub fn empty_success(globals: Option<Rc<GlobalsMap>>) -> Self {
212        Self {
213            output: String::new(),
214            success: true,
215            globals,
216        }
217    }
218
219    pub fn finalize<E: std::io::Write>(self, stderr: &mut E) -> bool {
220        write!(stderr, "{}", self.output).unwrap();
221        self.success
222    }
223
224    pub fn output(&self) -> &str {
225        &self.output
226    }
227
228    pub fn success(&self) -> bool {
229        self.success
230    }
231}
232
233/// Interprets the given code snippet, printing out warnings, errors
234/// and the result itself. The return value indicates whether
235/// evaluation succeeded.
236#[allow(clippy::too_many_arguments)]
237pub fn interpret<E: std::io::Write + Clone + Send>(
238    stderr: &mut E,
239    snix_store_io: Rc<SnixStoreIO>,
240    code: &str,
241    path: Option<PathBuf>,
242    args: &Args,
243    explain: bool,
244    allow_incomplete: AllowIncomplete,
245    env: Option<&FxHashMap<SmolStr, Value>>,
246    globals: Option<Rc<GlobalsMap>>,
247    source_map: Option<SourceCode>,
248) -> Result<InterpretResult, IncompleteInput> {
249    let mut output = String::new();
250    let result = evaluate(
251        stderr,
252        snix_store_io,
253        code,
254        path,
255        args,
256        allow_incomplete,
257        env,
258        globals,
259        source_map,
260    )?;
261
262    if let Some(value) = result.value.as_ref() {
263        if explain {
264            writeln!(&mut output, "=> {}", value.explain()).unwrap();
265        } else if args.raw {
266            writeln!(&mut output, "{}", value.to_contextful_str().unwrap()).unwrap();
267        } else {
268            writeln!(&mut output, "=> {} :: {}", value, value.type_of()).unwrap();
269        }
270    }
271
272    // inform the caller about any errors
273    Ok(InterpretResult {
274        output,
275        success: result.value.is_some(),
276        globals: Some(result.globals),
277    })
278}
snix_cli/lib.rs

snix_cli/
lib.rs
