fix(config): keep a file's per-file-ignores out of the workspace index it feeds

A run over files filtered each file's rules by its `per-file-ignores` before
linting it, and the same filtered set built the index the cross-file checks
resolve against. MD051 is the only rule that records a file's headings, so
`"target.md" = ["MD051"]` erased target.md from the index and every link
elsewhere pointing at one of its anchors reported as broken. The finding named
a file and a rule the reader never configured, and the fragment it called
missing was there in the target all along.

Per-file-ignores decides what a file REPORTS. What a file contributes to the
workspace belongs to the workspace: its headings answer links written in other
files, whose own configuration says nothing about it. `lint_and_index` now
applies the ignores to the rules it runs and keeps every cross-file rule for
the index it builds, so the full rule set can go in. That is how the cache-hit
path and the stdin path already build an index, so all three now agree.

The ignore itself is unchanged: the file that names a rule reports nothing from
it, on its own lines or through a cross-file check, and an embedded markdown
block is part of that file so it is still linted with the reduced set.

The persisted workspace index carries the old meaning, and content is what
decides whether an entry is reused, so an unchanged file would have kept its
gap and the fixed build would have gone on reporting the false positive from
the cache the previous one wrote. Its format version is bumped to rebuild.

Author: rvben

src/file_processor/processing.rs

