From 2b718f27839d7063bccda187d8a8c6ff78d3eded Mon Sep 17 00:00:00 2001
From: Akseli Lukkarila <akseli.lukkarila@nitor.com>
Date: Tue, 15 Sep 2026 18:20:49 +0300
Subject: [PATCH] Slb: make trailing comment fixing opt-in and skip ignored
 paths

Moving a comment off a code line rewrites code, and the result often
reads worse than what was there, so the trailing rule is no longer part
of the default set. RuleSet::DEFAULT is every rule except that one, and
-T/--trailing turns it back on so it composes with -R and the config
rules list instead of replacing them. The rule gates checking as well as
fixing, so a default run no longer reports trailing comments either.

When a comment already sits directly above the code line, the trailing
comment is now reported but not moved. Moving it there put it in the
same comment block as the comment above, and the reflow then joined the
two into one sentence: a note reading "below threshold of 15" followed
by "6 chars" came out as "below threshold of 15 6 chars". Keeping the
moved line apart was tried first, by marking the break before the last
line of a comment block above code so the reflow could not join it away.
That cannot tell a moved annotation from a genuinely wrapped line, and
it stopped three fixtures reflowing their prose, so the conservative
report is what remains. The same check now also leaves a comment on a
line that closes a block comment alone, which avoids writing the moved
comment inside the block.

A run with -x also walked target/ and rewrote vendored C headers,
because the command line excludes replaced the built-in list rather than
adding to it, dropping target and node_modules along with it. They add
to it now. The walk also moved from walkdir to the ignore crate, so
paths the repository ignores are skipped, with -n/--no-ignore and the
use_gitignore config key to turn that off. The built-in excludes stay as
the safety net outside git repositories, where gitignore rules do not
apply.
---
 Cargo.lock                                  | 40 +++++++++
 Cargo.toml                                  |  1 +
 README.md                                   | 13 ++-
 cli-tools.toml                              | 12 ++-
 src/bin/semantic_line_breaks/config.rs      | 85 ++++++++++++++----
 src/bin/semantic_line_breaks/files.rs       | 89 +++++++++++++++---
 src/bin/semantic_line_breaks/main.rs        | 12 ++-
 src/lib.rs                                  | 15 ++++
 src/semantic_line_breaks/comments.rs        | 99 ++++++++++++++++++++-
 src/semantic_line_breaks/formatter.rs       | 72 ++++++++++++---
 src/semantic_line_breaks/regex_literals.rs  | 10 ++-
 src/semantic_line_breaks/types.rs           | 35 ++++++--
 tests/fixtures/sample_config.toml           |  2 +-
 tests/fixtures/slb/rust_doc_comments.out.rs |  3 +-
 tests/fixtures/slb/yaml_comments.out.yml    |  3 +-
 tests/slb_cli_tests.rs                      | 87 +++++++++++++++++-
 tests/slb_integration_tests.rs              |  8 +-
 17 files changed, 525 insertions(+), 61 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 009750e..d4bea7a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -237,6 +237,16 @@ dependencies = [
  "objc2",
 ]
 
