rfmt 1.6.0 → 1.6.2

data/ext/rfmt/src/format/rules/begin.rs

@@ -13,6 +13,107 @@ use crate::format::rule::{
     format_child, format_leading_comments, format_statements, format_trailing_comment, FormatRule,
 };
 
+/// True when this BeginNode represents an implicit begin (the source does not
+/// start with the `begin` keyword) AND carries at least one rescue/else/ensure
+/// clause. Such bodies need the rescue/else/ensure keywords emitted at the
+/// outer (e.g. `def`) indent level rather than at the body indent level.
+pub(crate) fn is_implicit_begin_with_clauses(node: &Node, ctx: &FormatContext) -> bool {
+    if node.node_type != NodeType::BeginNode {
+        return false;
+    }
+    let has_clause = node.children.iter().any(|c| {
+        matches!(
+            c.node_type,
+            NodeType::RescueNode | NodeType::EnsureNode | NodeType::ElseNode
+        )
+    });
+    if !has_clause {
+        return false;
+    }
+    ctx.extract_source(node)
+        .map(|s| !s.trim_start().starts_with("begin"))
+        .unwrap_or(false)
+}
+
+/// Emits the body of a construct (def/class/module/block) whose body is an
+/// implicit BeginNode with rescue/else/ensure clauses.
+///
+/// The returned Doc is meant to sit between the opening line (e.g. `def foo`)
+/// and a trailing `hardline + text("end")` emitted by the caller. Body
+/// statements are wrapped in `indent`, while rescue/else/ensure clause
+/// keywords are emitted at the caller's current indent level so that they
+/// align with the opener instead of the body.
+pub(crate) fn format_implicit_begin_body(
+    node: &Node,
+    ctx: &mut FormatContext,
+    registry: &RuleRegistry,
+) -> Result<Doc> {
+    let mut body_children: Vec<&Node> = Vec::new();
+    let mut clause_children: Vec<&Node> = Vec::new();
+
+    for child in &node.children {
+        match child.node_type {
+            NodeType::RescueNode | NodeType::EnsureNode | NodeType::ElseNode => {
+                clause_children.push(child);
+            }
+            _ => {
+                body_children.push(child);
+            }
+        }
+    }
+
+    let mut docs: Vec<Doc> = Vec::with_capacity(clause_children.len() * 2 + 2);
+
+    if !body_children.is_empty() {
+        let mut body_docs: Vec<Doc> = Vec::with_capacity(body_children.len() * 2 + 1);
+        body_docs.push(hardline());
+        for (i, child) in body_children.iter().enumerate() {
+            if i > 0 {
+                body_docs.push(hardline());
+            }
+            body_docs.push(format_child(child, ctx, registry)?);
+        }
+        docs.push(indent(concat(body_docs)));
+    }
+
+    for clause in clause_children {
+        docs.push(hardline());
+        docs.push(format_begin_clause(clause, ctx, registry)?);
+    }
+
+    Ok(concat(docs))
+}
+
+/// Emits a rescue/else/ensure clause the way the enclosing begin expects.
+///
+/// `format_child` sends ElseNode to `FallbackRule`, which slices the source
+/// between `else` and the next keyword — but Prism's `ElseNode.location`
+/// stretches into the *following* clause's keyword (`ensure`, or the
+/// begin's `end`). Emitting that slice as-is duplicates whichever keyword
+/// comes after, producing e.g. `else\n  y\nensure\nensure\n  z\nend` or
+/// `else\n  y\nend\nend`. Handle ElseNode explicitly so we emit only
+/// `else\n  body` and let the caller (or the subsequent EnsureRule) write
+/// the following keyword.
+fn format_begin_clause(
+    clause: &Node,
+    ctx: &mut FormatContext,
+    registry: &RuleRegistry,
+) -> Result<Doc> {
+    if !matches!(clause.node_type, NodeType::ElseNode) {
+        return format_child(clause, ctx, registry);
+    }
+
+    let mut docs: Vec<Doc> = Vec::with_capacity(3);
+    docs.push(text("else"));
+    for child in &clause.children {
+        if matches!(child.node_type, NodeType::StatementsNode) {
+            let body_doc = format_statements(child, ctx, registry)?;
+            docs.push(indent(concat(vec![hardline(), body_doc])));
+        }
+    }
+    Ok(concat(docs))
+}
+
 /// Rule for formatting begin/rescue/ensure blocks.
 pub struct BeginRule;
 
