rfmt 1.6.0 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 538d3def9f35a241acf4089c99a2d905acb03f77a097a2ad88b19e47c2009d16
-  data.tar.gz: 28e0cbe935992181c22056f16c1a2edb52fac170a80400905e2cee90f0eec1ce
+  metadata.gz: 5f1d0fa5ba56d10568e9dd3625974abc815350c4c6c2ff03d5114d8c38aae9a1
+  data.tar.gz: 4b6256a168e7be4a70c162a26bea0983fd6397397224cd1953abbe9cc1cbd01b
 SHA512:
-  metadata.gz: 4169b3f6b4d2dae45fbddec1b299ca2f787b8a854999d03c3f63307e9af2ef5007076d74f96852e3624e3a0d269b9480c2fbe8064bb707e57863df71e7d88618
-  data.tar.gz: fc8cd1357d92ca01a5829248a58bc42f4f731f4122274950e98d17daa7a51c0a53a0e35c3cbbc2132b8a489d474adaf4489be05e9ec41f37c4412d6da1e27ece
+  metadata.gz: a90b0b5f699c21e3e5aebd5f33ce71c152694a3cc51c812d2ffda946d2250a7714ae572ab9e7538531386e09b91210aa50f5e4de49e1d11234afd6803525ede4
+  data.tar.gz: ab5588dfe3b5035e444219ad218756b475d964f18b47fdb78311593ba964c7c4436856abca58a13fc2e799eaa7d85815e6e70be39e6d0e083d9c7951c3867553

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## [Unreleased]
 
+## [1.6.2] - 2026-04-24
+
+Minor stability refinements on top of the 1.6.x architecture release. See the 1.6.1 notes below for the feature set this series delivers.
+
+## [1.6.1] - 2026-04-24
+
+Follow-up release consolidating the 1.6.0 architecture work.
+
+### Rule-based formatter
+
+The rule-based `format/` pipeline (`Formatter`, `Registry`, `Rule`) is the canonical formatting path, replacing the legacy monolithic emitter. Rules covering body indentation (`StatementsRule`), singleton classes (`SingletonClassRule`), and variable writes (`VariableWriteRule`) ship as part of the default registry. The Intermediate Representation (IR) module decouples parsing from emission for composability and testability.
+
+### Method chain reformatting
+
+Multi-line method chains can be reformatted from aligned style (indented under the first dot) to indented style (one level beyond the receiver), preserving the source's base indent. The pass is wired into the fallback path for resilience.
+
+### Printer optimizations
+
+The printer carries a pre-computed indent cache and inline hints for the hot path; `reformat_chain_lines` has been deduplicated across rules and uses `Cow<str>` to avoid allocations on pass-through.
+
+### Editor integration
+
+Setup guides for VSCode, Neovim, Helix, Emacs, and Zed land in the repository; every editor uses the Ruby LSP addon system, so there are no editor-specific plugins to maintain. The README's Editor Integration section replaces the previous "Coming Soon" placeholder with a VSCode quick start.
+
 ## [1.6.0] - 2026-04-23
 
 ### Added

data/Cargo.lock

@@ -1251,7 +1251,7 @@ checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "rfmt"
-version = "1.6.0"
+version = "1.6.2"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.6.0"
+version = "1.6.2"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"

data/ext/rfmt/src/doc/printer.rs

@@ -108,6 +108,18 @@ impl<'a> Printer<'a> {
             self.output.push('\n');
         }
 
+        // Strip trailing whitespace on every line.
+        //
+        // When a `hardline` lands inside an `indent(...)` region and is
+        // immediately followed by another newline (because the user wrote a
+        // blank line between statements), the printer first emits
+        // `"\n" + indent_spaces`, then the next newline runs over those
+        // spaces — leaving them on the otherwise-blank line. Stripping here
+        // is simpler and safer than threading "next is newline?" state
+        // through `Doc::Line` emission, and it also removes stray spaces
+        // that show up after inline trailing comments.
+        strip_trailing_line_whitespace(&mut self.output);
+
         std::mem::take(&mut self.output)
     }
 
@@ -388,6 +400,31 @@ impl<'a> Printer<'a> {
     }
 }
 
