feat: support more inline comments

Author: kamadorueda

src/alejandra_engine/src/builder.rs

@@ -182,9 +182,7 @@ fn format(
                 // { }
                 rnix::SyntaxKind::NODE_ATTR_SET => crate::rules::attr_set::rule,
                 // a $op b
-                rnix::SyntaxKind::NODE_BIN_OP => {
-                    crate::rules::bin_op_and_or_default::rule
-                }
+                rnix::SyntaxKind::NODE_BIN_OP => crate::rules::bin_op::rule,
                 // ${a} (interpolation but for NODE_SELECT)
                 rnix::SyntaxKind::NODE_DYNAMIC => crate::rules::dynamic::rule,
                 // $identifier
@@ -213,9 +211,7 @@ fn format(
                 // let { }
                 rnix::SyntaxKind::NODE_LEGACY_LET => crate::rules::default,
                 // a or b
-                rnix::SyntaxKind::NODE_OR_DEFAULT => {
-                    crate::rules::bin_op_and_or_default::rule
-                }
+                rnix::SyntaxKind::NODE_OR_DEFAULT => crate::rules::bin_op::rule,
                 // ( a )
                 rnix::SyntaxKind::NODE_PAREN => crate::rules::paren::rule,
                 // a | a ? b

src/alejandra_engine/src/children2.rs

@@ -0,0 +1,67 @@
+use std::collections::LinkedList;
+
+pub(crate) enum Trivia {
+    Comment(String),
+    Newlines(usize),
+}
+
+pub(crate) struct Child {
+    pub element: rnix::SyntaxElement,
+
+    pub inline_comment:     Option<String>,
+    pub has_inline_comment: bool,
+
+    pub trivialities:     LinkedList<Trivia>,
+    pub has_comments:     bool,
+    pub has_trivialities: bool,
+}
+
+pub(crate) fn new(
+    build_ctx: &crate::builder::BuildCtx,
+    node: &rnix::SyntaxNode,
+) -> std::collections::linked_list::IntoIter<Child> {
+    let mut children = crate::children::Children::new(build_ctx, node);
+
+    let mut elements = LinkedList::new();
+
+    while let Some(element) = children.get_next() {
+        let mut inline_comment = None;
+        let mut trivialities = LinkedList::new();
+
+        children.drain_trivia(|element| match element {
+            crate::children::Trivia::Comment(text) => {
+                if trivialities.is_empty() && text.starts_with('#') {
+                    inline_comment = Some(text);
+                } else {
+                    trivialities.push_back(Trivia::Comment(text));
+                }
+            }
+            crate::children::Trivia::Whitespace(text) => {
+                let newlines = crate::utils::count_newlines(&text);
+
+                if newlines > 0 {
+                    trivialities.push_back(Trivia::Newlines(newlines))
+                }
+            }
+        });
+
+        let has_inline_comment = inline_comment.is_some();
+        let has_comments = trivialities
+            .iter()
+            .any(|trivia| matches!(trivia, Trivia::Comment(_)));
+        let has_trivialities = !trivialities.is_empty();
+
+        elements.push_back(Child {
+            element,
+
+            inline_comment,
+            has_inline_comment,
+
+            trivialities,
+            has_comments,
+            has_trivialities,
+        })
+    }
+
+    elements.into_iter()
+}

src/alejandra_engine/src/lib.rs

@@ -29,6 +29,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 pub(crate) mod builder;
 pub(crate) mod children;
+pub(crate) mod children2;
 pub mod format;
 pub(crate) mod parsers;
 pub(crate) mod position;

src/alejandra_engine/src/parsers/apply.rs

@@ -1,5 +1,3 @@
-pub(crate) mod apply;
 pub(crate) mod assert_or_with;
-pub(crate) mod bin_op;
 pub(crate) mod if_else;
 pub(crate) mod pattern;

src/alejandra_engine/src/parsers/bin_op.rs

@@ -4,35 +4,48 @@ pub(crate) fn rule(
 ) -> std::collections::LinkedList<crate::builder::Step> {
     let mut steps = std::collections::LinkedList::new();
 
-    let parsed = crate::parsers::apply::Apply::parse(build_ctx, node);
+    let mut children = crate::children2::new(build_ctx, node);
+
+    let first = children.next().unwrap();
+    let second = children.next().unwrap();
 
     let vertical = build_ctx.vertical
-        || !parsed.comments_after_left.is_empty()
-        || parsed.has_newlines_after_left;
+        || first.has_inline_comment
+        || first.has_trivialities
+        || second.has_inline_comment
+        || second.has_trivialities;
 
-    // left_expression
+    // first
     if vertical {
-        steps.push_back(crate::builder::Step::FormatWider(
-            parsed.left_expression,
-        ));
+        steps.push_back(crate::builder::Step::FormatWider(first.element));
     } else {
-        steps.push_back(crate::builder::Step::Format(parsed.left_expression));
+        steps.push_back(crate::builder::Step::Format(first.element));
     }
 
-    // comments_after_left
-    let has_comments_after_left = !parsed.comments_after_left.is_empty();
-    for text in parsed.comments_after_left {
+    if let Some(text) = first.inline_comment {
+        steps.push_back(crate::builder::Step::Whitespace);
+        steps.push_back(crate::builder::Step::Comment(text));
         steps.push_back(crate::builder::Step::NewLine);
         steps.push_back(crate::builder::Step::Pad);
-        steps.push_back(crate::builder::Step::Comment(text));
     }
 
-    // right_expression
+    for trivia in first.trivialities {
+        match trivia {
+            crate::children2::Trivia::Comment(text) => {
+                steps.push_back(crate::builder::Step::NewLine);
+                steps.push_back(crate::builder::Step::Pad);
+                steps.push_back(crate::builder::Step::Comment(text));
+            }
+            crate::children2::Trivia::Newlines(_) => {}
+        }
+    }
+
+    // second
     if vertical {
-        if !has_comments_after_left
-            && !parsed.has_newlines_after_left
+        if !first.has_inline_comment
+            && !first.has_trivialities
             && matches!(
-                parsed.right_expression.kind(),
+                second.element.kind(),
                 rnix::SyntaxKind::NODE_ATTR_SET
                     | rnix::SyntaxKind::NODE_LIST
                     | rnix::SyntaxKind::NODE_PAREN
@@ -44,12 +57,10 @@ pub(crate) fn rule(
             steps.push_back(crate::builder::Step::NewLine);
             steps.push_back(crate::builder::Step::Pad);
         };
-        steps.push_back(crate::builder::Step::FormatWider(
-            parsed.right_expression,
-        ));
+        steps.push_back(crate::builder::Step::FormatWider(second.element));
     } else {
         steps.push_back(crate::builder::Step::Whitespace);
-        steps.push_back(crate::builder::Step::Format(parsed.right_expression));
+        steps.push_back(crate::builder::Step::Format(second.element));
     }
 
     steps