@@ -71,14 +172,36 @@ fn format_explicit_begin(
     }
 
     docs.push(text("begin"));
-    docs.push(hardline());
 
+    let mut body_children: Vec<&Node> = Vec::new();
+    let mut clause_children: Vec<&Node> = Vec::new();
     for child in &node.children {
-        let child_doc = format_child(child, ctx, registry)?;
-        docs.push(child_doc);
+        match child.node_type {
+            NodeType::RescueNode | NodeType::EnsureNode | NodeType::ElseNode => {
+                clause_children.push(child);
+            }
+            _ => body_children.push(child),
+        }
+    }
+
+    if !body_children.is_empty() {
+        let mut body_docs: Vec<Doc> = Vec::with_capacity(body_children.len() * 2 + 1);
+        body_docs.push(hardline());
+        for (i, child) in body_children.iter().enumerate() {
+            if i > 0 {
+                body_docs.push(hardline());
+            }
+            body_docs.push(format_child(child, ctx, registry)?);
+        }
+        docs.push(indent(concat(body_docs)));
+    }
+
+    for clause in &clause_children {
         docs.push(hardline());
+        docs.push(format_begin_clause(clause, ctx, registry)?);
     }
 
+    docs.push(hardline());
     docs.push(text("end"));
 
     // Trailing comment on end line
@@ -122,6 +245,15 @@ fn format_rescue(
     // But since we're in Doc IR, we handle this at the caller level
     let _ = dedent_level;
 
+    // Emit any standalone comments that sit immediately before the rescue
+    // keyword. Without this they would be picked up as leading comments of
+    // the first statement inside the rescue body, which visually moves an
+    // annotation like `# retry on flaky errors` *into* the rescue branch.
+    let leading = format_leading_comments(ctx, node.location.start_line);
+    if !leading.is_empty() {
+        docs.push(leading);
+    }
+
     docs.push(text("rescue"));
 
     // Extract exception classes and variable from source
@@ -167,26 +299,32 @@ fn format_rescue(
         }
     }
 
-    docs.push(hardline());
-
-    // Emit rescue body and handle subsequent rescue nodes
+    // Emit rescue body (indented under the rescue keyword) and subsequent
+    // chained rescue clauses (at the same indent level as this rescue).
+    //
+    // The hardline lives INSIDE the `indent(...)` wrap so that the body's
+    // first statement lands at `caller_indent + indent_width`, matching the
+    // indentation applied by hardlines later inside `format_statements`.
+    let mut body_stmts: Option<&Node> = None;
+    let mut subsequent: Option<&Node> = None;
     for child in &node.children {
         match &child.node_type {
-            NodeType::StatementsNode => {
-                let body_doc = format_statements(child, ctx, registry)?;
-                docs.push(indent(body_doc));
-            }
-            NodeType::RescueNode => {
-                // Emit subsequent rescue clause
-                let rescue_doc = format_rescue(child, ctx, registry, dedent_level)?;
-                docs.push(rescue_doc);
-            }
-            _ => {
-                // Skip exception classes and variable (already handled above)
-            }
+            NodeType::StatementsNode => body_stmts = Some(child),
+            NodeType::RescueNode => subsequent = Some(child),
+            _ => {}
         }
     }
 
+    if let Some(stmts) = body_stmts {
+        let body_doc = format_statements(stmts, ctx, registry)?;
+        docs.push(indent(concat(vec![hardline(), body_doc])));
+    }
+
+    if let Some(sub) = subsequent {
+        docs.push(hardline());
+        docs.push(format_rescue(sub, ctx, registry, dedent_level)?);
+    }
+
     Ok(concat(docs))
 }
 
@@ -207,18 +345,19 @@ fn format_ensure(
     }
 
     docs.push(text("ensure"));
-    docs.push(hardline());
 