+[[package]]
+name = "bstr"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f"
+dependencies = [
+ "memchr",
+ "serde_core",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -416,6 +426,7 @@ dependencies = [
  "encoding_rs",
  "futures",
  "git2",
+ "ignore",
  "indicatif",
  "itertools 0.15.0",
  "jiff",
@@ -1234,6 +1245,19 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "globset"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "h2"
 version = "0.4.19"
@@ -1556,6 +1580,22 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "ignore"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b69833ed729dc5aa7d19541d96d6cf8e9137194207a04916d658e43168402f"
+dependencies = [
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata",
+ "same-file",
+ "walkdir",
+ "winapi-util",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.14.2"
diff --git a/Cargo.toml b/Cargo.toml
index b0788e3..3c87926 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,6 +26,7 @@ dunce = "1.0.5"
 encoding_rs = "0.8.41"
 futures = "0.3.34"
 git2 = { version = "0.21.0", features = ["ssh", "https"] }
+ignore = "0.4.33"
 indicatif = { version = "0.18.6", features = ["tokio", "futures", "rayon"] }
 itertools = "0.15.0"
 num_cpus = "1.17.0"
diff --git a/README.md b/README.md
index ea62764..4f55c17 100644
--- a/README.md
+++ b/README.md
@@ -494,14 +494,19 @@ whenever the clause it introduces carries on past it,
 so the explanation or list starts on a line of its own.
 Text inside backticks, Markdown links, and inline formatting such as `**bold**`, `_italic_`,
 and `~~strikethrough~~` is never broken, and a span that was split by hand is joined back together.
-Semicolons are rewritten as separate sentences, and trailing comments are moved above the code.
+Semicolons are rewritten as separate sentences.
 An em dash becomes a period and a new sentence, or a colon where the text before it names what follows.
 A pair of dashes that encloses an aside becomes a pair of commas,
 and a dash that is kept never ends or starts a line.
 Aligned column blocks, such as the environment table of a usage comment, are left as they are.
 Slash-delimited regex literals are protected across supported source languages.
 When ambiguous slash syntax could hide a multiline string or comment, the remaining source is left unchanged.
+With `--trailing`, a comment sharing a line with code is moved onto its own line above it.
+That rule rewrites code lines and the result often reads worse than the original, so it is off by default.
+A trailing comment whose code line already has a comment above it is reported but not moved,
+since the two notes would be reflowed into one sentence.
 The line limit is read from project config files such as `.editorconfig`, `rustfmt.toml`, and `pyproject.toml`.
+Paths ignored by git are skipped, unless `--no-ignore` says otherwise.
 Files are checked in parallel, one worker per core unless `--jobs` says otherwise,
 and the report is printed in file order so a run is reproducible.
 The default mode reports violations and exits with code 1.
@@ -526,9 +531,11 @@ Options:
   -j, --join-sentences          Also pack consecutive short sentences up to the line limit
   -w, --width <N>               Maximum line length including indentation and comment marker (default: from project config or 120)
   -i, --ignore-project-config   Do not read the line length from project config files such as .editorconfig, rustfmt.toml, or pyproject.toml
-  -R, --rules <RULES>           Rules to enable (default: all) [possible values: too-long, mid-clause, semicolon, em-dash, trailing]
+  -R, --rules <RULES>           Rules to enable (default: every rule except trailing comments) [possible values: too-long, mid-clause, semicolon, em-dash, trailing]
+  -T, --trailing                Also move trailing comments to their own line above the code
   -e, --extensions <EXTENSION>  Only process files with these extensions
-  -x, --exclude <PATTERN>       Skip paths with a directory or file name equal to this text
+  -x, --exclude <PATTERN>       Skip paths with a directory or file name equal to this text, in addition to the default excludes
+  -n, --no-ignore               Do not skip paths ignored by git
   -t, --type <KIND>             Force the file kind, required with --stdin [possible values: rust, c, javascript, go, python, shell, toml, yaml, dockerfile, makefile, ruby, sql, lua, markdown]
   -s, --stdin                   Read text from stdin and write the formatted result to stdout
   -b, --word-break              Allow breaking at a plain word boundary when no clause boundary fits
diff --git a/cli-tools.toml b/cli-tools.toml
index 406c1ed..3e32dd3 100644
--- a/cli-tools.toml
+++ b/cli-tools.toml
@@ -366,7 +366,10 @@ replace = [
 # Read the line length from project config files such as .editorconfig, rustfmt.toml, and pyproject.toml
 # use_project_config = true
 
-# Rules to enable
+# Rules to enable.
+# The "trailing" rule moves a comment sharing a line with code onto its own line above.
+# It rewrites code lines and the result often reads worse than the original,
+# so it is off unless listed here or asked for with --trailing.
 # rules = ["too-long", "mid-clause", "semicolon", "em-dash", "trailing"]
 
 # Also pack consecutive short sentences up to the line limit
@@ -378,9 +381,14 @@ replace = [
 # Only process files with these extensions (empty means all supported file types)
 # extensions = []
 
-# Skip paths with a directory or file name equal to any of these
+# Skip paths with a directory or file name equal to any of these.
+# Setting this replaces the built-in list, while --exclude on the command line adds to it.
 # exclude = ["target", "node_modules", "build", "dist", "cdk.out", "coverage", ".venv", "venv", "vendor"]
 
+# Skip paths ignored by git, using .gitignore, .ignore, the global ignore file, and .git/info/exclude.
+# Only applies inside a git repository, elsewhere the exclude list above is the only filter.
+# use_gitignore = true
+
 # Abbreviations that do not end a sentence (added to the built-in list)
 # abbreviations = []
 
diff --git a/src/bin/semantic_line_breaks/config.rs b/src/bin/semantic_line_breaks/config.rs
index 7b7db81..78d1c12 100644
--- a/src/bin/semantic_line_breaks/config.rs
+++ b/src/bin/semantic_line_breaks/config.rs
@@ -52,6 +52,8 @@ pub struct SlbConfig {
     #[serde(default)]
     pub rules: Vec<String>,
     #[serde(default)]
+    pub use_gitignore: Option<bool>,
+    #[serde(default)]
     pub use_project_config: Option<bool>,
     #[serde(default)]
     pub verbose: bool,
@@ -85,6 +87,7 @@ pub struct Config {
     pub rules: RuleSet,
     pub stdin: bool,
     pub project_width: bool,
+    pub use_gitignore: bool,
     pub verbose: bool,
     pub width: Option<usize>,
 }
@@ -126,7 +129,9 @@ impl Config {
     ///
     /// Command line values win over the config file, which wins over the built-in defaults.
     /// Extension lists (abbreviations, directive prefixes, lowercase words) add to the defaults.
-    /// Clause starters and excludes replace the defaults when given.
+    /// Clause starters replace the defaults when given.
+    /// An exclude list in the config file replaces the defaults,
+    /// while command line excludes add to whichever list was resolved.
     ///
     /// # Errors
     /// Returns an error if the config file cannot be read or parsed or names an unknown rule.
@@ -139,9 +144,9 @@ impl Config {
     /// # Errors
     /// Returns an error if the user config names an unknown rule.
     pub fn from_args_and_user_config(args: &Args, user_config: SlbConfig) -> Result<Self> {
-        let rules = if args.rules.is_empty() {
+        let mut rules = if args.rules.is_empty() {
             if user_config.rules.is_empty() {
-                RuleSet::ALL
+                RuleSet::DEFAULT
             } else {
                 let kinds = user_config
                     .rules
@@ -156,16 +161,22 @@ impl Config {
         } else {
             RuleSet::from_kinds(&args.rules)
         };
+        if args.trailing {
+            rules.trailing_comment = true;
+        }
 
-        let exclude = if args.exclude.is_empty() {
-            if user_config.exclude.is_empty() {
-                cli_tools::strings_from(DEFAULT_EXCLUDES)
-            } else {
-                user_config.exclude
-            }
+        // The command line excludes narrow the walk further,
+        // so they add to the resolved list instead of replacing it.
+        let mut exclude = if user_config.exclude.is_empty() {
+            cli_tools::strings_from(DEFAULT_EXCLUDES)
         } else {
-            args.exclude.clone()
+            user_config.exclude
         };
+        for pattern in &args.exclude {
+            if !exclude.contains(pattern) {
+                exclude.push(pattern.clone());
+            }
+        }
 
         let extensions = if args.extensions.is_empty() {
             user_config.extensions
@@ -193,6 +204,7 @@ impl Config {
             rules,
             stdin: args.stdin,
             project_width: !args.ignore_project_config && user_config.use_project_config.unwrap_or(true),
+            use_gitignore: !args.no_ignore && user_config.use_gitignore.unwrap_or(true),
             verbose: args.verbose || user_config.verbose,
             width: args.width.or(user_config.width),
         })
@@ -308,7 +320,8 @@ mod test_config_from_args {
         assert!(config.rules.em_dash);
         assert!(!config.rules.trailing_comment);
         assert_eq!(config.width, Some(80));
-        assert_eq!(config.exclude, vec!["docs"]);
+        // The fixture config sets exclude = ["target"], and the command line value adds to it.
+        assert_eq!(config.exclude, vec!["target", "docs"]);
         assert!(config.project_width);
     }
 
@@ -319,7 +332,8 @@ mod test_config_from_args {
     fn fixture_config_values_are_merged_with_defaults() {
         let args = Args::try_parse_from(["slb", "--extensions", ".RS"]).expect("arguments should parse");
         let config = Config::from_args(&args).expect("config should build");
-        assert_eq!(config.rules, RuleSet::ALL);
+        // The fixture config lists every rule except the opt-in trailing comment rule.
+        assert_eq!(config.rules, RuleSet::DEFAULT);
         assert_eq!(config.exclude, vec!["target"]);
         assert_eq!(config.extensions, vec!["rs"]);
         assert_eq!(config.clause_starters, vec!["meanwhile"]);
@@ -358,7 +372,8 @@ mod test_config_merge {
     #[test]
     fn an_empty_user_config_gives_the_built_in_defaults() {
         let config = config(&["slb"], "").expect("config should build");
-        assert_eq!(config.rules, RuleSet::ALL);
+        assert_eq!(config.rules, RuleSet::DEFAULT);
+        assert!(!config.rules.trailing_comment);
         assert_eq!(config.exclude, cli_tools::strings_from(DEFAULT_EXCLUDES));
         assert!(config.extensions.is_empty());
         assert!(config.width.is_none());
@@ -398,7 +413,47 @@ mod test_config_merge {
         assert_eq!(config.exclude, vec!["generated"]);
 
         let overridden = config_with_exclude_option();
-        assert_eq!(overridden.exclude, vec!["docs"]);
+        assert_eq!(overridden.exclude, vec!["generated", "docs"]);
+    }
+
+    #[test]
+    fn a_command_line_exclude_adds_to_the_built_in_defaults() {
+        let config = config(&["slb", "--exclude", "docs"], "").expect("config should build");
+        assert!(config.exclude.contains(&"target".to_string()));
+        assert!(config.exclude.contains(&"node_modules".to_string()));
+        assert_eq!(config.exclude.last(), Some(&"docs".to_string()));
+    }
+
+    #[test]
+    fn a_command_line_exclude_already_in_the_list_is_not_repeated() {
+        let config = config(&["slb", "--exclude", "target"], "").expect("config should build");
+        assert_eq!(config.exclude, cli_tools::strings_from(DEFAULT_EXCLUDES));
+    }
+
+    #[test]
+    fn the_trailing_flag_adds_the_trailing_comment_rule() {
+        let default_rules = config(&["slb", "--trailing"], "").expect("config should build");
+        assert_eq!(default_rules.rules, RuleSet::ALL);
+
+        let with_rules = config(&["slb", "--rules", "semicolon", "--trailing"], "").expect("config should build");
+        assert!(with_rules.rules.semicolon);
+        assert!(with_rules.rules.trailing_comment);
+        assert!(!with_rules.rules.line_too_long);
+    }
+
+    #[test]
+    fn gitignore_is_used_unless_turned_off() {
+        assert!(config(&["slb"], "").expect("config should build").use_gitignore);
+        assert!(
+            !config(&["slb", "--no-ignore"], "")
+                .expect("config should build")
+                .use_gitignore
+        );
+        assert!(
+            !config(&["slb"], "[slb]\nuse_gitignore = false\n")
+                .expect("config should build")
+                .use_gitignore
+        );
     }
 
     /// Config with an exclude given on the command line and another one in the user config.
@@ -445,6 +500,6 @@ mod test_config_merge {
         assert_eq!(options.clause_starters, vec!["meanwhile"]);
         assert!(options.abbreviations.contains(&"approx.".to_string()));
         assert!(options.preserve_lowercase.contains(&"ffmpeg".to_string()));
-        assert_eq!(options.rules, RuleSet::ALL);
+        assert_eq!(options.rules, RuleSet::DEFAULT);
     }
 }
diff --git a/src/bin/semantic_line_breaks/files.rs b/src/bin/semantic_line_breaks/files.rs
index aa0b24a..b5eeaaa 100644
--- a/src/bin/semantic_line_breaks/files.rs
+++ b/src/bin/semantic_line_breaks/files.rs
@@ -1,12 +1,13 @@
 //! File discovery and filtering for `slb`.
 //!
-//! Walks the given input paths, skips excluded directories and unsupported file types,
+//! Walks the given input paths, skips ignored and excluded directories and unsupported file types,
 //! and applies the extension filter to build the list of files to process.
 
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use anyhow::Result;
-use walkdir::WalkDir;
+use ignore::WalkBuilder;
 
 use cli_tools::print_yellow;
 use cli_tools::semantic_line_breaks::FileKind;
@@ -28,6 +29,8 @@ pub fn collect_files(paths: &[PathBuf], config: &Config) -> Result<Vec<(PathBuf,
     };
 
     let excludes_have_separator = config.exclude.iter().any(|pattern| pattern.contains('/'));
+    // The filter runs on the walker's own threads, so it needs an owned handle on the excludes.
+    let excludes = Arc::new(config.exclude.clone());
     let mut files = Vec::new();
     for root in roots {
         if root.is_file() {
@@ -41,14 +44,25 @@ pub fn collect_files(paths: &[PathBuf], config: &Config) -> Result<Vec<(PathBuf,
             }
             continue;
         }
-        // The hidden and system directory skip does not apply to the root,
-        // so an explicitly given directory such as ".github" is still walked.
-        let walker = WalkDir::new(&root).into_iter().filter_entry(|entry| {
-            (entry.depth() == 0 || !cli_tools::should_skip_entry(entry))
-                && !is_excluded(entry.path(), config, excludes_have_separator)
-        });
+        // The standard filters are off so the hidden and system directory skip stays here,
+        // where it can exempt the root and let an explicitly given directory such as ".github" through.
+        // Gitignore rules only apply inside a git repository,
+        // so the exclude list stays as the safety net everywhere else.
+        let filter_excludes = Arc::clone(&excludes);
+        let walker = WalkBuilder::new(&root)
+            .standard_filters(false)
+            .git_ignore(config.use_gitignore)
+            .git_global(config.use_gitignore)
+            .git_exclude(config.use_gitignore)
+            .ignore(config.use_gitignore)
+            .parents(config.use_gitignore)
+            .filter_entry(move |entry| {
+                (entry.depth() == 0 || !cli_tools::should_skip_path(entry.path()))
+                    && !is_excluded(entry.path(), &filter_excludes, excludes_have_separator)
+            })
+            .build();
         for entry in walker.filter_map(Result::ok) {
-            if !entry.file_type().is_file() {
+            if !entry.file_type().is_some_and(|file_type| file_type.is_file()) {
                 continue;
             }
             let path = entry.into_path();
@@ -69,13 +83,13 @@ pub fn collect_files(paths: &[PathBuf], config: &Config) -> Result<Vec<(PathBuf,
 ///
 /// The whole path is only rendered as text when some pattern holds a separator,
 /// since that rendering costs an allocation for every entry of the walk.
-fn is_excluded(path: &Path, config: &Config, any_pattern_has_separator: bool) -> bool {
+fn is_excluded(path: &Path, excludes: &[String], any_pattern_has_separator: bool) -> bool {
     let path_string = if any_pattern_has_separator {
         path.to_string_lossy().replace('\\', "/")
     } else {
         String::new()
     };
-    config.exclude.iter().any(|pattern| {
+    excludes.iter().any(|pattern| {
         if pattern.contains('/') {
             path_string.contains(pattern.trim_matches('/'))
         } else {
@@ -115,7 +129,7 @@ mod test_helpers {
     /// Whether the path is excluded, working out the separator flag the way the walk does.
     pub fn excluded(path: &Path, config: &Config) -> bool {
         let any_pattern_has_separator = config.exclude.iter().any(|pattern| pattern.contains('/'));
-        super::is_excluded(path, config, any_pattern_has_separator)
+        super::is_excluded(path, &config.exclude, any_pattern_has_separator)
     }
 
     /// Build a config from command line arguments as the binary would.
@@ -237,6 +251,57 @@ mod test_collect_files {
         assert_eq!(collected_names(&files), vec!["lib.rs"]);
     }
 
+    #[test]
+    fn gitignored_files_are_not_walked() {
+        let directory = temporary_directory();
+        write(&directory, ".gitignore", "generated/\n");
+        write(&directory, "lib.rs", "// comment\n");
+        write(&directory, "generated/api.rs", "// comment\n");
+        std::process::Command::new("git")
+            .args(["init", "--quiet"])
+            .current_dir(directory.path())
+            .status()
+            .expect("git init should run");
+
+        let files = collect_files(&[directory.path().to_path_buf()], &config_with(vec![], vec![]))
+            .expect("collecting should succeed");
+
+        assert_eq!(collected_names(&files), vec!["lib.rs"]);
+    }
+
+    #[test]
+    fn gitignored_files_are_walked_with_the_ignore_rules_off() {
+        let directory = temporary_directory();
+        write(&directory, ".gitignore", "generated/\n");
+        write(&directory, "lib.rs", "// comment\n");
+        write(&directory, "generated/api.rs", "// comment\n");
+        std::process::Command::new("git")
+            .args(["init", "--quiet"])
+            .current_dir(directory.path())
+            .status()
+            .expect("git init should run");
+
+        let mut config = config_with(vec![], vec![]);
+        config.use_gitignore = false;
+
+        let files = collect_files(&[directory.path().to_path_buf()], &config).expect("collecting should succeed");
+
+        assert_eq!(collected_names(&files), vec!["api.rs", "lib.rs"]);
+    }
+
+    #[test]
+    fn a_gitignore_outside_a_repository_is_not_applied() {
+        let directory = temporary_directory();
+        write(&directory, ".gitignore", "generated/\n");
+        write(&directory, "lib.rs", "// comment\n");
+        write(&directory, "generated/api.rs", "// comment\n");
+
+        let files = collect_files(&[directory.path().to_path_buf()], &config_with(vec![], vec![]))
+            .expect("collecting should succeed");
+
+        assert_eq!(collected_names(&files), vec!["api.rs", "lib.rs"]);
+    }
+
     #[test]
     fn hidden_files_inside_a_directory_are_skipped() {
         let directory = temporary_directory();
diff --git a/src/bin/semantic_line_breaks/main.rs b/src/bin/semantic_line_breaks/main.rs
index 93ff010..f7aeb06 100644
--- a/src/bin/semantic_line_breaks/main.rs
+++ b/src/bin/semantic_line_breaks/main.rs
@@ -56,18 +56,26 @@ pub struct Args {
     #[arg(short, long)]
     ignore_project_config: bool,
 
-    /// Rules to enable (default: all)
+    /// Rules to enable (default: every rule except trailing comments)
     #[arg(short = 'R', long, value_delimiter = ',', value_name = "RULES")]
     rules: Vec<cli_tools::semantic_line_breaks::ViolationKind>,
 
+    /// Also move trailing comments to their own line above the code
+    #[arg(short = 'T', long)]
+    trailing: bool,
+
     /// Only process files with these extensions
     #[arg(short, long, num_args = 1, action = clap::ArgAction::Append, value_name = "EXTENSION")]
     extensions: Vec<String>,
 
-    /// Skip paths with a directory or file name equal to this text
+    /// Skip paths with a directory or file name equal to this text, in addition to the default excludes
     #[arg(short = 'x', long, num_args = 1, action = clap::ArgAction::Append, value_name = "PATTERN")]
     exclude: Vec<String>,
 
+    /// Do not skip paths ignored by git
+    #[arg(short = 'n', long)]
+    no_ignore: bool,
+
     /// Force the file kind, required with --stdin
     #[arg(short = 't', long = "type", value_name = "KIND")]
     kind: Option<FileKind>,
diff --git a/src/lib.rs b/src/lib.rs
index 94b9405..fc8d82b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -449,6 +449,13 @@ pub fn is_hidden_tokio(entry: &tokio::fs::DirEntry) -> bool {
     name_bytes.first() == Some(&b'.')
 }
 
+/// Check if a path is a hidden file or directory (name starts with '.')
+#[must_use]
+pub fn is_hidden_path(path: &Path) -> bool {
+    path.file_name()
+        .is_some_and(|name| name.as_encoded_bytes().first() == Some(&b'.'))
+}
+
 /// Check if entry is a system directory that should be skipped.
 /// Returns true for OS-specific directories like `$RECYCLE.BIN`, `.Spotlight-V100`, or `lost+found`.
 #[must_use]
@@ -577,6 +584,14 @@ pub fn should_skip_entry(entry: &walkdir::DirEntry) -> bool {
     is_hidden(entry) || is_system_directory(entry)
 }
 
+/// Check if a path should be skipped (hidden or system directory).
+/// Combines `is_hidden_path` and `is_system_directory_path` checks,
+/// for walkers that do not hand out a [`walkdir::DirEntry`].
+#[must_use]
+pub fn should_skip_path(path: &Path) -> bool {
+    is_hidden_path(path) || is_system_directory_path(path)
+}
+
 /// Check if directory is empty (contains no files or subdirectories)
 pub fn is_directory_empty(dir: &Path) -> bool {
     for entry in WalkDir::new(dir).into_iter().filter_map(std::result::Result::ok) {
diff --git a/src/semantic_line_breaks/comments.rs b/src/semantic_line_breaks/comments.rs
index 15093dc..d65cbb6 100644
--- a/src/semantic_line_breaks/comments.rs
+++ b/src/semantic_line_breaks/comments.rs
@@ -12,7 +12,7 @@ use regex::Regex;
 use super::markdown;
 use super::scanner::{ScanState, scan_line_buffered};
 use super::string_syntax::{StringSyntax, string_syntax};
-use super::types::{FileKind, FormatOptions, Region, Violation, ViolationKind};
+use super::types::{CommentStyle, FileKind, FormatOptions, Region, Violation, ViolationKind};
 use crate::{leading_whitespace, starts_with_ignore_case};
 
 /// Matches the opening of a Python docstring and captures indentation, string prefix, quotes, and the rest.
@@ -159,6 +159,22 @@ pub fn split_source_regions_scanned(lines: &[&str], kind: FileKind, scan: &LineS
     regions
 }
 
+/// Whether a line comment already sits directly above the given line.
+///
+/// A comment moved above such a line would be reflowed together with the comment above it,
+/// which merges two separate notes into one sentence, so those lines are reported but not fixed.
+fn has_comment_line_above(lines: &[&str], index: usize, style: &CommentStyle, inside_string: &[bool]) -> bool {
+    let Some(previous) = index.checked_sub(1) else {
+        return false;
+    };
+    if inside_string.get(previous).copied().unwrap_or(false) {
+        return false;
+    }
+    lines
+        .get(previous)
+        .is_some_and(|line| line_marker(line.trim_start(), style.line_markers).is_some())
+}
+
 /// Find trailing comments and build replacement line pairs for each affected line.
 ///
 /// Returns one entry per input line, `Some((comment_line, code_line))` for lines to split,
@@ -185,6 +201,7 @@ pub fn fix_trailing_comments_scanned(
     let Some(syntax) = string_syntax(kind) else {
         return (replacements, violations);
     };
+    let style = kind.comment_style();
     for (index, line) in lines.iter().enumerate() {
         let Some(comment_start) = scan.comment_start.get(index).copied().flatten() else {
             continue;
@@ -195,6 +212,19 @@ pub fn fix_trailing_comments_scanned(
         if is_directive(&trailing.text, options) {
             continue;
         }
+        // A comment moved above a line that already has a comment above it joins that comment block,
+        // and the reflow then merges two separate notes into one sentence.
+        // The move is reported so the line can be fixed by hand, but it is not made automatically.
+        if has_comment_line_above(lines, index, &style, &scan.inside_string) {
+            violations.push(Violation {
+                line: index + 1,
+                column: Some(trailing.column),
+                kind: ViolationKind::TrailingComment,
+                message: "comment shares a line with code, a comment already sits above it".into(),
+                fixable: false,
+            });
+            continue;
+        }
         let indent = leading_whitespace(line);
         let comment_line = format!("{indent}{} {}", syntax.line_marker, trailing.text);
         violations.push(Violation {
@@ -741,6 +771,73 @@ mod test_docstrings {
     }
 }
 
+#[cfg(test)]
+mod test_comment_above_code {
+    use super::test_helpers::*;
+    use super::*;
+
+    #[test]
+    fn a_comment_directly_above_the_code_blocks_the_move() {
+        let lines = [
+            "// Various dotted prefixes all below threshold of 15",
+            "let x = 1; // 6 chars",
+        ];
+        let (replacements, violations) = fix(&lines, FileKind::Rust);
+        assert!(replacements.iter().all(Option::is_none));
+        assert_eq!(violations.len(), 1);
+        assert_eq!(violations[0].kind, ViolationKind::TrailingComment);
+        assert_eq!(violations[0].line, 2);
+        assert!(!violations[0].fixable);
+        assert!(violations[0].message.contains("a comment already sits above it"));
+    }
+
+    #[test]
+    fn a_doc_comment_above_the_code_also_blocks_the_move() {
+        let lines = ["/// documented", "let x = 1; // note"];
+        let (replacements, violations) = fix(&lines, FileKind::Rust);
+        assert!(replacements.iter().all(Option::is_none));
+        assert!(!violations[0].fixable);
+    }
+
+    #[test]
+    fn a_blank_line_above_the_code_still_allows_the_move() {
+        let lines = ["// a note", "", "let x = 1; // 6 chars"];
+        let (replacements, violations) = fix(&lines, FileKind::Rust);
+        assert_eq!(replacements[2], Some(pair("// 6 chars", "let x = 1;")));
+        assert!(violations[0].fixable);
+    }
+
+    #[test]
+    fn code_above_the_code_still_allows_the_move() {
+        let lines = ["let y = 2;", "let x = 1; // 6 chars"];
+        let (replacements, _) = fix(&lines, FileKind::Rust);
+        assert_eq!(replacements[1], Some(pair("// 6 chars", "let x = 1;")));
+    }
+
+    #[test]
+    fn the_first_line_of_a_file_still_allows_the_move() {
+        assert_eq!(
+            replacement("let x = 1; // one", FileKind::Rust),
+            Some(pair("// one", "let x = 1;"))
+        );
+    }
+
+    #[test]
+    fn a_hash_comment_above_the_code_blocks_the_move() {
+        let lines = ["# a note", "value = 1  # 6 chars"];
+        let (replacements, violations) = fix(&lines, FileKind::Python);
+        assert!(replacements.iter().all(Option::is_none));
+        assert!(!violations[0].fixable);
+    }
+
+    #[test]
+    fn a_comment_inside_a_string_above_the_code_does_not_block_the_move() {
+        let lines = ["let text = \"", "// not a comment", "\";", "let x = 1; // note"];
+        let (replacements, _) = fix(&lines, FileKind::Rust);
+        assert_eq!(replacements[3], Some(pair("// note", "let x = 1;")));
+    }
+}
+
 #[cfg(test)]
 mod test_trailing_rust {
     use super::test_helpers::*;
diff --git a/src/semantic_line_breaks/formatter.rs b/src/semantic_line_breaks/formatter.rs
index 7e104d0..d10bd4f 100644
--- a/src/semantic_line_breaks/formatter.rs
+++ b/src/semantic_line_breaks/formatter.rs
@@ -250,7 +250,15 @@ mod test_split_and_assemble {
 #[cfg(test)]
 mod test_format {
     use super::*;
-    use crate::semantic_line_breaks::types::ViolationKind;
+    use crate::semantic_line_breaks::types::{RuleSet, ViolationKind};
+
+    /// Options with every rule on, including the opt-in trailing comment rule.
+    fn all_rules() -> FormatOptions {
+        FormatOptions {
+            rules: RuleSet::ALL,
+            ..FormatOptions::default()
+        }
+    }
 
     #[test]
     fn check_matches_format_violations() {
@@ -284,7 +292,7 @@ mod test_format {
     #[test]
     fn moves_trailing_comment_above_code_with_crlf() {
         let text = "fn f() {\r\n    let x = 1; // one\r\n}\r\n";
-        let result = format(text, FileKind::Rust, &FormatOptions::default());
+        let result = format(text, FileKind::Rust, &all_rules());
         assert_eq!(
             result.fixed_text.as_deref(),
             Some("fn f() {\r\n    // one\r\n    let x = 1;\r\n}\r\n")
@@ -293,6 +301,40 @@ mod test_format {
         assert_eq!(result.violations[0].line, 2);
     }
 
+    #[test]
+    fn a_trailing_comment_under_a_comment_is_reported_but_left_in_place() {
+        let text = concat!(
+            "// Various dotted prefixes all below threshold of 15\n",
+            "std::fs::write(root.join(\"One.Two.File.001.mp4\"), \"\").unwrap(); // 6 chars\n",
+        );
+        let result = format(text, FileKind::Rust, &all_rules());
+        assert_eq!(result.fixed_text, None);
+        assert_eq!(result.violations.len(), 1);
+        assert_eq!(result.violations[0].kind, ViolationKind::TrailingComment);
+        assert_eq!(result.violations[0].line, 2);
+        assert!(!result.violations[0].fixable);
+    }
+
+    #[test]
+    fn a_trailing_comment_without_a_comment_above_is_still_moved() {
+        let text = "let x = 1; // 6 chars\n";
+        let result = format(text, FileKind::Rust, &all_rules());
+        assert_eq!(result.fixed_text.as_deref(), Some("// 6 chars\nlet x = 1;\n"));
+        assert!(result.violations[0].fixable);
+        // The fixed text is stable, the moved comment is not merged into anything.
+        let second = format("// 6 chars\nlet x = 1;\n", FileKind::Rust, &all_rules());
+        assert_eq!(second.fixed_text, None);
+        assert!(second.violations.is_empty());
+    }
+
+    #[test]
+    fn the_trailing_rule_is_off_unless_it_is_enabled() {
+        let text = "let x = 1; // one\n";
+        let result = format(text, FileKind::Rust, &FormatOptions::default());
+        assert_eq!(result.fixed_text, None);
+        assert!(result.violations.is_empty());
+    }
+
     #[test]
     fn ignore_file_marker_disables_formatting() {
         let text = "<!-- slb-ignore-file -->\nthe quick brown fox\njumps over the dog.\n";
@@ -355,7 +397,7 @@ mod test_format {
             "// Keep this comment.\n",
             "const next = 1;\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::JavaScript, FileKind::CLike, FileKind::Rust, FileKind::Go] {
             let first = format(text, kind, &options);
             assert_eq!(first.fixed_text.as_deref(), Some(expected), "{kind:?}");
@@ -406,15 +448,23 @@ mod test_format {
             "code //// literal; not prose\n",
             "// wrapped block\n",
             "// content.\n",
-            "// next note\n",
-            "*/ let next = 1;\n",
+            // The block content line above the code keeps the trailing comment in place,
+            // so nothing is inserted inside the block comment.
+            "*/ let next = 1; // next note\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::Rust, FileKind::Go, FileKind::CLike, FileKind::JavaScript] {
             let first = format(text, kind, &options);
             assert_eq!(first.fixed_text.as_deref(), Some(expected), "{kind:?}");
             assert_eq!(check(text, kind, &options), first.violations, "{kind:?}");
-            assert_eq!(format(expected, kind, &options), FormatResult::default(), "{kind:?}");
+            // The trailing comment that cannot be moved is still reported, so only the fix is checked.
+            let second = format(expected, kind, &options);
+            assert_eq!(second.fixed_text, None, "{kind:?}");
+            assert!(
+                second.violations.iter().all(|violation| !violation.fixable),
+                "{kind:?}: {:?}",
+                second.violations
+            );
         }
     }
 
@@ -443,7 +493,7 @@ mod test_format {
             "// next note\n",
             "*/ let next = 1;\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::Rust, FileKind::Go, FileKind::CLike, FileKind::JavaScript] {
             let first = format(text, kind, &options);
             assert_eq!(first.fixed_text.as_deref(), Some(expected), "{kind:?}");
@@ -456,7 +506,7 @@ mod test_format {
     fn regex_hashes_are_preserved_while_real_hash_comments_are_formatted() {
         let text = "pattern = /[ #/]/ # Match a delimiter.\nnext = 1 # Keep this comment.\n";
         let expected = "# Match a delimiter.\npattern = /[ #/]/\n# Keep this comment.\nnext = 1\n";
-        let options = FormatOptions::default();
+        let options = all_rules();
         for kind in [FileKind::Python, FileKind::Shell, FileKind::Toml, FileKind::Yaml] {
             assert_eq!(
                 format(text, kind, &options).fixed_text.as_deref(),
@@ -469,7 +519,7 @@ mod test_format {
 
     #[test]
     fn quoted_slashes_in_division_and_paths_preserve_code() {
-        let options = FormatOptions::default();
+        let options = all_rules();
         for (kind, code) in [
             (FileKind::Python, r#"value = default / len("/# not a comment")"#),
             (FileKind::Python, r#"value = default / len(["]/# not a comment"])"#),
@@ -534,7 +584,7 @@ mod test_format {
             "// Keep this comment.\n",
             "const next = 1;\n",
         );
-        let options = FormatOptions::default();
+        let options = all_rules();
         assert_eq!(
             format(text, FileKind::JavaScript, &options).fixed_text.as_deref(),
             Some(expected)
diff --git a/src/semantic_line_breaks/regex_literals.rs b/src/semantic_line_breaks/regex_literals.rs
index 8f8e48e..449ef59 100644
--- a/src/semantic_line_breaks/regex_literals.rs
+++ b/src/semantic_line_breaks/regex_literals.rs
@@ -648,10 +648,18 @@ mod test_regex_literals {
         );
         let lines = [
             r"const expression = /[/*]/; /* real block",
-            "// inside the block",
+            "inside the block",
             "*/ const next = 1; // c",
         ];
         assert_eq!(replaced_indices(&lines, FileKind::JavaScript), vec![2]);
+
+        // A comment line just above the code keeps the trailing comment in place.
+        let with_comment_above = [
+            r"const expression = /[/*]/; /* real block",
+            "// inside the block",
+            "*/ const next = 1; // c",
+        ];
+        assert!(replaced_indices(&with_comment_above, FileKind::JavaScript).is_empty());
     }
 
     #[test]
diff --git a/src/semantic_line_breaks/types.rs b/src/semantic_line_breaks/types.rs
index 1c93c2b..13741a2 100644
--- a/src/semantic_line_breaks/types.rs
+++ b/src/semantic_line_breaks/types.rs
@@ -607,6 +607,19 @@ impl RuleSet {
         trailing_comment: true,
     };
 
+    /// Rules enabled when the caller asks for no particular set.
+    ///
+    /// Trailing comment fixing is left out.
+    /// It rewrites code lines and the result often reads worse than the original,
+    /// so it has to be asked for.
+    pub const DEFAULT: Self = Self {
+        line_too_long: true,
+        mid_clause_break: true,
+        semicolon: true,
+        em_dash: true,
+        trailing_comment: false,
+    };
+
     /// No rules enabled.
     pub const NONE: Self = Self {
         line_too_long: false,
@@ -647,7 +660,7 @@ impl RuleSet {
 
 impl Default for RuleSet {
     fn default() -> Self {
-        Self::ALL
+        Self::DEFAULT
     }
 }
 
@@ -669,7 +682,7 @@ impl Default for FormatOptions {
             tab_width: DEFAULT_TAB_WIDTH,
             join_sentences: false,
             allow_word_break: false,
-            rules: RuleSet::ALL,
+            rules: RuleSet::DEFAULT,
             abbreviations: crate::strings_from(DEFAULT_ABBREVIATIONS),
             clause_starters: Vec::new(),
             directive_prefixes: crate::strings_from(DEFAULT_DIRECTIVE_PREFIXES),
@@ -1117,7 +1130,7 @@ mod test_options_and_prefixes {
         let defaults = FormatOptions::default();
         assert_eq!(options.max_width, 72);
         assert_eq!(options.tab_width, DEFAULT_TAB_WIDTH);
-        assert_eq!(options.rules, RuleSet::ALL);
+        assert_eq!(options.rules, RuleSet::DEFAULT);
         assert_eq!(options.abbreviations, defaults.abbreviations);
         assert_eq!(options.directive_prefixes, defaults.directive_prefixes);
         assert_eq!(options.preserve_lowercase, defaults.preserve_lowercase);
@@ -1128,8 +1141,8 @@ mod test_options_and_prefixes {
     }
 
     #[test]
-    fn the_rule_set_defaults_to_all_rules() {
-        assert_eq!(RuleSet::default(), RuleSet::ALL);
+    fn the_rule_set_defaults_to_every_rule_except_trailing_comments() {
+        assert_eq!(RuleSet::default(), RuleSet::DEFAULT);
         assert_eq!(RuleSet::from_kinds(&[]), RuleSet::NONE);
         for kind in [
             ViolationKind::LineTooLong,
@@ -1144,6 +1157,18 @@ mod test_options_and_prefixes {
         }
     }
 
+    #[test]
+    fn the_default_rule_set_differs_from_all_rules_only_in_trailing_comments() {
+        const { assert!(!RuleSet::DEFAULT.trailing_comment) };
+        assert_eq!(
+            RuleSet {
+                trailing_comment: true,
+                ..RuleSet::DEFAULT
+            },
+            RuleSet::ALL
+        );
+    }
+
     #[test]
     fn openers_and_closers_are_recognized() {
         for character in ['(', '[', '{', '"', '\'', '“', '‘', '«'] {
diff --git a/tests/fixtures/sample_config.toml b/tests/fixtures/sample_config.toml
index 4238b45..03ddaa0 100644
--- a/tests/fixtures/sample_config.toml
+++ b/tests/fixtures/sample_config.toml
@@ -99,7 +99,7 @@ verbose = false
 [slb]
 width = 110
 use_project_config = true
-rules = ["too-long", "mid-clause", "semicolon", "em-dash", "trailing"]
+rules = ["too-long", "mid-clause", "semicolon", "em-dash"]
 join_sentences = false
 allow_word_break = false
 extensions = ["rs", "md"]
diff --git a/tests/fixtures/slb/rust_doc_comments.out.rs b/tests/fixtures/slb/rust_doc_comments.out.rs
index 356b0bd..ac927a9 100644
--- a/tests/fixtures/slb/rust_doc_comments.out.rs
+++ b/tests/fixtures/slb/rust_doc_comments.out.rs
@@ -17,8 +17,7 @@
 /// Returns an error when the input is empty.
 pub fn parse(input: &str) -> Header {
     // Use the default width for now.
-    // default width
-    let width = 80;
+    let width = 80; // default width
     // not a URL comment
     let url = "http://example.com";
     Header::new(input, width) // clippy::allow
diff --git a/tests/fixtures/slb/yaml_comments.out.yml b/tests/fixtures/slb/yaml_comments.out.yml
index 53d39db..7cbead2 100644
--- a/tests/fixtures/slb/yaml_comments.out.yml
+++ b/tests/fixtures/slb/yaml_comments.out.yml
@@ -1,6 +1,5 @@
 # Top level comment that wraps in the middle.
-# trailing note
-key: value
+key: value # trailing note
 url: http://example.com/#anchor
 script: |
   echo "# not a comment"
diff --git a/tests/slb_cli_tests.rs b/tests/slb_cli_tests.rs
index 5cf8e17..c1fab3b 100644
--- a/tests/slb_cli_tests.rs
+++ b/tests/slb_cli_tests.rs
@@ -294,7 +294,7 @@ fn a_trailing_comment_is_moved_above_the_code() {
     let directory = temporary_directory();
     let path = write_file(&directory, "trailing.rs", "let width = 80; // default width\n");
 
-    let output = run(&[&argument(&path), "--fix"]);
+    let output = run(&[&argument(&path), "--trailing", "--fix"]);
 
     assert_eq!(exit_code(&output), 0);
     assert_eq!(
@@ -303,12 +303,49 @@ fn a_trailing_comment_is_moved_above_the_code() {
     );
 }
 
+#[test]
+fn a_trailing_comment_is_left_alone_without_the_trailing_flag() {
+    let directory = temporary_directory();
+    let path = write_file(&directory, "trailing.rs", "let width = 80; // default width\n");
+
+    let output = run(&[&argument(&path), "--fix"]);
+
+    assert_eq!(exit_code(&output), 0);
+    assert_eq!(
+        std::fs::read_to_string(&path).expect("file should be readable"),
+        "let width = 80; // default width\n"
+    );
+}
+
+#[test]
+fn a_trailing_comment_under_a_comment_is_reported_but_not_fixed() {
+    let directory = temporary_directory();
+    let path = write_file(
+        &directory,
+        "trailing.rs",
+        "// Various dotted prefixes all below threshold of 15\nlet width = 80; // 6 chars\n",
+    );
+
+    let output = run(&[&argument(&path), "--trailing", "--fix"]);
+
+    assert_eq!(exit_code(&output), 1);
+    assert_eq!(
+        std::fs::read_to_string(&path).expect("file should be readable"),
+        "// Various dotted prefixes all below threshold of 15\nlet width = 80; // 6 chars\n"
+    );
+    assert!(
+        stdout(&output).contains("a comment already sits above it"),
+        "{}",
+        stdout(&output)
+    );
+}
+
 #[test]
 fn a_directive_comment_is_left_on_the_code_line() {
     let directory = temporary_directory();
     let path = write_file(&directory, "directive.rs", "let value = 1; // clippy::all\n");
 
-    let output = run(&[&argument(&path), "--fix"]);
+    let output = run(&[&argument(&path), "--trailing", "--fix"]);
 
     assert_eq!(exit_code(&output), 0);
     assert_eq!(
@@ -351,6 +388,52 @@ fn excluded_directories_are_skipped_when_walking() {
     );
 }
 
+#[test]
+fn a_command_line_exclude_keeps_the_default_excludes() {
+    let directory = temporary_directory();
+    write_file(&directory, "target/long.rs", TWO_SENTENCES);
+    write_file(&directory, "other/long.rs", TWO_SENTENCES);
+    write_file(&directory, "kept/clean.rs", "/// Short comment.\n");
+
+    let output = run(&[&argument(directory.path()), "-w", "40", "--exclude", "other"]);
+
+    assert_eq!(exit_code(&output), 0);
+    assert!(
+        stdout(&output).contains("Checked 1 file, no violations"),
+        "{}",
+        stdout(&output)
+    );
+}
+
+#[test]
+fn gitignored_files_are_skipped_unless_the_ignore_rules_are_off() {
+    let directory = temporary_directory();
+    write_file(&directory, ".gitignore", "generated/\n");
+    write_file(&directory, "generated/long.rs", TWO_SENTENCES);
+    write_file(&directory, "kept/clean.rs", "/// Short comment.\n");
+    Command::new("git")
+        .args(["init", "--quiet"])
+        .current_dir(directory.path())
+        .status()
+        .expect("git init should run");
+
+    let output = run(&[&argument(directory.path()), "-w", "40"]);
+    assert_eq!(exit_code(&output), 0);
+    assert!(
+        stdout(&output).contains("Checked 1 file, no violations"),
+        "{}",
+        stdout(&output)
+    );
+
+    let without_ignore = run(&[&argument(directory.path()), "-w", "40", "--no-ignore", "--quiet"]);
+    assert_eq!(exit_code(&without_ignore), 1);
+    assert!(
+        stdout(&without_ignore).contains("Checked 2 files"),
+        "{}",
+        stdout(&without_ignore)
+    );
+}
+
 #[test]
 fn the_extension_filter_limits_the_walked_files() {
     let directory = temporary_directory();
diff --git a/tests/slb_integration_tests.rs b/tests/slb_integration_tests.rs
index 5490db1..35768bc 100644
--- a/tests/slb_integration_tests.rs
+++ b/tests/slb_integration_tests.rs
@@ -7,7 +7,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use cli_tools::semantic_line_breaks::{FileKind, FormatOptions, format};
+use cli_tools::semantic_line_breaks::{FileKind, FormatOptions, RuleSet, format};
 
 /// Directory holding the fixture pairs.
 fn fixture_directory() -> PathBuf {
@@ -41,7 +41,11 @@ fn assert_fixture(input_name: &str, output_name: &str) {
     let input = read_fixture(input_name);
     let expected = read_fixture(output_name);
     let kind = FileKind::from_path(Path::new(output_name)).expect("fixture should have a known kind");
-    let options = FormatOptions::default();
+    // The fixtures cover the opt-in trailing comment rule too, so every rule is on here.
+    let options = FormatOptions {
+        rules: RuleSet::ALL,
+        ..FormatOptions::default()
+    };
 
     let result = format(&input, kind, &options);
     let actual = result.fixed_text.unwrap_or_else(|| input.clone());