feat: support more inline comments

CHANGELOG.md

@@ -17,6 +17,15 @@ Types of changes
 - Security in case of vulnerabilities.
 -->
 
+### Added
+
+- Binary operators now support inline comments:
+  ```diff
+  -      ++
+  -      # subsections go last
+  +      ++ # subsections go last
+  ```
+
 ### Changed
 
 - Linux binaries now use [mimalloc](https://github.com/microsoft/mimalloc)

src/alejandra_engine/src/builder.rs

@@ -176,9 +176,7 @@ fn format(
                 // a b
                 rnix::SyntaxKind::NODE_APPLY => crate::rules::apply::rule,
                 // assert a; b
-                rnix::SyntaxKind::NODE_ASSERT => {
-                    crate::rules::assert_or_with::rule
-                }
+                rnix::SyntaxKind::NODE_ASSERT => crate::rules::scoped::rule,
                 // { }
                 rnix::SyntaxKind::NODE_ATTR_SET => crate::rules::attr_set::rule,
                 // a $op b
@@ -239,9 +237,7 @@ fn format(
                 // !a
                 rnix::SyntaxKind::NODE_UNARY_OP => crate::rules::default,
                 // with a; b
-                rnix::SyntaxKind::NODE_WITH => {
-                    crate::rules::assert_or_with::rule
-                }
+                rnix::SyntaxKind::NODE_WITH => crate::rules::scoped::rule,
                 kind => {
                     panic!(
                         "Missing rule for {:?} at: {}",

src/alejandra_engine/src/parsers/mod.rs

@@ -1,3 +1,2 @@
-pub(crate) mod assert_or_with;
 pub(crate) mod if_else;
 pub(crate) mod pattern;

src/alejandra_engine/src/rules/mod.rs

@@ -1,5 +1,4 @@
 pub(crate) mod apply;
-pub(crate) mod assert_or_with;
 pub(crate) mod attr_set;
 pub(crate) mod bin_op;
 pub(crate) mod dynamic;
@@ -14,6 +13,7 @@ pub(crate) mod pat_bind;
 pub(crate) mod pat_entry;
 pub(crate) mod pattern;
 pub(crate) mod root;
+pub(crate) mod scoped;
 pub(crate) mod select;
 pub(crate) mod string;
 pub(crate) mod string_interpol;

src/alejandra_engine/src/rules/scoped.rs

@@ -0,0 +1,115 @@
+pub(crate) fn rule(
+    build_ctx: &crate::builder::BuildCtx,
+    node: &rnix::SyntaxNode,
+) -> std::collections::LinkedList<crate::builder::Step> {
+    let mut steps = std::collections::LinkedList::new();
+
+    let mut children = crate::children2::new(build_ctx, node);
+
+    let first = children.next().unwrap();
+    let second = children.next().unwrap();
+    let third = children.next().unwrap();
+    let fourth = children.next().unwrap();
+
+    let vertical = build_ctx.vertical
+        || first.has_inline_comment
+        || first.has_trivialities
+        || second.has_inline_comment
+        || second.has_trivialities
+        || third.has_inline_comment
+        || third.has_trivialities
+        || fourth.has_inline_comment
+        || fourth.has_trivialities;
+
+    // first
+    steps.push_back(crate::builder::Step::Format(first.element));
+
+    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);
+    } else if first.has_comments {
+        steps.push_back(crate::builder::Step::NewLine);
+        steps.push_back(crate::builder::Step::Pad);
+    } else {
+        steps.push_back(crate::builder::Step::Whitespace);
+    }
+
+    for trivia in first.trivialities {
+        match trivia {
+            crate::children2::Trivia::Comment(text) => {
+                steps.push_back(crate::builder::Step::Comment(text));
+                steps.push_back(crate::builder::Step::NewLine);
+                steps.push_back(crate::builder::Step::Pad);
+            }
+            crate::children2::Trivia::Newlines(_) => {}
+        }
+    }
+
+    // second
+    if vertical {
+        steps.push_back(crate::builder::Step::FormatWider(second.element));
+    } else {
+        steps.push_back(crate::builder::Step::Format(second.element));
+    }
+
+    // third
+    steps.push_back(crate::builder::Step::Format(third.element));
+
+    if let Some(text) = third.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);
+    }
+
+    for trivia in third.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(_) => {}
+        }
+    }
+
+    // fourth
+    if vertical {
+        if matches!(
+            fourth.element.kind(),
+            rnix::SyntaxKind::NODE_ASSERT | rnix::SyntaxKind::NODE_WITH
+        ) {
+            steps.push_back(crate::builder::Step::NewLine);
+            steps.push_back(crate::builder::Step::Pad);
+            steps.push_back(crate::builder::Step::FormatWider(fourth.element));
+        } else if third.has_inline_comment
+            || third.has_comments
+            || !matches!(
+                fourth.element.kind(),
+                rnix::SyntaxKind::NODE_ATTR_SET
+                    | rnix::SyntaxKind::NODE_IDENT
+                    | rnix::SyntaxKind::NODE_PAREN
+                    | rnix::SyntaxKind::NODE_LET_IN
+                    | rnix::SyntaxKind::NODE_LIST
+                    | rnix::SyntaxKind::NODE_LITERAL
+                    | rnix::SyntaxKind::NODE_STRING
+            )
+        {
+            steps.push_back(crate::builder::Step::Indent);
+            steps.push_back(crate::builder::Step::NewLine);
+            steps.push_back(crate::builder::Step::Pad);
+            steps.push_back(crate::builder::Step::FormatWider(fourth.element));
+            steps.push_back(crate::builder::Step::Dedent);
+        } else {
+            steps.push_back(crate::builder::Step::Whitespace);
+            steps.push_back(crate::builder::Step::FormatWider(fourth.element));
+        }
+    } else {
+        steps.push_back(crate::builder::Step::Whitespace);
+        steps.push_back(crate::builder::Step::Format(fourth.element));
+    }
+
+    steps
+}

src/alejandra_engine/tests/cases/assert/in

@@ -1,8 +1,12 @@
 [
-  (assert       b;       c)
-  (assert       b; /*b*/ c)
-  (assert /*a*/ b;       c)
-  (assert /*a*/ b; /*b*/ c)
+  (assert       b      ;       e)
+  (assert       b      ; /*d*/ e)
+  (assert       b /*c*/;       e)
+  (assert       b /*c*/; /*d*/ e)
+  (assert /*a*/ b      ;       e)
+  (assert /*a*/ b      ; /*d*/ e)
+  (assert /*a*/ b /*c*/;       e)
+  (assert /*a*/ b /*c*/; /*d*/ e)
   ( assert b; cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc )
   ( assert b;
   cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc )