Better typed api

benches/all-packages.rs

@@ -5,7 +5,9 @@ fn all_packages(c: &mut Criterion) {
     let mut group = c.benchmark_group("all-packages");
     group.throughput(Throughput::Bytes(input.len() as u64));
     group.sample_size(30);
-    group.bench_with_input("all-packages", input, move |b, input| b.iter(|| rnix::parse(input)));
+    group.bench_with_input("all-packages", input, move |b, input| {
+        b.iter(|| rnix::Root::parse(input))
+    });
     group.finish();
 }
 

examples/dump-ast.rs

@@ -1,4 +1,3 @@
-use rnix::types::*;
 use std::{env, fs};
 
 fn main() {
@@ -15,12 +14,11 @@ fn main() {
                 return;
             }
         };
-        let ast = rnix::parse(&content);
+        let parse = rnix::Root::parse(&content);
 
-        for error in ast.errors() {
+        for error in parse.errors() {
             println!("error: {}", error);
         }
-
-        println!("{}", ast.root().dump());
+        println!("{:#?}", parse.tree());
     }
 }

examples/error-report.rs

@@ -16,7 +16,7 @@ fn main() {
             return;
         }
     };
-    let ast = rnix::parse(&content);
+    let ast = rnix::Root::parse(&content);
     for error in ast.errors() {
         let range = match error {
             ParseError::Unexpected(range) => range,

examples/from-stdin.rs

@@ -1,14 +1,13 @@
-use rnix::types::*;
 use std::{io, io::Read};
 
 fn main() {
     let mut content = String::new();
     io::stdin().read_to_string(&mut content).expect("could not read nix from stdin");
-    let ast = rnix::parse(&content);
+    let ast = rnix::Root::parse(&content);
 
     for error in ast.errors() {
         println!("error: {}", error);
     }
 
-    println!("{}", ast.root().dump());
+    println!("{}", ast.tree());
 }

examples/list-fns.rs

@@ -1,6 +1,19 @@
 use std::{env, error::Error, fs};
 
-use rnix::{types::*, NodeOrToken, SyntaxKind::*, SyntaxNode};
+use rnix::{
+    ast::{self, AstToken, HasEntry},
+    match_ast, NodeOrToken, SyntaxNode,
+};
+use rowan::ast::AstNode;
+
+macro_rules! single_match {
+    ($expression:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? => $captured:expr) => {
+        match $expression {
+            $( $pattern )|+ $( if $guard )? => Some($captured),
+            _ => None
+        }
+    };
+}
 
 fn main() -> Result<(), Box<dyn Error>> {
     let file = match env::args().nth(1) {
@@ -11,28 +24,47 @@ fn main() -> Result<(), Box<dyn Error>> {
         }
     };
     let content = fs::read_to_string(&file)?;
-    let ast = rnix::parse(&content).as_result()?;
-    let set = ast.root().inner().and_then(AttrSet::cast).ok_or("root isn't a set")?;
-
+    let ast = rnix::Root::parse(&content).ok()?;
+    let expr = ast.expr().unwrap();
+    let set = match expr {
+        ast::Expr::AttrSet(set) => set,
+        _ => return Err("root isn't a set".into()),
+    };
     for entry in set.entries() {
-        if let Some(lambda) = entry.value().and_then(Lambda::cast) {
-            if let Some(attr) = entry.key() {
-                let ident = attr.path().last().and_then(Ident::cast);
-                let s = ident.as_ref().map_or_else(|| "error".to_string(), Ident::to_inner_string);
+        if let ast::Entry::KeyValue(key_value) = entry {
+            if let Some(ast::Expr::Lambda(lambda)) = key_value.value() {
+                let key = key_value.key().unwrap();
+                let ident = key.attrs().last().and_then(|attr| match attr {
+                    ast::Attr::Ident(ident) => Some(ident),
+                    _ => None,
+                });
+                let s = ident.as_ref().map_or_else(
+                    || "error".to_string(),
+                    |ident| ident.ident_token().unwrap().text().to_string(),
+                );
                 println!("Function name: {}", s);
-                if let Some(comment) = find_comment(attr.node().clone()) {
-                    println!("-> Doc: {}", comment);
+                {
+                    let comments = comments_before(key_value.syntax());
+                    if !comments.is_empty() {
+                        println!("--> Doc: {comments}");
+                    }
                 }
 
                 let mut value = Some(lambda);
                 while let Some(lambda) = value {
-                    let ident = lambda.arg().and_then(Ident::cast);
-                    let s = ident.as_ref().map_or_else(|| "error".to_string(), Ident::to_inner_string);
-                    println!("-> Arg: {}", s);
-                    if let Some(comment) = lambda.arg().and_then(find_comment) {
-                        println!("--> Doc: {}", comment);
+                    let s = lambda
+                        .param()
+                        .as_ref()
+                        .map_or_else(|| "error".to_string(), |param| param.to_string());
+                    println!("-> Param: {}", s);
+                    {
+                        let comments = comments_before(lambda.syntax());
+                        if !comments.is_empty() {
+                            println!("--> Doc: {comments}");
+                        }
                     }
-                    value = lambda.body().and_then(Lambda::cast);
+                    value =
+                        single_match!(lambda.body().unwrap(), ast::Expr::Lambda(lambda) => lambda);
                 }
                 println!();
             }
@@ -41,32 +73,23 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
-fn find_comment(node: SyntaxNode) -> Option<String> {
-    let mut node = NodeOrToken::Node(node);
-    let mut comments = Vec::new();
-    loop {
-        loop {
-            if let Some(new) = node.prev_sibling_or_token() {
-                node = new;
-                break;
-            } else {
-                node = NodeOrToken::Node(node.parent()?);
-            }
-        }
 
-        match node.kind() {
-            TOKEN_COMMENT => match &node {
-                NodeOrToken::Token(token) => comments.push(token.text().to_string()),
-                NodeOrToken::Node(_) => unreachable!(),
+fn comments_before(node: &SyntaxNode) -> String {
+    node.siblings_with_tokens(rowan::Direction::Prev)
+        // rowan always returns the first node for some reason
+        .skip(1)
+        .map_while(|element| match element {
+            NodeOrToken::Token(token) => match_ast! {
+                match token {
+                    ast::Comment(it) => Some(Some(it)),
+                    ast::Whitespace(_) => Some(None),
+                    _ => None,
+                }
             },
-            t if t.is_trivia() => (),
-            _ => break,
-        }
-    }
-    let doc = comments
-        .iter()
-        .map(|it| it.trim_start_matches('#').trim())
+            _ => None,
+        })
+        .flatten()
+        .map(|s| s.text().trim().to_string())
         .collect::<Vec<_>>()
-        .join("\n        ");
-    Some(doc).filter(|it| !it.is_empty())
+        .join("\n         ")
 }

examples/preserve.rs

@@ -14,6 +14,6 @@ fn main() {
                 return;
             }
         };
-        print!("{}", rnix::parse(&content).node());
+        print!("{}", rnix::Root::parse(&content).tree());
     }
 }

examples/test-nixpkgs.rs

@@ -21,7 +21,7 @@ fn recurse(path: &Path) -> Result<(), Box<dyn Error>> {
             return Ok(());
         }
 
-        let parsed = rnix::parse(&original).as_result()?.node().to_string();
+        let parsed = rnix::Root::parse(&original).tree().to_string();
         if original != parsed {
             eprintln!("Original input does not match parsed output!");
             println!("Input:");

flake.nix

@@ -7,6 +7,8 @@
     import-cargo.url = "github:edolstra/import-cargo";
   };
 
+  # first comment
+  # second comment
   outputs = { self, nixpkgs, utils, import-cargo }:
     {
       overlay = final: prev: let

src/ast.rs

@@ -0,0 +1,68 @@
+//! Provides a type system for the AST, in some sense
+
+mod expr_ext;
+mod nodes;
+mod operators;
+mod str_util;
+mod tokens;
+
+use crate::{NixLanguage, SyntaxKind, SyntaxToken};
+
+pub use nodes::*;
+pub use operators::{BinOpKind, UnaryOpKind};
+pub use str_util::StrPart;
+pub use tokens::*;
+
+pub trait AstNode: rowan::ast::AstNode<Language = NixLanguage> {}
+
+impl<T> AstNode for T where T: rowan::ast::AstNode<Language = NixLanguage> {}
+
+pub trait AstToken {
+    fn can_cast(from: SyntaxKind) -> bool
+    where
+        Self: Sized;
+
+    /// Cast an untyped token into this strongly-typed token. This will return
+    /// None if the type was not correct.
+    fn cast(from: SyntaxToken) -> Option<Self>
+    where
+        Self: Sized;
+
+    fn syntax(&self) -> &SyntaxToken;
+}
+
+mod support {
+    use rowan::ast::AstChildren;
+
+    use super::{AstNode, AstToken};
+    use crate::{SyntaxElement, SyntaxKind, SyntaxToken};
+
+    pub(super) fn nth<N: AstNode, NN: AstNode>(parent: &N, n: usize) -> Option<NN> {
+        parent.syntax().children().flat_map(NN::cast).nth(n)
+    }
+
+    pub(super) fn children<N: AstNode, NN: AstNode>(parent: &N) -> AstChildren<NN> {
+        rowan::ast::support::children(parent.syntax())
+    }
+
+    pub(super) fn token<N: AstNode, T: AstToken>(parent: &N) -> Option<T> {
+        children_tokens(parent).nth(0)
+    }
+
+    /// Token untyped
+    pub(super) fn token_u<N: AstNode>(parent: &N, kind: SyntaxKind) -> Option<SyntaxToken> {
+        children_tokens_u(parent).find(|it| it.kind() == kind)
+    }
+
+    pub(super) fn children_tokens<N: AstNode, T: AstToken>(parent: &N) -> impl Iterator<Item = T> {
+        parent
+            .syntax()
+            .children_with_tokens()
+            .filter_map(SyntaxElement::into_token)
+            .filter_map(T::cast)
+    }
+
+    pub(super) fn children_tokens_u<N: AstNode>(parent: &N) -> impl Iterator<Item = SyntaxToken> {
+        parent.syntax().children_with_tokens().filter_map(SyntaxElement::into_token)
+    }
+}

src/ast/expr_ext.rs

@@ -0,0 +1,34 @@
+use crate::ast::{self, support::*};
+
+// this is a separate type because it mixes tokens and nodes
+// for example, a Str is a node because it can contain nested subexpressions but an Integer is a token.
+// This means that we have to write it out manually instead of using the macro to create the type for us.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum LiteralKind {
+    Float(ast::Float),
+    Integer(ast::Integer),
+    Path(ast::Path),
+    Uri(ast::Uri),
+}
+
+impl ast::Literal {
+    pub fn kind(&self) -> LiteralKind {
+        if let Some(it) = token(self) {
+            return LiteralKind::Float(it);
+        }
+
+        if let Some(it) = token(self) {
+            return LiteralKind::Integer(it);
+        }
+
+        if let Some(it) = token(self) {
+            return LiteralKind::Path(it);
+        }
+
+        if let Some(it) = token(self) {
+            return LiteralKind::Uri(it);
+        }
+
+        unreachable!()
+    }
+}