+/// Strips trailing ASCII spaces/tabs from every line in `s` in-place.
+///
+/// Heredoc content embedded in `Doc::Text` also passes through this pass;
+/// trailing whitespace inside a heredoc body is extremely rare in real Ruby
+/// code and Rails projects universally run with `Layout/TrailingWhitespace`,
+/// so trimming unconditionally matches project conventions.
+fn strip_trailing_line_whitespace(buf: &mut String) {
+    if !buf.bytes().any(|b| b == b' ' || b == b'\t') {
+        return;
+    }
+
+    let mut out = String::with_capacity(buf.len());
+    for line in buf.split_inclusive('\n') {
+        // `split_inclusive` keeps the trailing `\n` attached to the line.
+        if let Some(stripped) = line.strip_suffix('\n') {
+            out.push_str(stripped.trim_end_matches([' ', '\t']));
+            out.push('\n');
+        } else {
+            // Final line without a trailing newline.
+            out.push_str(line.trim_end_matches([' ', '\t']));
+        }
+    }
+    *buf = out;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/ext/rfmt/src/format/formatter.rs

@@ -6,7 +6,7 @@
 //! 3. Apply rules to generate Doc IR
 //! 4. Print Doc IR to string using Printer
 
-use crate::ast::{Node, NodeType};
+use crate::ast::{CommentType, Node, NodeType};
 use crate::config::Config;
 use crate::doc::{concat, hardline, Doc, Printer};
 use crate::error::Result;
@@ -120,16 +120,40 @@ impl Formatter {
             let child_doc = self.format_node(child, ctx)?;
             docs.push(child_doc);
 
-            // Add newlines between statements
+            // Add newlines between statements. Mirrors the logic in
+            // `format_statements` so top-level programs and node bodies
+            // agree on how comments participate in blank-line preservation:
+            //  1) subtract comment-occupied lines from the blank-line count
+            //     so a standalone comment in the gap doesn't inflate it;
+            //  2) deduct one more when the gap contains a `=begin/=end`
+            //     block comment, because that comment's `literalline`
+            //     emission already supplies one of the line breaks.
             if let Some(next_child) = children.get(i + 1) {
                 let current_end_line = child.location.end_line;
                 let next_start_line = next_child.location.start_line;
                 let line_diff = next_start_line.saturating_sub(current_end_line);
 
-                // Add 1 hardline if consecutive, 2 hardlines (1 blank line) if there was a gap
                 docs.push(hardline());
+
                 if line_diff > 1 {
-                    docs.push(hardline());
+                    let (comment_lines_in_gap, gap_has_block): (usize, bool) = ctx
+                        .get_comment_indices_in_range(current_end_line + 1, next_start_line)
+                        .filter_map(|idx| ctx.get_comment(idx).cloned())
+                        .fold((0usize, false), |(lines, had_block), c| {
+                            let span =
+                                c.location.end_line.saturating_sub(c.location.start_line) + 1;
+                            let is_block = matches!(c.comment_type, CommentType::Block);
+                            (lines + span, had_block || is_block)
+                        });
+                    let mut blank_lines = line_diff
+                        .saturating_sub(1)
+                        .saturating_sub(comment_lines_in_gap);
+                    if gap_has_block && blank_lines > 0 {
+                        blank_lines -= 1;
+                    }
+                    if blank_lines >= 1 {
+                        docs.push(hardline());
+                    }
                 }
             }
         }

data/ext/rfmt/src/format/rule.rs

@@ -3,8 +3,8 @@
 //! This module defines the core FormatRule trait that all formatting rules implement,
 //! along with shared helper functions for common formatting patterns.
 
-use crate::ast::Node;
-use crate::doc::{concat, hardline, leading_comment, trailing_comment, Doc};
+use crate::ast::{CommentType, Node};
+use crate::doc::{concat, hardline, leading_comment, literalline, text, trailing_comment, Doc};
 use crate::error::Result;
 
 use super::context::FormatContext;
@@ -46,6 +46,33 @@ struct CommentRef {
     idx: usize,
     start_line: usize,
     end_line: usize,
+    is_block: bool,
+}
+
+/// Emits a single leading comment at the configured indent context.
+///
+/// `=begin ... =end` (Prism's `EmbDocComment`) must start in column 0;
+/// nesting it under an `indent(...)` wrapper would emit `=begin` at the
+/// body indent, which is a *syntax error*. Use `literalline` to break out
+/// of the current indent so the `=begin` and `=end` markers — and every
+/// intermediate line — land at column 0. The following `hardline` then
+/// restores the normal indented flow for the code that comes after.
+///
+/// Prism's location slice for an embdoc includes the trailing newline that
+/// sits after `=end`; strip it so that our own `hardline` doesn't produce
+/// a double line break.
+fn push_leading_comment(docs: &mut Vec<Doc>, comment_text: &str, is_block: bool) {
+    if is_block {
+        let body = comment_text
+            .strip_suffix('\n')
+            .and_then(|s| s.strip_suffix('\r').or(Some(s)))
+            .unwrap_or(comment_text);
+        docs.push(literalline());
+        docs.push(text(body.to_string()));
+        docs.push(hardline());
+    } else {
+        docs.push(leading_comment(comment_text, true));
+    }
 }
 
 /// Formats leading comments before a given line.
@@ -68,6 +95,7 @@ pub fn format_leading_comments(ctx: &mut FormatContext, line: usize) -> Doc {
                 idx,
                 start_line: c.location.start_line,
                 end_line: c.location.end_line,
+                is_block: matches!(c.comment_type, CommentType::Block),
             })
         })
         .collect();
