sonicop 26.8.111 → 26.8.113

data/src/directives.rs

@@ -10,11 +10,56 @@ use crate::diagnostic::Offense;
 use crate::engine::{Selection, is_mandatory_cop};
 use crate::source::SourceFile;
 
+/// What the last directive to speak for a name decided, which is the shape `analyze_cop` leaves
+/// one cop's analysis in.
+///
+/// An `enable` records a verdict rather than dropping the entry, because the cop it names may sit
+/// under a department -- or under `all` -- that a directive above it switched off, and upstream
+/// closes that cop's range while leaving the rest of the department alone.
+#[derive(Clone, Debug)]
+enum Verdict {
+    /// `analyze_disabled`, carrying the `-- reason` the directive was written with.
+    Disabled(Option<String>),
+    /// `analyze_rest`.
+    Enabled,
+}
+
 #[derive(Clone, Debug, Default)]
 struct Snapshot {
-    all: bool,
-    all_reason: Option<String>,
-    cops: HashMap<String, Option<String>>,
+    /// The verdict a directive that named `all` left in force.
+    all: Option<Verdict>,
+    /// The verdict for every name a directive spelled out, department names included. See
+    /// [`Snapshot::verdict_for`] for why a department is not expanded here.
+    cops: HashMap<String, Verdict>,
+}
+
+impl Snapshot {
+    /// The directive in force for `cop`: the one that named it, else the one that named its
+    /// department, else the one that named `all`.
+    ///
+    /// `DirectiveComment#cop_names` expands a department and `all` into concrete cop names when
+    /// the directive is read, so upstream needs no lookup order at all. Expanding here instead
+    /// would mean copying a couple of hundred names into a snapshot that every line of the file
+    /// clones, and a department is exactly the prefix of the cops it holds -- so the expansion is
+    /// left implicit and read back here, with the entries it supersedes dropped by
+    /// [`record`] as the directive is applied.
+    fn verdict_for(&self, cop: &str) -> Option<&Verdict> {
+        // `parsed_cop_names` subtracts `Lint/Syntax` from every directive, `all` and departments
+        // included: a file cannot switch off the report of the parse it was not read by.
+        if cop == UNDISABLEABLE_COPS[1] {
+            return None;
+        }
+        if let Some(verdict) = self.cops.get(cop) {
+            return Some(verdict);
+        }
+        // `exclude_lint_department_cops` takes the cop that reads directives out of `all` and out
+        // of the `Lint` department, so only a directive that spells its name out reaches it:
+        // "this cop is not disabled when disabling all cops".
+        if cop == UNDISABLEABLE_COPS[0] {
+            return None;
+        }
+        self.cops.get(department(cop)).or(self.all.as_ref())
+    }
 }
 
 #[derive(Debug, Default)]
