Nix/nickel

Cargo.toml

@@ -24,6 +24,7 @@ markdown = ["termimad"]
 repl = ["rustyline", "rustyline-derive", "ansi_term"]
 repl-wasm = ["wasm-bindgen", "js-sys", "serde_repr"]
 doc = [ "comrak" ]
+nix = [ "rnix", "rowan" ]
 
 [build-dependencies]
 lalrpop = "0.19.6"
@@ -64,6 +65,10 @@ comrak = { version = "0.12.1", optional = true, features = [] }
 once_cell = "1.14.0"
 typed-arena = "2.0.1"
 
+# needed dependencies to be able to interpret nix expr with nickel
+rnix = { version = "0.11", optional = true }
+rowan = { version = "0.15.10", optional = true }
+
 [dev-dependencies]
 pretty_assertions = "1.2.1"
 assert_matches = "1.5.0"

flake.nix

@@ -162,6 +162,7 @@
           mkFilter = regexp: path: _type: builtins.match regexp path != null;
           lalrpopFilter = mkFilter ".*lalrpop$";
           nclFilter = mkFilter ".*ncl$";
+          nixFilter = mkFilter ".*/tests/nix/.+\\.nix$";
           txtFilter = mkFilter ".*txt$";
           snapFilter = mkFilter ".*snap$";
         in