@@ -90,7 +118,7 @@ pub fn format_leading_comments(ctx: &mut FormatContext, line: usize) -> Doc {
         }
 
         if let Some(comment) = ctx.get_comment(cref.idx) {
-            docs.push(leading_comment(&comment.text, true));
+            push_leading_comment(&mut docs, &comment.text, cref.is_block);
         }
         last_end_line = Some(cref.end_line);
         indices_to_mark.push(cref.idx);
@@ -175,6 +203,7 @@ pub fn format_comments_before_end(
                         idx,
                         start_line: c.location.start_line,
                         end_line: c.location.end_line,
+                        is_block: matches!(c.comment_type, CommentType::Block),
                     })
                 } else {
                     None
@@ -188,10 +217,28 @@ pub fn format_comments_before_end(
     }
 
     let mut docs: Vec<Doc> = vec![hardline()];
+    // Preserve the blank line that separated the body's last content from
+    // the first trailing comment. Without this, a construct like
+    //
+    //   def foo
+    //     body
+    //                          <- blank line
+    //     # trailing annotation
+    //   end
+    //
+    // collapses to `body\n# trailing annotation\nend`. Detect the case
+    // heuristically: if the source line immediately above the first
+    // standalone comment is blank, emit an extra hardline.
+    if let Some(first) = standalone_refs.first() {
+        if first.start_line > 1 && is_line_blank(ctx.source(), first.start_line - 1) {
+            docs.push(hardline());
+        }
+    }
     let mut last_end_line: Option<usize> = None;
     let mut indices_to_mark: Vec<usize> = Vec::with_capacity(standalone_refs.len());
 
-    for cref in &standalone_refs {
+    let last_idx = standalone_refs.len().saturating_sub(1);
+    for (i, cref) in standalone_refs.iter().enumerate() {
         // Preserve blank lines between comments
         if let Some(prev_end) = last_end_line {
             let gap = cref.start_line.saturating_sub(prev_end);
@@ -201,7 +248,26 @@ pub fn format_comments_before_end(
         }
 
         if let Some(comment) = ctx.get_comment(cref.idx) {
-            docs.push(leading_comment(&comment.text, true));
+            // The caller always emits its own `hardline + "end"` right after
+            // us, so the last comment must *not* also emit its own trailing
+            // newline — doing so produces a spurious blank line between the
+            // comment and the `end` keyword.
+            let hard_line_after = i != last_idx;
+            if cref.is_block {
+                let body = comment
+                    .text
+                    .strip_suffix('\n')
+                    .and_then(|s| s.strip_suffix('\r').or(Some(s)))
+                    .unwrap_or(&comment.text)
+                    .to_string();
+                docs.push(literalline());
+                docs.push(text(body));
+                if hard_line_after {
+                    docs.push(hardline());
+                }
+            } else {
+                docs.push(leading_comment(&comment.text, hard_line_after));
+            }
         }
         last_end_line = Some(cref.end_line);
         indices_to_mark.push(cref.idx);
@@ -233,6 +299,7 @@ pub fn format_remaining_comments(ctx: &mut FormatContext, last_code_line: usize)
                 idx,
                 start_line: c.location.start_line,
                 end_line: c.location.end_line,
+                is_block: matches!(c.comment_type, CommentType::Block),
             })
         })
         .collect();