@@ -908,28 +908,20 @@ pub fn process_file_with_index(
 
     let lint_start = Instant::now();
 
-    // Filter rules based on per-file-ignores configuration
-    let filtered_rules: Vec<_> = rumdl_lib::time_function!(
-        "file: filter rules",
-        if !ignored_rules_for_file.is_empty() {
-            rules
-                .iter()
-                .filter(|rule| !ignored_rules_for_file.contains(rule.name()))
-                .map(|r| dyn_clone::clone_box(&**r))
-                .collect()
-        } else {
-            rules.to_vec()
-        }
-    );
-
     // Determine flavor based on per-file-flavor overrides, global config, or file extension
     let flavor = config.get_flavor_for_file(Path::new(file_path));
 
-    // Use lint_and_index for single-file linting + index contribution
+    // Use lint_and_index for single-file linting + index contribution.
+    //
+    // The full rule set goes in: `lint_and_index` applies this file's
+    // per-file-ignores to what it reports, and keeps every cross-file rule for the
+    // index it builds. Handing it a pre-filtered set instead erased this file's
+    // headings from the workspace, so a link elsewhere pointing at one of them
+    // reported as broken.
     let source_file = Some(std::path::PathBuf::from(file_path));
     let (warnings_result, file_index) = rumdl_lib::time_function!(
         "file: lint and index",
-        rumdl_lib::lint_and_index(&content, &filtered_rules, verbose, flavor, source_file, Some(config))
+        rumdl_lib::lint_and_index(&content, rules, verbose, flavor, source_file, Some(config))
     );
 
     // Combine all warnings
@@ -938,6 +930,20 @@ pub fn process_file_with_index(
     // Check embedded markdown blocks if configured in code-block-tools
     // The special tool "rumdl" in [code-block-tools.languages.markdown] enables this
     if should_lint_embedded_markdown(&config.code_block_tools) {
+        // An embedded block is part of this file, so its findings are this file's
+        // and per-file-ignores decides which of them are reported.
+        let filtered_rules: Vec<_> = rumdl_lib::time_function!(
+            "file: filter rules",
+            if !ignored_rules_for_file.is_empty() {
+                rules
+                    .iter()
+                    .filter(|rule| !ignored_rules_for_file.contains(rule.name()))
+                    .map(|r| dyn_clone::clone_box(&**r))
+                    .collect()
+            } else {
+                rules.to_vec()
+            }
+        );
         let embedded_warnings = rumdl_lib::time_function!(
             "file: embedded markdown blocks",
             check_embedded_markdown_blocks(&content, &filtered_rules, config)

src/lib.rs

@@ -403,6 +403,17 @@ pub fn lint_and_index(
         return (Ok(warnings), file_index);
     }
 
+    // The rules `per-file-ignores` takes away for this file. It decides what this
+    // file REPORTS, and nothing else: the index contribution at the end of this
+    // function deliberately keeps running every cross-file rule, because a file's
+    // headings and links belong to the workspace rather than to its own report.
+    // Dropping a rule from the index instead would break the links pointing HERE,
+    // in files that never named it.
+    let ignored_for_file = match (config, source_file.as_deref()) {
+        (Some(cfg), Some(path)) => cfg.get_ignored_rules_for_file(path),
+        _ => std::collections::HashSet::new(),
+    };
+
     // Parse LintContext once (includes inline config parsing)
     let lint_ctx = time_function!(
         "lint: parse lint context",
@@ -422,9 +433,10 @@ pub fn lint_and_index(
         ContentCharacteristics::analyze(content)
     );
 
-    // Filter rules based on content characteristics
+    // Filter rules based on per-file-ignores and content characteristics
     let applicable_rules: Vec<_> = rules
         .iter()
+        .filter(|rule| !ignored_for_file.contains(rule.name()))
         .filter(|rule| !(rule.skippable_by_category() && characteristics.should_skip_rule(rule.as_ref())))
         .collect();
 
@@ -527,12 +539,14 @@ pub fn lint_and_index(
 
         // A workspace-scope rule has its warnings filtered after this point, and for a
         // single-file run not at all, so its findings never reach the report and
-        // nothing can be concluded about a comment naming it.
+        // nothing can be concluded about a comment naming it. A rule this file
+        // ignores does not report either, for the same reason.
         let report = crate::rule::SuppressionReport {
             suppressed,
             judged_rules: rules
                 .iter()
                 .filter(|rule| rule.cross_file_scope() != crate::rule::CrossFileScope::Workspace)
+                .filter(|rule| !ignored_for_file.contains(rule.name()))
                 .map(|rule| rule.name().to_string())
                 .collect(),
         };
@@ -555,9 +569,10 @@ pub fn lint_and_index(
     // Contribute to index for cross-file rules (done after all rules checked)
     // NOTE: We iterate over ALL rules (not just applicable_rules) because cross-file
     // rules need to extract data from every file in the workspace, regardless of whether
-    // that file has content that would trigger the rule. For example, MD051 needs to
-    // index headings from files that have no links (like target.md) so that links
-    // FROM other files TO those headings can be validated.
+    // that file has content that would trigger the rule, and regardless of what this
+    // file's own configuration reports. For example, MD051 needs to index headings from
+    // files that have no links (like target.md) so that links FROM other files TO those
+    // headings can be validated - including from a file that ignores MD051 itself.
     time_section!("lint: contribute cross-file data", {
         for rule in rules {
             if rule.cross_file_scope() == crate::rule::CrossFileScope::Workspace {

src/workspace_index.rs

@@ -289,8 +289,14 @@ const CACHE_MAGIC: &[u8; 4] = b"RWSI";
 /// bytes still decode, so nothing here would notice, and a cached index is
 /// reused whole when a file's content is unchanged - a version 9 cache would
 /// keep reporting the duplicate this version exists to stop.
+///
+/// Version 11 is the same shape of change: a file's entry no longer depends on
+/// its own `per-file-ignores`, so an entry written before it can be missing the
+/// headings an ignored rule would have recorded. Content is what decides reuse,
+/// and the content did not change, so without this the fixed build would keep
+/// serving the false positive from the cache the old one left behind.
 #[cfg(feature = "postcard")]
-const CACHE_FORMAT_VERSION: u32 = 10;
+const CACHE_FORMAT_VERSION: u32 = 11;
 
 /// Cache file name within the version directory
 #[cfg(feature = "postcard")]

tests/config/per_file_ignores_integration_test.rs

@@ -600,3 +600,47 @@ fn test_inline_enable_of_per_file_ignored_rule_denies() {
         String::from_utf8_lossy(&plain.stderr)
     );
 }
+
+/// `per-file-ignores` decides what a file reports, not what the workspace knows
+/// about it. A target that ignores MD051 still has to contribute its headings,
+/// or a link pointing at one of them reports as broken from a file that never
+/// named the rule - a false positive whose cause is written in another file's
+/// configuration.
+#[test]
+fn test_per_file_ignores_on_a_target_keeps_its_headings_indexed() {
+    let temp_dir = tempdir().unwrap();
+
+    fs::write(
+        temp_dir.path().join(".rumdl.toml"),
+        r#"
+[per-file-ignores]
+"target.md" = ["MD051"]
+"#,
+    )
+    .unwrap();
+    fs::write(temp_dir.path().join("target.md"), "# Real\n").unwrap();
+    fs::write(
+        temp_dir.path().join("source.md"),
+        "# Source\n\n[valid](target.md#real)\n\n[broken](target.md#missing)\n",
+    )
+    .unwrap();
+
+    let stdout = run_check(temp_dir.path(), &["."]);
+
+    assert!(
+        !stdout.contains("'real' not found"),
+        "the anchor target.md does have must resolve. stdout={stdout}"
+    );
+    // The positive control: MD051 is still running for source.md, so the absence
+    // above is the fragment resolving rather than the check declining to look.
+    assert!(
+        stdout.contains("'missing' not found"),
+        "a fragment target.md does not have must still report. stdout={stdout}"
+    );
+    // And the ignore itself still holds for the file that named it: target.md's
+    // own MD051 findings stay out of the report.
+    assert!(
+        !reports(&stdout, "target.md", "MD051"),
+        "target.md must report no MD051 of its own. stdout={stdout}"
+    );
+}