@@ -174,6 +175,7 @@
             builtins.any (filter: filter path type) [
               lalrpopFilter
               nclFilter
+              nixFilter
               txtFilter
               snapFilter
               filterCargoSources

lsp/nls/src/requests/completion.rs

@@ -90,7 +90,7 @@ impl IdentWithType {
             if name.is_ascii() {
                 String::from(name)
             } else {
-                format!("\"{}\"", name)
+                format!("\"{name}\"")
             }
         }
         let doc = || {
@@ -814,7 +814,7 @@ mod tests {
             let actual = get_identifier_path(input);
             let expected: Option<Vec<_>> =
                 expected.map(|path| path.iter().map(|s| String::from(*s)).collect());
-            assert_eq!(actual, expected, "test failed: {}", case_name)
+            assert_eq!(actual, expected, "test failed: {case_name}")
         }
     }
 

src/bin/nickel.rs

@@ -7,6 +7,8 @@ use nickel_lang::repl::query_print;
 use nickel_lang::repl::rustyline_frontend;
 use nickel_lang::term::{RichTerm, Term};
 use nickel_lang::{serialize, serialize::ExportFormat};
+#[cfg(feature = "nix")]
+use std::io::Read;
 use std::path::{Path, PathBuf};
 use std::{
     fs::{self, File},
@@ -40,6 +42,10 @@ struct Opt {
 /// Available subcommands.
 #[derive(StructOpt, Debug)]
 enum Command {
+    /// translate Nix input to Nickel code.
+    /// Only a POC, main target is to be able to run Nix code on nickel.
+    /// May never be a complet source to source transformation.
+    Nixin,
     /// Converts the parsed representation (AST) back to Nickel source code and prints it. Used for
     /// debugging purpose
     PprintAst {
@@ -108,6 +114,34 @@ fn main() {
 
         #[cfg(not(feature = "repl"))]
         eprintln!("error: this executable was not compiled with REPL support");
+    } else if let Some(Command::Nixin) = opts.command {
+        #[cfg(feature = "nix")]
+        {
+            use nickel_lang::cache::Cache;
+            use nickel_lang::cache::ErrorTolerance;
+            use nickel_lang::pretty::*;
+            use pretty::BoxAllocator;
+
+            let mut buf = String::new();
+            let mut cache = Cache::new(ErrorTolerance::Strict);
+            let mut out: Vec<u8> = Vec::new();
+            opts.file
+                .map(std::fs::File::open)
+                .map(|f| f.and_then(|mut f| f.read_to_string(&mut buf)))
+                .unwrap_or_else(|| std::io::stdin().read_to_string(&mut buf))
+                .unwrap_or_else(|err| {
+                    eprintln!("Error when reading input: {err}");
+                    process::exit(1)
+                });
+            let allocator = BoxAllocator;
+            let file_id = cache.add_source("<stdin>.nix", buf.as_bytes()).unwrap();
+            let rt = nickel_lang::nix::parse(&cache, file_id).unwrap();
+            let doc: DocBuilder<_, ()> = rt.pretty(&allocator);
+            doc.render(80, &mut out).unwrap();
+            println!("{}", String::from_utf8_lossy(&out).as_ref());
+        }
+        #[cfg(not(feature = "nix"))]
+        eprintln!("error: this executable was not compiled with Nix evaluation support");
     } else {
         let mut program = opts
             .file
@@ -158,7 +192,7 @@ fn main() {
                 })
             }
             Some(Command::Typecheck) => program.typecheck(),
-            Some(Command::Repl { .. }) => unreachable!(),
+            Some(Command::Repl { .. }) | Some(Command::Nixin) => unreachable!(),
             #[cfg(feature = "doc")]
             Some(Command::Doc { ref output }) => output
                 .as_ref()

src/cache.rs

@@ -28,6 +28,7 @@ use void::Void;
 #[derive(Clone, Copy, Eq, Debug, PartialEq)]
 pub enum InputFormat {
     Nickel,
+    Nix,
     Json,
     Yaml,
     Toml,
@@ -37,6 +38,19 @@ impl InputFormat {
     fn from_path_buf(path_buf: &Path) -> Option<InputFormat> {
         match path_buf.extension().and_then(OsStr::to_str) {
             Some("ncl") => Some(InputFormat::Nickel),
+            Some("nix") => {
+                #[cfg(feature = "nix")]
+                {
+                    Some(InputFormat::Nix)
+                }
+                #[cfg(not(feature = "nix"))]
+                {
+                    eprintln!(
+                        "error: this executable was not compiled with Nix evaluation support"
+                    );
+                    None
+                }
+            }
             Some("json") => Some(InputFormat::Json),
             Some("yaml") | Some("yml") => Some(InputFormat::Yaml),
             Some("toml") => Some(InputFormat::Toml),
@@ -457,6 +471,22 @@ impl Cache {
 
                 Ok((t, parse_errs))
             }
+            // TODO: Error management for parse errors.
+            // May be better to throw an error instead of panicing if nickel has been compiled
+            // without Nix support
+            InputFormat::Nix => {
+                #[cfg(feature = "nix")]
+                {
+                    Ok((
+                        crate::nix::parse(self, file_id).unwrap(),
+                        ParseErrors::default(),
+                    ))
+                }
+                #[cfg(not(feature = "nix"))]
+                {
+                    panic!("error: this executable was not compiled with Nix evaluation support")
+                }
+            }
             InputFormat::Json => serde_json::from_str(self.files.source(file_id))
                 .map(|t| (t, ParseErrors::default()))
                 .map_err(|err| ParseError::from_serde_json(err, file_id, &self.files)),

src/conversion.rs

@@ -0,0 +1,38 @@
+//! This module contains a trait to implement on every thing you want to be convertible into nickel
+//! AST.
+//! It should be used mostly for AST to AST convertion (e.g.: nix to nickel). Effectively the
+//! `translate` function require to pass a `codespan::FileId` so it's not wors to use it for
+//! convertions which not imply a file/stream input. For these convertions, prefer `Into`/`From`
+//! standart traits.
+
+use crate::term::RichTerm;
+use codespan::FileId;
+use std::collections::HashSet;
+
+/// State of the conversion. It contains the definitions in scope of the currently converted node (e.g.:
+/// `with` environments, declared variables, current file id...), required for elaborate compilation (`with`).
+#[derive(Clone)]
+pub struct State {
+    /// The current transformation file ID.
+    pub file_id: FileId,
+    /// Variables in scope.
+    pub env: HashSet<String>,
+    /// With scope. List of the records on which has been applied a with in the current scope.
+    pub with: Vec<RichTerm>,
+}
+
+pub trait ToNickel: Sized {
+    /// Used when converting a full file. Actually call `translate` with an initial `State`.
+    fn to_nickel(self, file_id: FileId) -> RichTerm {
+        let state = State {
+            file_id,
+            env: HashSet::new(),
+            with: Vec::new(),
+        };
+        self.translate(&state)
+    }
+
+    /// Use to convert an expression or a term of the source language to nickel.
+    /// For a complet exemple, you can see `crate::nix`, the convertion from Nix to Nickel.
+    fn translate(self, state: &State) -> RichTerm;
+}

src/error.rs

@@ -314,6 +314,11 @@ impl IntoDiagnostics<FileId> for ParseErrors {
 /// An error occurring during parsing.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ParseError {
+    #[cfg(feature = "nix")]
+    /// Temporary Nix error variant.
+    /// TODO: because parsing errors are almost the same between Nix and Nickel, Have a seamless
+    /// convertion from Nix errors to Nickel ones could be a good improvement.
+    NixParseError(FileId),
     /// Unexpected end of file.
     UnexpectedEOF(FileId, /* tokens expected by the parser */ Vec<String>),
     /// Unexpected token.
@@ -1399,6 +1404,22 @@ impl IntoDiagnostics<FileId> for ParseError {
         _stdlib_ids: Option<&Vec<FileId>>,
     ) -> Vec<Diagnostic<FileId>> {
         let diagnostic = match self {
+            // TODO: improve error management for nix parser.
+            #[cfg(feature = "nix")]
+            ParseError::NixParseError(file_id) => {
+                let end = files.source_span(file_id).end();
+                let start = files.source_span(file_id).start();
+                Diagnostic::error()
+                    .with_message(format!(
+                        "error parsing nix file {}",
+                        files.name(file_id).to_string_lossy()
+                    ))
+                    .with_labels(vec![primary(&RawSpan {
+                        start,
+                        end,
+                        src_id: file_id,
+                    })])
+            }
             ParseError::UnexpectedEOF(file_id, _expected) => {
                 let end = files.source_span(file_id).end();
                 Diagnostic::error()

src/lib.rs

@@ -1,11 +1,14 @@
 pub mod cache;
+pub mod conversion;
 pub mod deserialize;
 pub mod destructuring;
 pub mod environment;
 pub mod error;
 pub mod eval;
 pub mod identifier;
 pub mod label;
+#[cfg(feature = "nix")]
+pub mod nix;
 pub mod parser;
 pub mod position;
 pub mod pretty;