-    // Emit ensure body statements
+    // Emit ensure body. The hardline lives INSIDE the `indent(...)` wrap so
+    // that every body statement — including the first one — lands at
+    // `caller_indent + indent_width`.
     for child in &node.children {
         match &child.node_type {
             NodeType::StatementsNode => {
                 let body_doc = format_statements(child, ctx, registry)?;
-                docs.push(indent(body_doc));
+                docs.push(indent(concat(vec![hardline(), body_doc])));
             }
             _ => {
                 let child_doc = format_child(child, ctx, registry)?;
-                docs.push(indent(child_doc));
+                docs.push(indent(concat(vec![hardline(), child_doc])));
             }
         }
     }

data/ext/rfmt/src/format/rules/body_end.rs

@@ -10,9 +10,11 @@ use crate::format::context::FormatContext;
 use crate::format::registry::RuleRegistry;
 use crate::format::rule::{
     format_child, format_comments_before_end, format_leading_comments, format_trailing_comment,
-    is_structural_node,
+    is_structural_node, mark_comments_in_range_emitted,
 };
 
+use super::begin::{format_implicit_begin_body, is_implicit_begin_with_clauses};
+
 /// Configuration for formatting a body-with-end construct.
 pub struct BodyEndConfig<'a> {
     /// The keyword (e.g., "class", "module", "def")
@@ -51,6 +53,79 @@ pub fn format_body_end(
         docs.push(leading);
     }
 
+    // Single-line form: `def foo = expr` (endless), `def foo; body; end`,
+    // `class Foo; end`, etc. Emit the source verbatim instead of forcing
+    // a multi-line `def ... end` layout. This preserves Ruby 3+ endless
+    // methods and the `Error < StandardError; end` exception-hierarchy
+    // idiom that is pervasive in Rails code.
+    if start_line == end_line {
+        if let Some(source_text) = ctx.extract_source(config.node) {
+            docs.push(text(source_text.to_string()));
+            mark_comments_in_range_emitted(ctx, start_line, end_line);
+
+            let trailing = format_trailing_comment(ctx, end_line);
+            if !trailing.is_empty() {
+                docs.push(trailing);
+            }
+            return Ok(concat(docs));
+        }
+    }
+
+    // Body children (filtered) — reused by both the multi-line header path
+    // below and the normal path further down.
+    let body_children: Vec<&Node> = config
+        .node
+        .children
+        .iter()
+        .filter(|c| {
+            if config.skip_same_line_children && c.location.start_line == start_line {
+                return false;
+            }
+            !is_structural_node(c)
+        })
+        .collect();
+
+    // Multi-line header form: `def foo(a, # c1\n  b, # c2\n  c) # c3`.
+    //
+    // Rebuilding the header from `parameters_text` + a reconstructed `)`
+    // drops the closing line's trailing comment and, worse, lets comments
+    // that the params slice already contains be re-picked up by the later
+    // `format_trailing_comment` + `format_leading_comments` calls. The net
+    // effect is that the first inline comment is duplicated, the rest are
+    // moved into the body, and the file stops being idempotent because the
+    // relocated comments keep accumulating every format pass. Detect this
+    // case early and emit the header verbatim from source.
+    let params_text = config.node.metadata.get("parameters_text");
+    let header_is_multiline = params_text.is_some_and(|t| t.contains('\n'));
+    if header_is_multiline {
+        let header_end_line = body_children
+            .first()
+            .map(|c| c.location.start_line.saturating_sub(1))
+            .unwrap_or(start_line);
+        if header_end_line >= start_line {
+            let header_end_offset = line_end_offset(ctx.source(), header_end_line);
+            if let Some(header_src) = ctx
+                .source()
+                .get(config.node.location.start_offset..header_end_offset)
+            {
+                docs.push(text(header_src.to_string()));
+                mark_comments_in_range_emitted(ctx, start_line, header_end_line + 1);
+
+                // Body + "end" (same as the normal path; no header trailing
+                // comment — it's already baked into the source slice above).
+                push_body_and_end(
+                    &mut docs,
+                    ctx,
+                    registry,
+                    &body_children,
+                    start_line,
+                    end_line,
+                )?;
+                return Ok(concat(docs));
+            }
+        }
+    }
+
     // 2. Build header: "keyword ..."
     let mut header_parts: Vec<Doc> = vec![text(config.keyword), text(" ")];
     header_parts.extend((config.header_builder)(config.node));