@@ -56,7 +101,9 @@ impl DirectiveState {
     ) -> Self {
         let mut current = Snapshot::default();
         for cop in disabled_by_config {
-            current.cops.insert((*cop).to_owned(), None);
+            current
+                .cops
+                .insert((*cop).to_owned(), Verdict::Disabled(None));
         }
         let mut stack = Vec::new();
         let mut line_states = Vec::with_capacity(source.line_count());
@@ -81,14 +128,21 @@ impl DirectiveState {
                 .and_then(|&start| parse_directive(line, start));
 
             if let Some(directive) = directive {
-                if directive.inline && matches!(directive.action, Action::Disable) {
-                    let mut line_only = before;
-                    apply_disable(&mut line_only, &directive.cops, directive.reason);
-                    line_states.push(line_only);
-                    continue;
-                }
-
                 match directive.action {
+                    // `analyze_single_line`, which is where `analyze_cop` sends a directive that
+                    // shares its line with code or that was written behind prose: it covers that
+                    // one line and no more.
+                    Action::Disable if directive.inline => {
+                        let mut line_only = before;
+                        apply_disable(&mut line_only, &directive.cops, directive.reason);
+                        line_states.push(line_only);
+                        continue;
+                    }
+                    // `return analysis unless directive.disabled?`: an `enable` written there is a
+                    // no-op, and in particular does not close the range a block-form `disable`
+                    // above it opened. `push` and `pop` are routed before that check upstream, so
+                    // they act wherever they are written.
+                    Action::Enable if directive.inline => {}
                     Action::Disable => {
                         apply_disable(&mut current, &directive.cops, directive.reason);
                     }
@@ -135,10 +189,7 @@ impl DirectiveState {
             let Some(state) = self.line_states.get(line - 1) else {
                 break;
             };
-            if !(state.all
-                || state.cops.contains_key(cop)
-                || state.cops.contains_key(department(cop)))
-            {
+            if !matches!(state.verdict_for(cop), Some(Verdict::Disabled(_))) {
                 continue;
             }
             match ranges.last_mut() {
@@ -161,19 +212,10 @@ impl DirectiveState {
         }
         let (line, _) = source.line_column(offense.start);
         let state = self.line_states.get(line.saturating_sub(1))?;
-        if let Some(reason) = state.cops.get(offense.cop_name) {
-            return Some(reason.clone());
-        }
-        // `exclude_lint_department_cops` takes the cop that reads directives out of `all` and out
-        // of the `Lint` department, so only a directive that spells its name out switches it off:
-        // "this cop is not disabled when disabling all cops".
-        if offense.cop_name == UNDISABLEABLE_COPS[0] {
-            return None;
+        match state.verdict_for(offense.cop_name)? {
+            Verdict::Disabled(reason) => Some(reason.clone()),
+            Verdict::Enabled => None,
         }
-        if let Some(reason) = state.cops.get(department(offense.cop_name)) {
-            return Some(reason.clone());
-        }
-        state.all.then(|| state.all_reason.clone())
     }
 }
 
@@ -206,28 +248,102 @@ pub fn opted_in_cops(source: &SourceFile, comment_ranges: &[Range<usize>]) -> Ha
 }
 
 fn apply_disable(state: &mut Snapshot, cops: &[String], reason: Option<String>) {
-    if cops.iter().any(|cop| cop == "all") {
-        state.all = true;
-        state.all_reason = reason;
-    } else {
-        state
-            .cops
-            .extend(cops.iter().cloned().map(|cop| (cop, reason.clone())));
+    for cop in cops {
+        record(state, cop, Verdict::Disabled(reason.clone()));
     }
 }
 
 fn apply_enable(state: &mut Snapshot, cops: &[String]) {
-    if cops.iter().any(|cop| cop == "all") {
-        state.all = false;
-        state.all_reason = None;
-        state.cops.clear();
-    } else {
-        for cop in cops {
-            state.cops.remove(cop);
-        }
+    for cop in cops {
+        record(state, cop, Verdict::Enabled);
     }
 }
 
+/// One name of one directive, applied to the snapshot.
+///
+/// `CommentConfig#analyze` writes the verdict against every cop `DirectiveComment#cop_names`
+/// expanded the name into, so a directive that names `all` or a department speaks for every cop
+/// below it and nothing an earlier directive left against one of them survives. Keeping the
+/// expansion implicit ([`Snapshot::verdict_for`] reads a department back off the cop's own name)
+/// means dropping those superseded entries by hand -- and leaving alone the two cops the
+/// expansion does not reach, whose own entry outlives the broader directive that follows it.
+fn record(state: &mut Snapshot, cop: &str, verdict: Verdict) {
+    if cop == "all" {
+        state.all = Some(verdict);
+        state.cops.retain(|name, _| undisableable(name));
+        return;
+    }
+    let cop = directive_cop_name(cop);
+    // `parsed_cop_names` ends in `cops - [LINT_SYNTAX_COP]`, so a directive that names the parse
+    // report names nothing at all -- not even enough to supersede what stands.
+    if cop == UNDISABLEABLE_COPS[1] {
+        return;
+    }
+    state.cops.retain(|name, _| {
+        department(name) != cop || (cop == LINT_DEPARTMENT && undisableable(name))
+    });
+    state.cops.insert(cop.to_owned(), verdict);
+}
+
+/// `exclude_lint_department_cops`: whether `all` and the `Lint` department leave this cop alone.
+fn undisableable(cop: &str) -> bool {
+    UNDISABLEABLE_COPS.contains(&cop)
+}
+
+/// `Cop::Registry.global`: the cops a directive resolves its names against.
+///
+/// Both `CommentConfig#qualified_cop_name` and `DirectiveComment#initialize` read the *global*
+/// registry rather than the one the run mobilized, so what `# rubocop:disable For` means depends
+/// on neither the configuration nor `--only`. [`CopRegistry`] is neither -- it is built from the
+/// configuration, and only for the cop that reviews directives -- so the names come from the cop
+/// list itself, which is what the global registry holds upstream.
+struct GlobalRegistry {
+    departments: HashSet<&'static str>,
+    /// `Registry#qualify_badge`, worked out once: the cop that carries a bare name, for the names
+    /// exactly one cop carries. An ambiguous one is left out, which is what makes a directive that
+    /// uses it resolve to nothing rather than to whichever cop was registered first.
+    by_cop_name: HashMap<&'static str, &'static str>,
+}
+
+fn global_registry() -> &'static GlobalRegistry {
+    static REGISTRY: OnceLock<GlobalRegistry> = OnceLock::new();
+    REGISTRY.get_or_init(|| {
+        let mut departments = HashSet::new();
+        let mut candidates: HashMap<&'static str, Option<&'static str>> = HashMap::new();
+        for name in crate::rules::rule_names() {
+            departments.insert(department(name));
+            let cop_name = name.rsplit('/').next().unwrap_or(name);
+            candidates
+                .entry(cop_name)
+                .and_modify(|found| *found = None)
+                .or_insert(Some(name));
+        }
+        GlobalRegistry {
+            departments,
+            by_cop_name: candidates
+                .into_iter()
+                .filter_map(|(cop_name, full)| Some((cop_name, full?)))
+                .collect(),
+        }
+    })
+}
+
+/// `CommentConfig#qualified_cop_name`, for one name a directive spelled out.
+///
+/// A department is left as it is: upstream expands it into the cops it holds, each of which is
+/// already qualified. Everything else goes through `Registry.qualified_cop_name`, which is what
+/// makes `# rubocop:disable For` switch off `Style/For` -- RuboCop warns about the missing
+/// department through `Migration/DepartmentName`, but it honours the directive -- and what makes
+/// a name written under the wrong department reach the cop that really carries it.
+fn directive_cop_name(name: &str) -> &str {
+    let registry = global_registry();
+    if registry.departments.contains(name) {
+        return name;
+    }
+    let cop_name = name.rsplit('/').next().unwrap_or(name);
+    registry.by_cop_name.get(cop_name).copied().unwrap_or(name)
+}
+
 #[derive(Clone, Copy, Debug)]
 enum Action {
     Disable,
@@ -270,7 +386,16 @@ fn parse_directive(line: &str, comment_start: usize) -> Option<Directive> {
     // `!comment_only_line?(directive.line_number) || directive.single_line?`: a directive covers
     // its own line alone when that line holds code as well, and also when it was written behind
     // prose rather than opening its comment.
-    let inline = !line[..comment_start].trim().is_empty() || header.start != 0;
+    //
+    // A byte order mark is not code. It is not in `White_Space` either, so `trim` leaves it and
+    // the first line of a file that carries one would read as holding something -- upstream never
+    // sees it, because `comment_only_line?` asks the token stream and `parser` strips the mark
+    // before it lexes anything.
+    let before_marker = &line[..comment_start];
+    let before_marker = before_marker
+        .strip_prefix(crate::source::BYTE_ORDER_MARK)
+        .unwrap_or(before_marker);
+    let inline = !before_marker.trim().is_empty() || header.start != 0;
 
     if matches!(action, Action::Push) {
         let push_operations = arguments
@@ -367,6 +492,9 @@ pub(crate) fn cop_name_length(text: &str) -> Option<usize> {
 /// directives by naming their department.
 const UNDISABLEABLE_COPS: [&str; 2] = ["Lint/RedundantCopDisableDirective", "Lint/Syntax"];
 
+/// `DirectiveComment::LINT_DEPARTMENT`, the one department whose expansion leaves cops out.
+const LINT_DEPARTMENT: &str = "Lint";
+
 /// The cop `CommentConfig` refuses to record a directive for once it is explicitly enabled, so
 /// that a file cannot switch off the cop that objects to its directives.
 const DISABLE_COPS_DIRECTIVE_COP: &str = "Style/DisableCopsWithinSourceCodeDirective";
@@ -1262,7 +1390,11 @@ fn lines_with_code(source: &SourceFile, comment_ranges: &[Range<usize>]) -> Hash
     let mut lines = HashSet::new();
     let mut comments = comment_ranges.iter().peekable();
     let mut line = 1;
-    let mut index = 0;
+    // `parser` strips a byte order mark before it lexes, so upstream never has a token for one and
+    // the first line of a file that carries one is still a comment-only line. The mark is not in
+    // `White_Space`, so nothing below would take it for a blank.
+    let mut index = usize::from(source.text().starts_with(crate::source::BYTE_ORDER_MARK))
+        * crate::source::BYTE_ORDER_MARK.len();
     while index < text.len() {
         if comments
             .peek()
@@ -1374,57 +1506,246 @@ fn pop_state(
 
 #[cfg(test)]
 mod tests {
+    use std::ops::Range;
+    use std::path::Path;
+
+    use crate::config::Config;
     use crate::diagnostic::{Offense, Severity};
+    use crate::engine::{self, Selection};
     use crate::source::SourceFile;
 
     use super::DirectiveState;
 
-    #[test]
-    fn handles_block_inline_reason_and_push_pop_directives() {
-        let source = SourceFile::new(
-            "test.rb",
-            "# rubocop:disable Layout -- legacy\n\
-             a = 1  \n\
-             # rubocop:enable Layout\n\
-             b = 2  # rubocop:disable Layout/TrailingWhitespace\n\
-             # rubocop:push -Layout/TrailingWhitespace\n\
-             c = 3  \n\
-             # rubocop:pop\n\
-             d = 4  \n"
-                .to_owned(),
-        );
-        let comment_ranges: Vec<_> = (1..=source.line_count())
+    /// Every comment of a file whose comments are all written with a bare `#`, which is what the
+    /// parse hands [`DirectiveState`] for real.
+    fn comment_ranges(source: &SourceFile) -> Vec<Range<usize>> {
+        (1..=source.line_count())
             .filter_map(|line_number| {
                 let line = source.line(line_number);
                 let local_start = line.find('#')?;
                 let start = source.line_start(line_number) + local_start;
                 Some(start..start + line[local_start..].trim_end().len())
             })
-            .collect();
-        let directives = DirectiveState::parse(&source, &comment_ranges);
+            .collect()
+    }
+
+    fn suppression_of(text: &str, cop: &'static str, line: usize) -> Option<Option<String>> {
+        let source = SourceFile::new("test.rb", text.to_owned());
+        let ranges = comment_ranges(&source);
+        let offense = Offense::new(
+            cop,
+            Severity::Convention,
+            "test",
+            source.line_start(line),
+            source.line_start(line) + 1,
+        );
+        DirectiveState::parse(&source, &ranges).suppression(&offense, &source)
+    }
+
+    /// The whole run, so that the directives are read the way the engine reads them rather than
+    /// the way the test builds them: `--only Style/For` over a file of `for` loops reports one
+    /// offense per loop the directives left switched on.
+    fn offense_count(text: &str) -> usize {
+        let config = Config::load_with_options(None, Path::new("/"), true)
+            .expect("the embedded default configuration has to load");
+        let selection = Selection {
+            only: vec!["Style/For".to_owned()],
+            ..Selection::default()
+        };
+        engine::inspect_source("example.rb", text.to_owned(), &config, &selection)
+            .expect("the source has to be inspectable")
+            .offenses
+            .len()
+    }
+
+    const FIRST_LOOP: &str = "for i in 1..2 do\n  puts i\nend\n";
+    const SECOND_LOOP: &str = "for j in 1..2 do\n  puts j\nend\n";
+
+    #[test]
+    fn handles_block_inline_reason_and_push_pop_directives() {
+        let text = "# rubocop:disable Layout -- legacy\n\
+                    a = 1  \n\
+                    # rubocop:enable Layout\n\
+                    b = 2  # rubocop:disable Layout/TrailingWhitespace\n\
+                    # rubocop:push -Layout/TrailingWhitespace\n\
+                    c = 3  \n\
+                    # rubocop:pop\n\
+                    d = 4  \n";
         for (line, expected) in [(2, true), (4, true), (6, true), (8, false)] {
-            let offense = Offense::new(
-                "Layout/TrailingWhitespace",
-                Severity::Convention,
-                "test",
-                source.line_start(line),
-                source.line_start(line) + 1,
-            );
             assert_eq!(
-                directives.suppression(&offense, &source).is_some(),
+                suppression_of(text, "Layout/TrailingWhitespace", line).is_some(),
                 expected
             );
         }
-        let offense = Offense::new(
-            "Layout/TrailingWhitespace",
-            Severity::Convention,
-            "test",
-            source.line_start(2),
-            source.line_start(2) + 1,
-        );
         assert_eq!(
-            directives.suppression(&offense, &source),
+            suppression_of(text, "Layout/TrailingWhitespace", 2),
             Some(Some("legacy".to_owned()))
         );
     }
+
+    /// `analyze_single_line` is `return analysis unless directive.disabled?`, so an `enable` that
+    /// shares its line with code changes nothing -- least of all closing the range a block-form
+    /// `disable` above it opened, which is what it used to do here and what left the rest of the
+    /// file reporting again.
+    #[test]
+    fn an_inline_enable_does_not_close_a_block_disable() {
+        let text = format!(
+            "# rubocop:disable Style/For\n{FIRST_LOOP}\
+             x = 1 # rubocop:enable Style/For\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&text, "Style/For", 6).is_some());
+        assert_eq!(offense_count(&text), 0);
+    }
+
+    /// The same for a `push`, which `CommentConfig#analyze` routes before it ever asks whether the
+    /// directive covers one line: it acts wherever it is written.
+    #[test]
+    fn an_inline_push_and_pop_still_act() {
+        let text = format!(
+            "x = 1 # rubocop:push -Style/For\n{FIRST_LOOP}\
+             y = 2 # rubocop:pop\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&text, "Style/For", 2).is_some());
+        assert!(suppression_of(&text, "Style/For", 6).is_none());
+        assert_eq!(offense_count(&text), 1);
+    }
+
+    /// `DirectiveComment#cop_names` expands a department into the cops it holds, so an `enable`
+    /// that names one of them closes that cop's range and leaves the rest of the department
+    /// switched off. Recording the department verbatim and only ever removing the name an `enable`
+    /// spelled out kept the cop disabled to the end of the file, which is the dangerous direction:
+    /// it hides offenses that RuboCop reports.
+    #[test]
+    fn an_enable_reopens_one_cop_of_a_disabled_department() {
+        let text = format!(
+            "# rubocop:disable Style\n{FIRST_LOOP}\
+             # rubocop:enable Style/For\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&text, "Style/For", 2).is_some());
+        assert!(suppression_of(&text, "Style/For", 6).is_none());
+        // The department is still switched off for everything it did not name.
+        assert!(suppression_of(&text, "Style/RedundantSelf", 6).is_some());
+        assert_eq!(offense_count(&text), 1);
+    }
+
+    /// `all` expands the same way.
+    #[test]
+    fn an_enable_reopens_one_cop_of_a_disabled_all() {
+        let text = format!(
+            "# rubocop:disable all\n{FIRST_LOOP}\
+             # rubocop:enable Style/For\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&text, "Style/For", 2).is_some());
+        assert!(suppression_of(&text, "Style/For", 6).is_none());
+        assert!(suppression_of(&text, "Layout/TrailingWhitespace", 6).is_some());
+        assert_eq!(offense_count(&text), 1);
+    }
+
+    /// A directive that names a department speaks for every cop below it, so what an earlier
+    /// directive left against one of them is gone.
+    #[test]
+    fn a_department_directive_supersedes_the_cops_below_it() {
+        let reopened_then_closed = format!(
+            "# rubocop:disable Style\n{FIRST_LOOP}\
+             # rubocop:enable Style/For\n\
+             # rubocop:disable Style\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&reopened_then_closed, "Style/For", 7).is_some());
+
+        let closed_then_reopened = format!(
+            "# rubocop:disable Style/For\n{FIRST_LOOP}\
+             # rubocop:enable Style\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&closed_then_reopened, "Style/For", 6).is_none());
+    }
+
+    /// `Registry.qualified_cop_name`: RuboCop warns about the missing department through
+    /// `Migration/DepartmentName` but honours the directive, so a name written without one -- or
+    /// under the wrong one -- reaches the cop that carries it.
+    #[test]
+    fn an_unqualified_cop_name_reaches_the_cop_that_carries_it() {
+        let bare = format!("# rubocop:disable For\n{FIRST_LOOP}");
+        assert!(suppression_of(&bare, "Style/For", 2).is_some());
+        assert_eq!(offense_count(&bare), 0);
+
+        let wrong_department = format!("# rubocop:disable Lint/For\n{FIRST_LOOP}");
+        assert!(suppression_of(&wrong_department, "Style/For", 2).is_some());
+        assert_eq!(offense_count(&wrong_department), 0);
+
+        let unqualified_enable = format!(
+            "# rubocop:disable Style/For\n{FIRST_LOOP}\
+             # rubocop:enable For\n{SECOND_LOOP}"
+        );
+        assert!(suppression_of(&unqualified_enable, "Style/For", 6).is_none());
+        assert_eq!(offense_count(&unqualified_enable), 1);
+
+        // A name no cop carries stays what it was written as and switches nothing off.
+        let unknown = format!("# rubocop:disable NotACop\n{FIRST_LOOP}");
+        assert!(suppression_of(&unknown, "Style/For", 2).is_none());
+        assert_eq!(offense_count(&unknown), 1);
+    }
+
+    /// `parser` strips the byte order mark before it lexes, so upstream's directive comment starts
+    /// at its `#` and its line holds no code. The mark is not in `White_Space`, so `trim` left it
+    /// behind and the directive read as one written behind prose -- covering line one alone.
+    #[test]
+    fn a_byte_order_mark_leaves_a_first_line_directive_block_form() {
+        let text = format!(
+            "{}# rubocop:disable Style/For\n{FIRST_LOOP}",
+            crate::source::BYTE_ORDER_MARK
+        );
+        assert!(suppression_of(&text, "Style/For", 2).is_some());
+        assert_eq!(offense_count(&text), 0);
+    }
+
+    /// The mark does not make line one hold code for `CommentConfig` either, which is the model
+    /// the cops that review directives read.
+    #[test]
+    fn a_byte_order_mark_leaves_the_first_line_comment_only() {
+        let text = format!(
+            "{}# rubocop:disable Style/For\n{FIRST_LOOP}",
+            crate::source::BYTE_ORDER_MARK
+        );
+        let source = SourceFile::new("test.rb", text);
+        assert!(!super::lines_with_code(&source, &comment_ranges(&source)).contains(&1));
+    }
+
+    /// `exclude_lint_department_cops`: the cop that reads directives is out of `all` and out of
+    /// the `Lint` department, and `Lint/Syntax` is out of every directive there is.
+    #[test]
+    fn the_two_undisableable_cops_stay_out_of_all_and_of_their_department() {
+        for directive in ["all", "Lint"] {
+            let text = format!("# rubocop:disable {directive}\nx = 1\n");
+            assert!(suppression_of(&text, "Lint/RedundantCopDisableDirective", 2).is_none());
+            assert!(suppression_of(&text, "Lint/Syntax", 2).is_none());
+            assert!(suppression_of(&text, "Lint/UselessAssignment", 2).is_some());
+        }
+        let named = "# rubocop:disable Lint/RedundantCopDisableDirective\nx = 1\n";
+        assert!(suppression_of(named, "Lint/RedundantCopDisableDirective", 2).is_some());
+    }
+
+    /// The other half of `exclude_lint_department_cops`: a later `all` or `Lint` directive does not
+    /// reach those two either, so what a directive that named one of them outright left behind
+    /// stands. Superseding the cops a broad directive expands into must not take them with it.
+    #[test]
+    fn a_broad_directive_does_not_supersede_the_two_cops_it_cannot_reach() {
+        for directive in [
+            "# rubocop:enable Lint",
+            "# rubocop:disable all",
+            "# rubocop:enable all",
+        ] {
+            let text = format!(
+                "# rubocop:disable Lint/RedundantCopDisableDirective\n{directive}\nx = 1\n"
+            );
+            assert!(
+                suppression_of(&text, "Lint/RedundantCopDisableDirective", 3).is_some(),
+                "{directive} closed a range it does not reach"
+            );
+        }
+        // Spelling the cop out does close it.
+        let closed = "# rubocop:disable Lint/RedundantCopDisableDirective\n\
+                      # rubocop:enable Lint/RedundantCopDisableDirective\n\
+                      x = 1\n";
+        assert!(suppression_of(closed, "Lint/RedundantCopDisableDirective", 3).is_none());
+    }
 }