Better typed api

examples/list-fns.rs

@@ -1,12 +1,12 @@
 use std::{env, error::Error, fs};
 
+use rnix::ast::AstToken;
 use rnix::{
     ast::{self, EntryHolder},
-    NodeOrToken, SyntaxNode,
+    match_ast, NodeOrToken, SyntaxNode,
 };
 use rowan::ast::AstNode;
 
-#[macro_export]
 macro_rules! single_match {
     ($expression:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? => $captured:expr) => {
         match $expression {
@@ -33,7 +33,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     };
     for entry in set.entries() {
         if let ast::Entry::KeyValue(key_value) = entry {
-            if let ast::Expr::Lambda(lambda) = key_value.value().unwrap() {
+            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),
@@ -44,22 +44,26 @@ fn main() -> Result<(), Box<dyn Error>> {
                     |ident| ident.ident_token().unwrap().text().to_string(),
                 );
                 println!("Function name: {}", s);
-                // if let Some(comment) = find_comment(key.syntax().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 s = ident.as_ref().map_or_else(
-                        || "error".to_string(),
-                        |ident| ident.ident_token().unwrap().to_string(),
-                    );
-                    println!("-> Arg: {}", s);
-                    // if let Some(comment) =
-                    //     lambda.param().map(|param| param.syntax()).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 =
                         single_match!(lambda.body().unwrap(), ast::Expr::Lambda(lambda) => lambda);
                 }
@@ -71,32 +75,22 @@ 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!(),
-//             },
-//             t if t.is_trivia() => (),
-//             _ => break,
-//         }
-//     }
-//     let doc = comments
-//         .iter()
-//         .map(|it| it.trim_start_matches('#').trim())
-//         .collect::<Vec<_>>()
-//         .join("\n        ");
-//     Some(doc).filter(|it| !it.is_empty())
-// }
+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,
+                }
+            },
+            _ => None,
+        })
+        .flatten()
+        .map(|s| s.text().trim().to_string())
+        .collect::<Vec<_>>()
+        .join(" ")
+}

src/ast.rs

@@ -26,10 +26,6 @@ mod support {
     use super::{AstNode, AstToken};
     use crate::{SyntaxElement, SyntaxKind, SyntaxToken};
 
-    pub(super) fn first<N: AstNode, NN: AstNode>(parent: &N) -> Option<NN> {
-        parent.syntax().children().find_map(|n| NN::cast(n))
-    }
-
     pub(super) fn nth<N: AstNode, NN: AstNode>(parent: &N, n: usize) -> Option<NN> {
         parent.syntax().children().flat_map(NN::cast).nth(n)
     }

src/ast/tokens.rs

@@ -45,13 +45,17 @@ macro_rules! ast_tokens {
 
 ast_tokens! {
     TOKEN_WHITESPACE => Whitespace,
-    TOKEN_COMMENT => Comment,
+    TOKEN_COMMENT => Comment: {
+        pub fn text(&self) -> &str {
+            self.syntax().text().strip_prefix('#').unwrap()
+        }
+    },
     TOKEN_FLOAT => Float: {
         pub fn value(&self) -> Result<f64, num::ParseFloatError> {
             self.syntax().text().parse()
         }
     },
-    TOKEN_INTEGER => Integer: { 
+    TOKEN_INTEGER => Integer: {
         pub fn value(&self) -> Result<i64, num::ParseIntError> {
             self.syntax().text().parse()
         }

src/lib.rs

@@ -11,7 +11,7 @@ pub use self::{kinds::SyntaxKind, tokenizer::tokenize};
 
 use ast::AstNode;
 use parser::ParseError;
-use rowan::{ast::AstNode as OtherAstNode, GreenNode};
+use rowan::GreenNode;
 pub use rowan::{NodeOrToken, TextRange, TextSize, TokenAtOffset, WalkEvent};
 
 use self::tokenizer::Tokenizer;
@@ -98,7 +98,7 @@ macro_rules! match_ast {
     (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
 
     (match ($node:expr) {
-        $( ast::$ast:ident($it:ident) => $res:expr, )*
+        $( ast::$ast:ident($it:pat) => $res:expr, )*
         _ => $catch_all:expr $(,)?
     }) => {{
         $( if let Some($it) = ast::$ast::cast($node.clone()) { $res } else )*