@@ -247,18 +314,41 @@ pub fn format_remaining_comments(ctx: &mut FormatContext, last_code_line: usize)
     let mut indices_to_mark: Vec<usize> = Vec::with_capacity(comment_refs.len());
 
     for cref in &comment_refs {
-        // Preserve blank lines
+        // Preserve blank lines. On the first iteration we must emit *at
+        // least one* hardline to separate the first remaining comment from
+        // the main document's last token (otherwise an orphan comment whose
+        // `start_line <= last_code_line` would concatenate onto whatever
+        // ended the output — producing e.g. `end# comment…` when a block's
+        // internal comments fall through to this tail handler). Round-tripping
+        // the already-formatted output must still be idempotent, so we
+        // cap the emission at the number of line breaks visible in the
+        // source: 1 for an adjacent comment, N for N-1 blank lines above it.
         let gap = cref.start_line.saturating_sub(last_end_line);
 
-        // Only add newlines if not the first comment or if there's a gap
-        if !is_first || gap > 0 {
+        if is_first {
+            let hardlines_to_emit = gap.max(1);
+            for _ in 0..hardlines_to_emit {
+                docs.push(hardline());
+            }
+        } else if gap > 0 {
             for _ in 0..gap.max(1) {
                 docs.push(hardline());
             }
         }
 
         if let Some(comment) = ctx.get_comment(cref.idx) {
-            docs.push(leading_comment(&comment.text, false));
+            if cref.is_block {
+                let body = comment
+                    .text
+                    .strip_suffix('\n')
+                    .and_then(|s| s.strip_suffix('\r').or(Some(s)))
+                    .unwrap_or(&comment.text)
+                    .to_string();
+                docs.push(literalline());
+                docs.push(text(body));
+            } else {
+                docs.push(leading_comment(&comment.text, false));
+            }
         }
         last_end_line = cref.end_line;
         is_first = false;
@@ -298,15 +388,46 @@ pub fn format_statements(
         let child_doc = format_child(child, ctx, registry)?;
         docs.push(child_doc);
 
-        // Add newlines between statements
+        // Add newlines between statements. A pure line-number diff would add
+        // a blank-line hardline whenever two consecutive statements sit on
+        // lines that are more than 1 apart — but that gap may be occupied
+        // by one or more standalone comments, each of which gets emitted as
+        // a leading comment of the next statement and already supplies its
+        // own line break. Subtract the lines consumed by comments so we
+        // only preserve *actually* blank lines between statements.
         if let Some(next_child) = node.children.get(i + 1) {
             let current_end_line = child.location.end_line;
             let next_start_line = next_child.location.start_line;
             let line_diff = next_start_line.saturating_sub(current_end_line);
 
             docs.push(hardline());
+
             if line_diff > 1 {
-                docs.push(hardline());
+                let (comment_lines_in_gap, gap_has_block): (usize, bool) = ctx
+                    .get_comment_indices_in_range(current_end_line + 1, next_start_line)
+                    .filter_map(|idx| ctx.get_comment(idx).cloned())
+                    .fold((0usize, false), |(lines, had_block), c| {
+                        let span = c.location.end_line.saturating_sub(c.location.start_line) + 1;
+                        let is_block = matches!(c.comment_type, CommentType::Block);
+                        (lines + span, had_block || is_block)
+                    });
+                // `line_diff - 1` is the count of lines strictly between the
+                // two statements. Subtract comment-occupied lines to get the
+                // count of truly blank lines.
+                let mut blank_lines = line_diff
+                    .saturating_sub(1)
+                    .saturating_sub(comment_lines_in_gap);
+                // A block comment (`=begin/=end`) is emitted via
+                // `literalline + text + hardline`. The leading `literalline`
+                // already supplies one line break, so the normal
+                // blank-line hardline added here would produce one extra
+                // blank line above `=begin`. Deduct one.
+                if gap_has_block && blank_lines > 0 {
+                    blank_lines -= 1;
+                }
+                if blank_lines >= 1 {
+                    docs.push(hardline());
+                }
             }
         }
     }
@@ -314,24 +435,47 @@ pub fn format_statements(
     Ok(concat(docs))
 }
 
+/// Returns the number of leading space/tab characters on the line containing `offset`.
+///
+/// The source text extracted by `FormatContext::extract_source` starts at the node's
+/// offset and does not include the whitespace that precedes the first line in the
+/// original source. `Doc::Text` is printed verbatim without re-indenting embedded
+/// newlines, so any reformatting that emits a multi-line string must include the
+/// original leading indent itself.
+pub fn line_leading_indent(source: &str, offset: usize) -> usize {
+    let offset = offset.min(source.len());
+    let line_start = source[..offset].rfind('\n').map(|p| p + 1).unwrap_or(0);
+    source.as_bytes()[line_start..offset]
+        .iter()
+        .take_while(|&&b| b == b' ' || b == b'\t')
+        .count()
+}
+
 /// Reformats multiline method chain text with indented style.
 ///
 /// Converts aligned method chains to indented style:
 /// - First line is kept as-is (trimmed at end)
-/// - Subsequent lines starting with `.` or `&.` are re-indented with one level of indentation
+/// - Subsequent lines starting with `.` or `&.` are re-indented to
+///   `base_indent + indent_width` spaces
 ///
-/// Returns `Cow::Borrowed` when no transformation is needed to avoid allocation.
+/// `base_indent` is the column at which the first line starts in the original source
+/// (obtain via `line_leading_indent`). Because `Doc::Text` is printed verbatim without
+/// re-indenting embedded newlines, this indent must be included in the returned string.
 ///
-/// # Arguments
-/// * `source_text` - The source text containing a method chain
-/// * `indent_width` - The number of spaces for one level of indentation
+/// Returns `Cow::Borrowed` when no transformation is needed to avoid allocation.
 ///
 /// # Example
 /// ```text
-/// Input (indent_width=2):  "foo.bar\n                  .baz"
-/// Output:                  "foo.bar\n  .baz"
+/// Input (base_indent=4, indent_width=2):
+///   "foo.bar\n                  .baz"
+/// Output:
+///   "foo.bar\n      .baz"
 /// ```
-pub fn reformat_chain_lines(source_text: &str, indent_width: usize) -> std::borrow::Cow<'_, str> {
+pub fn reformat_chain_lines(
+    source_text: &str,
+    base_indent: usize,
+    indent_width: usize,
+) -> std::borrow::Cow<'_, str> {
     use std::borrow::Cow;
 
     let lines: Vec<&str> = source_text.lines().collect();
@@ -339,6 +483,21 @@ pub fn reformat_chain_lines(source_text: &str, indent_width: usize) -> std::borr
         return Cow::Borrowed(source_text);
     }
 
+    // Skip reformatting when the first line opens a new scope (a `{` brace
+    // lambda, a `do` block, or a `do |params|` block). The `.method` lines
+    // that follow are chain continuations *inside the block body*, not of
+    // the outer call — re-indenting them relative to the outer
+    // `base_indent` collapses the nested chain one level to the left and
+    // breaks the visual structure of the block body.
+    //
+    // This deliberately keeps the reformat conservative: for a top-level
+    // `User.active.where(...)` chain, line 1 ends with an identifier so
+    // we still rewrite aligned → indented as PR #100 intended.
+    let first_line = lines[0].trim_end();
+    if first_line.ends_with('{') || first_line.ends_with(" do") || first_line.ends_with('|') {
+        return Cow::Borrowed(source_text);
+    }
+
     // Check if there are actual chain continuation lines (. or &.)
     let has_chain = lines[1..].iter().any(|l| {
         let t = l.trim_start();
@@ -350,7 +509,7 @@ pub fn reformat_chain_lines(source_text: &str, indent_width: usize) -> std::borr
     }
 
     // Build the indented chain with pre-allocated capacity
-    let chain_indent = " ".repeat(indent_width);
+    let chain_indent = " ".repeat(base_indent + indent_width);
     let mut result = String::with_capacity(source_text.len());
     result.push_str(lines[0].trim_end());
 
@@ -369,6 +528,45 @@ pub fn reformat_chain_lines(source_text: &str, indent_width: usize) -> std::borr
     Cow::Owned(result)
 }
 
+/// Returns true when the given 1-based `line` in `source` contains only
+/// whitespace (or is empty). Returns false for any line that has code or
+/// a comment.
+fn is_line_blank(source: &str, line: usize) -> bool {
+    let mut current = 1usize;
+    let mut line_start = 0usize;
+    for (i, b) in source.bytes().enumerate() {
+        if current == line {
+            let end = source[i..].find('\n').map_or(source.len(), |n| i + n);
+            return source[line_start..end]
+                .bytes()
+                .all(|b| b == b' ' || b == b'\t' || b == b'\r');
+        }
+        if b == b'\n' {
+            current += 1;
+            line_start = i + 1;
+        }
+    }
+    false
+}
+
+/// Removes at most one trailing `\n` (optionally preceded by a single `\r`)
+/// from `s`. Spaces, tabs, and any additional preceding newlines are
+/// preserved.
+///
+/// This is used by source-extracting rules (FallbackRule, CallRule,
+/// VariableWriteRule) to strip the terminator-line newline that Prism
+/// includes in node extents for constructs like
+/// `foo(<<~HEREDOC)\n…\nHEREDOC\n`. A full `trim_end` would also eat any
+/// blank separator line that happens to fall inside the node's range,
+/// collapsing the spacing between consecutive statements.
+pub fn strip_one_trailing_newline(s: &str) -> &str {
+    if let Some(rest) = s.strip_suffix('\n') {
+        rest.strip_suffix('\r').unwrap_or(rest)
+    } else {
+        s
+    }
+}
+
 /// Marks comments within a line range as emitted.
 ///
 /// This is used when source text is extracted directly, as any comments
@@ -528,28 +726,51 @@ mod tests {
     #[test]
     fn test_reformat_chain_lines_single_line() {
         let input = "foo.bar.baz";
-        let result = reformat_chain_lines(input, 2);
+        let result = reformat_chain_lines(input, 0, 2);
         assert_eq!(result, "foo.bar.baz");
     }
 
     #[test]
     fn test_reformat_chain_lines_multiline_chain() {
         let input = "foo.bar\n                  .baz\n                  .qux";
-        let result = reformat_chain_lines(input, 2);
+        let result = reformat_chain_lines(input, 0, 2);
         assert_eq!(result, "foo.bar\n  .baz\n  .qux");
     }
 
     #[test]
     fn test_reformat_chain_lines_safe_navigation() {
         let input = "foo&.bar\n                  &.baz";
-        let result = reformat_chain_lines(input, 2);
+        let result = reformat_chain_lines(input, 0, 2);
         assert_eq!(result, "foo&.bar\n  &.baz");
     }
 
     #[test]
     fn test_reformat_chain_lines_no_chain() {
         let input = "foo(\n  arg1,\n  arg2\n)";
-        let result = reformat_chain_lines(input, 2);
+        let result = reformat_chain_lines(input, 0, 2);
         assert_eq!(result, input);
     }
+
+    #[test]
+    fn test_reformat_chain_lines_preserves_base_indent() {
+        // Simulates a chain inside a 4-space-indented method body:
+        // the caller must include base_indent so the printed continuation
+        // lines up with `base_indent + indent_width` columns.
+        let input = "foo.bar\n                  .baz\n                  .qux";
+        let result = reformat_chain_lines(input, 4, 2);
+        assert_eq!(result, "foo.bar\n      .baz\n      .qux");
+    }
+
+    #[test]
+    fn test_line_leading_indent_counts_spaces_and_tabs() {
+        let source = "def foo\n    bar\n\tbaz\nqux\n";
+        let bar = source.find("bar").unwrap();
+        let baz = source.find("baz").unwrap();
+        let qux = source.find("qux").unwrap();
+        assert_eq!(line_leading_indent(source, bar), 4);
+        assert_eq!(line_leading_indent(source, baz), 1);
+        assert_eq!(line_leading_indent(source, qux), 0);
+        // Out-of-range offset is clamped.
+        assert_eq!(line_leading_indent(source, usize::MAX), 0);
+    }
 }