Added support for the experimental pipe operators

Author: aftix

Diff for: Cargo.lock

@@ -6,7 +6,7 @@ license = "MIT"
 name = "rnix"
 readme = "README.md"
 repository = "https://github.com/nix-community/rnix-parser"
-version = "0.11.0"
+version = "0.11.1"
 
 [[bench]]
 harness = false

Diff for: Cargo.toml

@@ -19,6 +19,8 @@ pub enum BinOpKind {
     MoreOrEq,
     NotEqual,
     Or,
+    PipeRight,
+    PipeLeft,
 }
 
 impl BinOpKind {
@@ -43,6 +45,9 @@ impl BinOpKind {
             TOKEN_NOT_EQUAL => Some(BinOpKind::NotEqual),
             TOKEN_OR_OR => Some(BinOpKind::Or),
 
+            TOKEN_PIPE_RIGHT => Some(BinOpKind::PipeRight),
+            TOKEN_PIPE_LEFT => Some(BinOpKind::PipeLeft),
+
             _ => None,
         }
     }

Diff for: src/ast/operators.rs

@@ -66,6 +66,88 @@ mod tests {
     use super::*;
     use rowan::ast::AstNode;
 
+    #[test]
+    fn pipe_right() {
+        let s = "1 |> toString";
+
+        let parsed = Root::parse(s).ok();
+        assert!(parsed.is_ok(), "Failed to parse syntax `{s}`: {:?}", parsed);
+        let parsed = parsed.unwrap();
+
+        let nodes: Vec<_> = parsed.syntax().children().collect();
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(nodes[0].kind(), NODE_BIN_OP);
+
+        let op_children: Vec<_> = nodes[0].children().collect();
+        assert_eq!(op_children.len(), 2);
+        assert_eq!(op_children[0].kind(), NODE_LITERAL);
+        assert_eq!(op_children[1].kind(), NODE_IDENT);
+    }
+
+    #[test]
+    fn pipe_right_precedence() {
+        let s = "toString <| 1 + 1";
+
+        let parsed = Root::parse(s).ok();
+        assert!(parsed.is_ok(), "Failed to parse syntax `{s}`: {:?}", parsed);
+        let parsed = parsed.unwrap();
+
+        let nodes: Vec<_> = parsed.syntax().children().collect();
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(nodes[0].kind(), NODE_BIN_OP);
+
+        let op_children: Vec<_> = nodes[0].children().collect();
+        assert_eq!(op_children.len(), 2);
+        assert_eq!(op_children[0].kind(), NODE_BIN_OP);
+        assert_eq!(op_children[1].kind(), NODE_LITERAL);
+
+        let op_children: Vec<_> = op_children[0].children().collect();
+        assert_eq!(op_children.len(), 2);
+        assert_eq!(op_children[0].kind(), NODE_IDENT);
+        assert_eq!(op_children[1].kind(), NODE_LITERAL);
+    }
+
+    #[test]
+    fn pipe_left() {
+        let s = "toString <| 1";
+
+        let parsed = Root::parse(s).ok();
+        assert!(parsed.is_ok(), "Failed to parse syntax `{s}`: {:?}", parsed);
+        let parsed = parsed.unwrap();
+
+        let nodes: Vec<_> = parsed.syntax().children().collect();
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(nodes[0].kind(), NODE_BIN_OP);
+
+        let op_children: Vec<_> = nodes[0].children().collect();
+        assert_eq!(op_children.len(), 2);
+        assert_eq!(op_children[0].kind(), NODE_IDENT);
+        assert_eq!(op_children[1].kind(), NODE_LITERAL);
+    }
+
+    #[test]
+    fn pipe_left_precedence() {
+        let s = "1 + 1 |> toString";
+
+        let parsed = Root::parse(s).ok();
+        assert!(parsed.is_ok(), "Failed to parse syntax `{s}`: {:?}", parsed);
+        let parsed = parsed.unwrap();
+
+        let nodes: Vec<_> = parsed.syntax().children().collect();
+        assert_eq!(nodes.len(), 1);
+        assert_eq!(nodes[0].kind(), NODE_BIN_OP);
+
+        let op_children: Vec<_> = nodes[0].children().collect();
+        assert_eq!(op_children.len(), 2);
+        assert_eq!(op_children[0].kind(), NODE_LITERAL);
+        assert_eq!(op_children[1].kind(), NODE_BIN_OP);
+
+        let op_children: Vec<_> = op_children[1].children().collect();
+        assert_eq!(op_children.len(), 2);
+        assert_eq!(op_children[0].kind(), NODE_LITERAL);
+        assert_eq!(op_children[1].kind(), NODE_IDENT);
+    }
+
     #[test]
     fn comment() {
         let s = "# comment bruh

Diff for: src/ast/tokens.rs

@@ -54,6 +54,8 @@ pub enum SyntaxKind {
     TOKEN_MORE_OR_EQ,
     TOKEN_NOT_EQUAL,
     TOKEN_OR_OR,
+    TOKEN_PIPE_RIGHT,
+    TOKEN_PIPE_LEFT,
 
     // Identifiers and values
     TOKEN_FLOAT,

Diff for: src/kinds.rs

@@ -45,5 +45,7 @@ macro_rules! T {
     (>=)      => ($crate::SyntaxKind::TOKEN_MORE_OR_EQ);
     (!=)      => ($crate::SyntaxKind::TOKEN_NOT_EQUAL);
     (||)      => ($crate::SyntaxKind::TOKEN_OR_OR);
+    ("|>")      => ($crate::SyntaxKind::TOKEN_PIPE_RIGHT);
+    ("<|")      => ($crate::SyntaxKind::TOKEN_PIPE_LEFT);
     ($kind:ident) => ($crate::SyntaxKind::$kind);
 }

Diff for: src/macros.rs

@@ -583,8 +583,11 @@ where
 
         checkpoint
     }
+    fn parse_pipe(&mut self) -> Checkpoint {
+        self.parse_left_assoc(Self::parse_simple, T!["|>"] | T!["<|"])
+    }
     fn parse_fn(&mut self) -> Checkpoint {
-        let checkpoint = self.parse_simple();
+        let checkpoint = self.parse_pipe();
 
         while self.peek().map(|t| t.is_fn_arg()).unwrap_or(false) {
             self.start_node_at(checkpoint, NODE_APPLY);

Diff for: src/parser.rs

@@ -364,6 +364,10 @@ impl Tokenizer<'_> {
             '-' => TOKEN_SUB,
             '*' => TOKEN_MUL,
             '/' => TOKEN_DIV,
+            '<' if self.peek() == Some('|') => {
+                self.next().unwrap();
+                TOKEN_PIPE_LEFT
+            }
             '<' if kind == Some(IdentType::Store) => {
                 self.consume(is_valid_path_char);
                 if self.next() != Some('>') {
@@ -376,6 +380,10 @@ impl Tokenizer<'_> {
                 self.next().unwrap();
                 TOKEN_AND_AND
             }
+            '|' if self.peek() == Some('>') => {
+                self.next().unwrap();
+                TOKEN_PIPE_RIGHT
+            }
             '|' if self.peek() == Some('|') => {
                 self.next().unwrap();
                 TOKEN_OR_OR