@@ -62,28 +137,21 @@ pub fn format_body_end(
         docs.push(trailing);
     }
 
-    // 4. Body (children), skipping structural nodes
-    let mut body_docs: Vec<Doc> = Vec::new();
-    let mut has_body_content = false;
-
-    for child in &config.node.children {
-        // Skip nodes on the same line as definition (name, parameters, etc.)
-        if config.skip_same_line_children && child.location.start_line == start_line {
-            continue;
+    // 4. Body (children), skipping structural nodes — already collected above.
+
+    // Special case: body is an implicit BeginNode carrying rescue/else/ensure.
+    // In that case the clause keywords must align with the opener, not with
+    // the body statements — so we split the body and clause emission instead
+    // of wrapping everything in a single `indent(...)`.
+    if body_children.len() == 1 && is_implicit_begin_with_clauses(body_children[0], ctx) {
+        docs.push(format_implicit_begin_body(body_children[0], ctx, registry)?);
+    } else if !body_children.is_empty() {
+        let mut body_docs: Vec<Doc> = Vec::with_capacity(body_children.len() * 2);
+        for child in &body_children {
+            let child_doc = format_child(child, ctx, registry)?;
+            body_docs.push(hardline());
+            body_docs.push(child_doc);
         }
-        if is_structural_node(child) {
-            continue;
-        }
-
-        has_body_content = true;
-
-        // Format the child node using recursive rule dispatch
-        let child_doc = format_child(child, ctx, registry)?;
-        body_docs.push(hardline());
-        body_docs.push(child_doc);
-    }
-
-    if has_body_content {
         docs.push(indent(concat(body_docs)));
     }
 
@@ -107,3 +175,59 @@ pub fn format_body_end(
 
     Ok(concat(docs))
 }
+
+/// Returns the byte offset of the character immediately past the end of the
+/// given 1-based line (i.e. the index of the trailing `\n`, or `source.len()`
+/// if the line has no trailing newline).
+fn line_end_offset(source: &str, line: usize) -> usize {
+    let mut current = 1;
+    for (i, b) in source.bytes().enumerate() {
+        if b == b'\n' {
+            if current == line {
+                return i;
+            }
+            current += 1;
+        }
+    }
+    source.len()
+}
+
+/// Emits the body (possibly an implicit BeginNode with rescue clauses) and the
+/// trailing `end` keyword. Extracted so that both the standard
+/// header-reconstruction path and the multi-line source-extraction path can
+/// share the emission logic.
+fn push_body_and_end(
+    docs: &mut Vec<Doc>,
+    ctx: &mut FormatContext,
+    registry: &RuleRegistry,
+    body_children: &[&Node],
+    start_line: usize,
+    end_line: usize,
+) -> Result<()> {
+    if body_children.len() == 1 && is_implicit_begin_with_clauses(body_children[0], ctx) {
+        docs.push(format_implicit_begin_body(body_children[0], ctx, registry)?);
+    } else if !body_children.is_empty() {
+        let mut body_docs: Vec<Doc> = Vec::with_capacity(body_children.len() * 2);
+        for child in body_children {
+            let child_doc = format_child(child, ctx, registry)?;
+            body_docs.push(hardline());
+            body_docs.push(child_doc);
+        }
+        docs.push(indent(concat(body_docs)));
+    }
+
+    let comments_before_end = format_comments_before_end(ctx, start_line, end_line);
+    if !comments_before_end.is_empty() {
+        docs.push(indent(comments_before_end));
+    }
+
+    docs.push(hardline());
+    docs.push(text("end"));
+
+    let end_trailing = format_trailing_comment(ctx, end_line);
+    if !end_trailing.is_empty() {
+        docs.push(end_trailing);
+    }
+
+    Ok(())
+}

data/ext/rfmt/src/format/rules/call.rs

@@ -5,14 +5,17 @@
 //! - Calls with blocks: `foo.bar do ... end` or `foo.bar { ... }`
 //! - Method chains: `foo.bar.baz`
 
+use std::borrow::Cow;
+
 use crate::ast::{Node, NodeType};
-use crate::doc::{concat, hardline, indent, text, Doc};
+use crate::doc::{align, concat, hardline, indent, text, Doc};
 use crate::error::Result;
 use crate::format::context::FormatContext;
 use crate::format::registry::RuleRegistry;
 use crate::format::rule::{
-    format_child, format_leading_comments, format_statements, format_trailing_comment,
-    mark_comments_in_range_emitted, reformat_chain_lines, FormatRule,
+    format_child, format_comments_before_end, format_leading_comments, format_statements,
+    format_trailing_comment, line_leading_indent, mark_comments_in_range_emitted,
+    reformat_chain_lines, strip_one_trailing_newline, FormatRule,
 };
 
 /// Rule for formatting method calls.
@@ -100,11 +103,25 @@ fn format_call(node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) ->
         .unwrap_or(false);
 
     if !has_block {
-        // Simple call - use source extraction with chain reformatting
+        // Simple call - use source extraction with chain reformatting.
+        //
+        // A CallNode that carries a heredoc argument (e.g.
+        // `query(<<~SQL)\n  …\nSQL`) reports its end_offset past the
+        // heredoc terminator's trailing newline. Leaving that newline in
+        // the emitted `Doc::Text` combines with the later `hardline + end`
+        // or inter-statement hardline to produce a spurious blank line.
+        // Strip at most one trailing newline so this doesn't happen; using
+        // the full `trim_end` here would instead eat a blank separator line
+        // that legitimately belongs between statements.
         if let Some(source_text) = ctx.extract_source(node) {
-            let reformatted =
-                reformat_chain_lines(source_text, ctx.config().formatting.indent_width);
-            docs.push(text(reformatted));
+            let base_indent = line_leading_indent(ctx.source(), node.location.start_offset);
+            let reformatted = reformat_chain_lines(
+                source_text,
+                base_indent,
+                ctx.config().formatting.indent_width,
+            );
+            let trimmed = strip_one_trailing_newline(&reformatted);
+            docs.push(text(trimmed.to_string()));
         }
 
         // Mark comments in this range as emitted (they're in source extraction)
@@ -123,16 +140,26 @@ fn format_call(node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) ->
     let block_node = node.children.last().unwrap();
     let block_style = detect_block_style(block_node, ctx);
 
-    // Emit the call part (receiver.method(args)) from source with chain reformatting
+    // Emit the call part (receiver.method(args)) from source with chain
+    // reformatting. Track whether reformatting actually fired so the block
+    // body can be re-aligned to match the chain's new depth.
     let call_end_offset = block_node.location.start_offset;
-    if let Some(call_text) = ctx
+    let chain_reformatted = if let Some(call_text) = ctx
         .source()
         .get(node.location.start_offset..call_end_offset)
     {
-        let reformatted =
-            reformat_chain_lines(call_text.trim_end(), ctx.config().formatting.indent_width);
+        let base_indent = line_leading_indent(ctx.source(), node.location.start_offset);
+        let reformatted = reformat_chain_lines(
+            call_text.trim_end(),
+            base_indent,
+            ctx.config().formatting.indent_width,
+        );
+        let changed = matches!(reformatted, Cow::Owned(_));
         docs.push(text(reformatted));
-    }
+        changed
+    } else {
+        false
+    };
 
     // Mark comments in the call part (before block) as emitted
     // This includes trailing comments that are part of the extracted source
@@ -142,16 +169,21 @@ fn format_call(node: &Node, ctx: &mut FormatContext, registry: &RuleRegistry) ->
         block_node.location.start_line,
     );
 
-    // Format the block
-    match block_style {
-        BlockStyle::DoEnd => {
-            let block_doc = format_do_end_block(block_node, ctx, registry)?;
-            docs.push(block_doc);
-        }
-        BlockStyle::Braces => {
-            let block_doc = format_brace_block(block_node, ctx, registry)?;
-            docs.push(block_doc);
-        }
+    // Format the block. When the receiver's chain was re-indented, the
+    // `do`-line ends up one level below `base_indent` instead of at
+    // `base_indent` itself, so the default `indent(body)` wrap inside the
+    // block formatter now places the body *at* the chain depth rather than
+    // one level below it (and the `end` keyword floats up to `base_indent`).
+    // Push both down with `Align` so the `do…end` body is indented relative
+    // to the chain's last line, matching what a human would write.
+    let block_doc = match block_style {
+        BlockStyle::DoEnd => format_do_end_block(block_node, ctx, registry)?,
+        BlockStyle::Braces => format_brace_block(block_node, ctx, registry)?,
+    };
+    if chain_reformatted {
+        docs.push(align(ctx.config().formatting.indent_width, block_doc));
+    } else {
+        docs.push(block_doc);
     }
 
     Ok(concat(docs))
@@ -201,9 +233,16 @@ fn format_do_end_block(
                 break;
             }
             NodeType::BeginNode => {
-                // Block with rescue/ensure/else
-                let body_doc = format_child(child, ctx, registry)?;
-                docs.push(indent(concat(vec![hardline(), body_doc])));
+                // Block with rescue/else/ensure needs the clause keywords at
+                // the block opener's indent level, not at the body indent.
+                if super::begin::is_implicit_begin_with_clauses(child, ctx) {
+                    docs.push(super::begin::format_implicit_begin_body(
+                        child, ctx, registry,
+                    )?);
+                } else {
+                    let body_doc = format_child(child, ctx, registry)?;
+                    docs.push(indent(concat(vec![hardline(), body_doc])));
+                }
                 break;
             }
             _ => {
@@ -212,6 +251,23 @@ fn format_do_end_block(
         }
     }
 
+    // Emit any standalone comments between the last body statement and `end`.
+    //
+    // Without this the orphan comments inside a `do…end` block (e.g. the
+    // commented-out config stanzas in a generated `spec_helper.rb`) never
+    // get claimed by any `format_leading_comments` call, fall through to
+    // `format_remaining_comments` at the end of the file, and get emitted
+    // *after* the block's own `end` — producing `end# comment…` with no
+    // separator and dropping the body indent.
+    let comments_before_end = format_comments_before_end(
+        ctx,
+        block_node.location.start_line,
+        block_node.location.end_line,
+    );
+    if !comments_before_end.is_empty() {
+        docs.push(indent(comments_before_end));
+    }
+
     // Emit 'end'
     docs.push(hardline());
     docs.push(text("end"));

data/ext/rfmt/src/format/rules/fallback.rs

@@ -10,8 +10,8 @@ use crate::error::Result;
 use crate::format::context::FormatContext;
 use crate::format::registry::RuleRegistry;
 use crate::format::rule::{
-    format_leading_comments, format_trailing_comment, mark_comments_in_range_emitted,
-    reformat_chain_lines, FormatRule,
+    format_leading_comments, format_trailing_comment, line_leading_indent,
+    mark_comments_in_range_emitted, reformat_chain_lines, strip_one_trailing_newline, FormatRule,
 };
 
 /// Fallback rule that extracts source text directly.
@@ -36,11 +36,25 @@ impl FormatRule for FallbackRule {
             docs.push(leading);
         }
 
-        // Extract source text with chain reformatting
+        // Extract source text with chain reformatting.
+        //
+        // Nodes such as ConstantWriteNode for `CONST = <<~HEREDOC ... HEREDOC`
+        // report an end_offset that sits past the heredoc terminator's
+        // newline. Preserving that newline verbatim combines with the
+        // surrounding `format_statements` hardline to produce a spurious
+        // blank line before the following statement or `end`. Strip at
+        // most one trailing newline (not all trailing whitespace, which
+        // could swallow an intentional blank line captured by the node's
+        // extent).
         if let Some(source_text) = ctx.extract_source(node) {
-            let reformatted =
-                reformat_chain_lines(source_text, ctx.config().formatting.indent_width);
-            docs.push(text(reformatted));
+            let base_indent = line_leading_indent(ctx.source(), node.location.start_offset);
+            let reformatted = reformat_chain_lines(
+                source_text,
+                base_indent,
+                ctx.config().formatting.indent_width,
+            );
+            let trimmed = strip_one_trailing_newline(&reformatted);
+            docs.push(text(trimmed.to_string()));
 
             // Mark any comments within this node's range as emitted
             // (they are included in the source extraction)