sonicop 26.8.111 → 26.8.113

data/src/rules/naming/ascii_identifiers.rs

@@ -18,7 +18,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         // unreported even when they hold non-ascii characters. tree-sitter has no such token
         // distinction: it reuses `identifier` for keyword-argument labels, which are `tLABEL`
         // upstream and must be skipped here to keep the two in step.
-        if is_keyword_argument_label(node) {
+        if is_keyword_argument_label(node, context) {
             continue;
         }
 
@@ -42,8 +42,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     }
 }
 
-fn is_keyword_argument_label(node: tree_sitter::Node<'_>) -> bool {
-    let Some(parent) = node.parent() else {
+fn is_keyword_argument_label(node: tree_sitter::Node<'_>, context: &RuleContext<'_>) -> bool {
+    let Some(parent) = context.parent(node) else {
         return false;
     };
     matches!(parent.kind_str(), "keyword_parameter" | "pair")

data/src/rules/naming/binary_operator_parameter_name.rs

@@ -1,8 +1,9 @@
 use tree_sitter::Node;
 
-use super::support::{ParameterKind, Variables, parameters};
+use super::support::{ParameterKind, parameters};
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
+use crate::rules::lint::variable_force::Analysis;
 use crate::rules::node_ext::NodeExt;
 
 /// `EXCLUDED`: operators whose sole parameter is not the other operand. Indexing takes a key,
@@ -38,7 +39,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if text == "other" || text == "_other" {
             continue;
         }
-        let variables = variables.get_or_insert_with(|| context.variable_roles());
+        let variables = variables.get_or_insert_with(|| context.variable_analysis());
         offenses.push(
             context
                 .offense(
@@ -59,7 +60,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// one and is put off to the next pass.
 fn rename(
     context: &RuleContext<'_>,
-    variables: &Variables,
+    variables: &Analysis<'_>,
     definition: Node<'_>,
     parameter: Node<'_>,
 ) -> Vec<Edit> {
@@ -69,7 +70,7 @@ fn rename(
         if node.start_byte() <= parameter.start_byte()
             || node.end_byte() > definition.end_byte()
             || context.source.node_text(node) != name
-            || !variables.is_variable(node)
+            || !(variables.is_reference(node) || variables.is_local_assignment(node))
         {
             continue;
         }

data/src/rules/naming/block_forwarding.rs

@@ -4,8 +4,9 @@ use crate::diagnostic::{Edit, Offense};
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
-use crate::rules::push_named_children;
-use crate::rules::send_node::{named_children, send_range};
+use crate::rules::{push_named_children, push_named_children_in};
+use crate::rules::send_node::send_range;
+use crate::rules::send_node::named_children_of;
 
 /// `minimum_target_ruby_version 3.1`: anonymous block forwarding is 3.1 syntax.
 const MINIMUM: RubyVersion = RubyVersion::new(3, 1);
@@ -42,7 +43,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(parameters) = node.field("parameters") else {
             continue;
         };
-        let Some(last) = named_children(parameters).last().copied() else {
+        let Some(last) = named_children_of(parameters, context).last().copied() else {
             continue;
         };
         if expected_style(node, last, anonymous, context) {
@@ -96,13 +97,13 @@ fn expected_style(
 fn forwarded_arguments<'tree>(
     node: Node<'tree>,
     last: Node<'tree>,
-    context: &RuleContext<'_>,
+    context: &'tree RuleContext<'_>,
 ) -> Option<Vec<Node<'tree>>> {
     let unsafe_in_block = context.target_ruby_version() <= ANONYMOUS_IN_BLOCK_REJECTED_THROUGH;
     let name = context.source.node_text(last);
     let mut found = Vec::new();
     let mut stack = Vec::new();
-    push_named_children(node, &mut stack);
+    push_named_children_in(node, context, &mut stack);
     while let Some(current) = stack.pop() {
         if current.kind_str() == "block_argument" {
             // `invalidates_syntax?` is asked of every block pass, matching or not, and aborts the
@@ -111,14 +112,14 @@ fn forwarded_arguments<'tree>(
                 return None;
             }
             // `&:sym` forwards a symbol rather than the block parameter.
-            let symbolic = named_children(current).first().is_some_and(|child| {
+            let symbolic = named_children_of(current, context).first().is_some_and(|child| {
                 matches!(child.kind_str(), "simple_symbol" | "delimited_symbol")
             });
             if !symbolic && context.source.node_text(current) == name {
                 found.push(current);
             }
         }
-        push_named_children(current, &mut stack);
+        push_named_children_in(current, context, &mut stack);
     }
     Some(found)
 }
@@ -313,7 +314,7 @@ fn reads_as_variable(node: Node<'_>, name: Option<&str>, context: &RuleContext<'
         {
             return true;
         }
-        push_named_children(current, &mut stack);
+        push_named_children_in(current, context, &mut stack);
     }
     false
 }

data/src/rules/naming/constant_name.rs

@@ -3,7 +3,7 @@ use std::sync::LazyLock;
 use regex::Regex;
 use tree_sitter::Node;
 
-use super::support::{Variables, last_named_child};
+use super::support::last_named_child;
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
 use crate::rules::node_ext::NodeExt;
@@ -15,17 +15,16 @@ static SCREAMING_SNAKE_CASE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^[0-9\p{Uppercase}_]+$").unwrap());
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
-    let variables = context.variable_roles();
     // `rescue => Foo` and `for Foo in bar` are `casgn` nodes upstream just as much as `Foo = bar`
     // is, and neither carries a value, so neither can be excused by what it was assigned.
     for node in context.nodes_of("exception_variable") {
         if let Some(target) = node.named_child(0) {
-            report(context, offenses, target, None, variables);
+            report(context, offenses, target, None);
         }
     }
     for node in context.nodes_of("for") {
         if let Some(target) = node.field("pattern") {
-            report(context, offenses, target, None, variables);
+            report(context, offenses, target, None);
         }
     }
     for node in context.nodes_of_any(&["assignment", "operator_assignment"]) {
@@ -45,7 +44,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             // The grammar swallowed the items written before the assignment; only the last of them
             // is really assigned to, and it keeps the value on the right.
             if let Some(target) = last_named_child(left) {
-                report(context, offenses, target, value, variables);
+                report(context, offenses, target, value);
             }
         } else if left.kind_str() == "left_assignment_list" {
             // Every target of a multiple assignment is a casgn without an expression, so none of
@@ -53,10 +52,10 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             let mut targets = Vec::new();
             collect_targets(left, &mut targets);
             for target in targets {
-                report(context, offenses, target, None, variables);
+                report(context, offenses, target, None);
             }
         } else {
-            report(context, offenses, left, value, variables);
+            report(context, offenses, left, value);
         }
     }
 }
@@ -66,12 +65,11 @@ fn report(
     offenses: &mut Vec<Offense>,
     target: Node<'_>,
     value: Option<Node<'_>>,
-    variables: &Variables,
 ) {
     let Some(name_node) = constant_name(target) else {
         return;
     };
-    if allowed_assignment(value, variables) {
+    if allowed_assignment(value, context) {
         return;
     }
     if SCREAMING_SNAKE_CASE.is_match(context.source.node_text(name_node)) {
@@ -110,11 +108,11 @@ fn collect_targets<'tree>(node: Node<'tree>, targets: &mut Vec<Node<'tree>>) {
 /// The shapes `allowed_assignment?` lets through. RuboCop only judges a constant's spelling once
 /// it can tell the value is not a class or module, because `SomeClass = SomeOtherClass` is a
 /// perfectly good CamelCase constant.
-fn allowed_assignment(value: Option<Node<'_>>, variables: &Variables) -> bool {
+fn allowed_assignment(value: Option<Node<'_>>, context: &RuleContext<'_>) -> bool {
     let Some(value) = value else {
         return false;
     };
-    match value_kind(value, variables) {
+    match value_kind(value, context) {
         Value::ClassLike => true,
         Value::Call { receiver } => receiver.is_none_or(|receiver| !literal_receiver(receiver)),
         Value::Conditional => branches(value).into_iter().any(is_constant),
@@ -133,7 +131,7 @@ enum Value<'tree> {
     Other,
 }
 
-fn value_kind<'tree>(node: Node<'tree>, variables: &Variables) -> Value<'tree> {
+fn value_kind<'tree>(node: Node<'tree>, context: &RuleContext<'_>) -> Value<'tree> {
     match node.kind_str() {
         "constant" => Value::ClassLike,
         "scope_resolution" => match node.field("name") {
@@ -148,14 +146,28 @@ fn value_kind<'tree>(node: Node<'tree>, variables: &Variables) -> Value<'tree> {
             _ => Value::Other,
         },
         // A method call carrying a block is a `block` node upstream, not a `send`.
-        "call" if node.field("block").is_some() => Value::ClassLike,
+        //
+        // **`numblock` and `itblock` are not `block`.** A block using `_1` or `it` reaches upstream
+        // as a type of its own, which the `%i[block const casgn]` list does not name -- so
+        // `Foo = Module.new do a(_1) end` is reported where the same block spelling its parameter
+        // is not.
+        // **A `numblock` passes every allowance.** It is not in `%i[block const casgn]`, it is no
+        // `send`, and `class_or_struct_return_method?` never reaches it -- so upstream reports the
+        // constant that a plain block would excuse.
+        "call" if node.field("block").is_some() => match node
+            .field("block")
+            .is_some_and(|block| is_numbered_block(context, block))
+        {
+            true => Value::Other,
+            false => Value::ClassLike,
+        },
         "lambda" => Value::ClassLike,
         "call" => Value::Call {
             receiver: node.field("receiver"),
         },
         // A bare identifier is a receiverless call unless the parser resolved it to a local.
         "identifier" => {
-            if variables.is_reference(node) {
+            if context.variable_analysis().is_reference(node) {
                 Value::Other
             } else {
                 Value::Call { receiver: None }
@@ -171,9 +183,7 @@ fn value_kind<'tree>(node: Node<'tree>, variables: &Variables) -> Value<'tree> {
         "unary" => match operator(node) {
             Some("defined?") => Value::Other,
             // A signed number reaches the parser as one numeric literal, not a call to `-@`.
-            Some("-" | "+") if node.field("operand").is_some_and(numeric) => {
-                Value::Other
-            }
+            Some("-" | "+") if node.field("operand").is_some_and(numeric) => Value::Other,
             _ => Value::Call {
                 receiver: node.field("operand"),
             },
@@ -227,7 +237,10 @@ fn is_literal(node: Node<'_>) -> bool {
 }
 
 fn numeric(node: Node<'_>) -> bool {
-    matches!(node.kind_str(), "integer" | "float" | "rational" | "complex")
+    matches!(
+        node.kind_str(),
+        "integer" | "float" | "rational" | "complex"
+    )
 }
 
 fn is_constant(node: Node<'_>) -> bool {
@@ -282,3 +295,28 @@ fn operator(node: Node<'_>) -> Option<&'static str> {
         }
     }
 }
+
+/// The version `it` becomes a block parameter rather than a method call.
+const IT_VERSION: crate::ruby_version::RubyVersion = crate::ruby_version::RubyVersion::new(3, 4);
+
+/// `numblock` / `itblock`: a block with no parameter list that names `_1`…`_9` or `it` instead.
+fn is_numbered_block(context: &RuleContext<'_>, block: Node<'_>) -> bool {
+    if block.field("parameters").is_some() {
+        return false;
+    }
+    let mut found = false;
+    crate::rules::walk_named(block, context, &mut |node| {
+        if found || node.kind_str() != "identifier" {
+            return;
+        }
+        let text = context.source.node_text(node);
+        // `it` is an `itblock` only from 3.4 on; before that it is an ordinary method call, and
+        // the block stays a `block`.
+        found |= (context.target_ruby_version() >= IT_VERSION && text == "it")
+            || (text.len() == 2
+                && text.starts_with('_')
+                && text.as_bytes()[1].is_ascii_digit()
+                && text.as_bytes()[1] != b'0');
+    });
+    found
+}

data/src/rules/naming/file_name.rs

@@ -1,12 +1,12 @@
-use std::path::Path;
 use std::sync::LazyLock;
 
-use globset::Glob;
 use regex::Regex;
+use tree_sitter::Node;
 
 use super::support::{ruby_regex, ruby_regex_to_s};
 use crate::diagnostic::Offense;
 use crate::rules::RuleContext;
+use crate::rules::node_ext::NodeExt;
 
 /// `SNAKE_CASE`, whose POSIX class is Unicode-aware in Ruby. A dot is allowed because only the
 /// last extension is stripped before the name is judged.
@@ -15,7 +15,7 @@ static SNAKE_CASE: LazyLock<Regex> =
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     let path = context.source.path();
-    if allowed_camel_case_file(context, path) {
+    if context.config.allowed_camel_case_file(path) {
         return;
     }
     let Some(basename) = path.file_name().and_then(|name| name.to_str()) else {
@@ -25,9 +25,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         .setting::<serde_yaml_ng::Value>("Regex")
         .as_ref()
         .and_then(ruby_regex);
-    // `ExpectMatchingDefinition` is off by default, and the checks it turns on are the only ones
-    // that inspect the file's contents; a name that is already snake_case is otherwise fine.
+    // `for_bad_filename` branches both ways: a name that *is* good is where the class-and-module
+    // checks run, and a name that is not is where the naming message comes from. Returning early
+    // on a good name skipped `ExpectMatchingDefinition` entirely.
     if filename_good(basename, pattern.unwrap_or(&SNAKE_CASE)) {
+        if let Some(message) = class_and_module_naming(context, path, basename) {
+            offenses.push(context.offense(message, 0..0));
+        }
         return;
     }
     let ignore_scripts: bool = context.setting("IgnoreExecutableScripts").unwrap_or(true);
@@ -47,6 +51,171 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     offenses.push(context.offense(message, 0..0));
 }
 
+/// `perform_class_and_module_naming_checks`: with `ExpectMatchingDefinition` on, a well-named file
+/// still has to define the constant its name spells.
+fn class_and_module_naming(
+    context: &RuleContext<'_>,
+    path: &std::path::Path,
+    basename: &str,
+) -> Option<String> {
+    if !context
+        .setting::<bool>("ExpectMatchingDefinition")
+        .unwrap_or(false)
+    {
+        return None;
+    }
+    let hierarchy: bool = context
+        .setting("CheckDefinitionPathHierarchy")
+        .unwrap_or(true);
+    let acronyms: Vec<String> = context.setting("AllowedAcronyms").unwrap_or_default();
+    // The two arms differ only in what the namespace is read off: the whole path, or the base name
+    // alone. The message quotes whichever was used.
+    let (namespace, quoted) = match hierarchy {
+        true => (
+            to_namespace(context, path),
+            path.to_string_lossy().into_owned(),
+        ),
+        false => (
+            to_namespace(context, std::path::Path::new(basename)),
+            basename.to_owned(),
+        ),
+    };
+    if finds_definition(context, &namespace, &acronyms) {
+        return None;
+    }
+    let _ = quoted;
+    Some(format!(
+        "`{basename}` should define a class or module called `{}`.",
+        namespace.join("::")
+    ))
+}
+
+/// `to_namespace`: the path split into constant names, starting at the innermost directory the
+/// configuration calls a root. With no root in the path only the file's own name is used.
+fn to_namespace(context: &RuleContext<'_>, path: &std::path::Path) -> Vec<String> {
+    let roots: Vec<String> = context
+        .setting("CheckDefinitionPathHierarchyRoots")
+        .unwrap_or_else(|| ["lib", "spec", "test", "src"].map(str::to_owned).to_vec());
+    let components: Vec<String> = path
+        .iter()
+        .map(|part| part.to_string_lossy().into_owned())
+        .collect();
+    let start = components
+        .iter()
+        .rposition(|part| roots.contains(part))
+        .map(|index| index + 1);
+    match start {
+        Some(index) if index < components.len() => components[index..]
+            .iter()
+            .map(|part| module_name(part))
+            .collect(),
+        _ => components
+            .last()
+            .map(|part| vec![module_name(part)])
+            .unwrap_or_default(),
+    }
+}
+
+/// `to_module_name`: the extension goes, the underscores split words, each word is capitalised.
+fn module_name(basename: &str) -> String {
+    let stem = basename.split_once('.').map_or(basename, |(head, _)| head);
+    stem.split('_')
+        .map(|word| {
+            let mut characters = word.chars();
+            match characters.next() {
+                Some(first) => first.to_uppercase().collect::<String>() + characters.as_str(),
+                None => String::new(),
+            }
+        })
+        .collect()
+}
+
+/// `find_class_or_module`: whether the file defines the innermost name, nested in the rest.
+///
+/// The nesting is checked by name rather than by walking upwards the way upstream does -- the
+/// namespaces a file writes are what `class A::B` and `module A; module B` both spell out.
+fn finds_definition(context: &RuleContext<'_>, namespace: &[String], acronyms: &[String]) -> bool {
+    let Some((name, outer)) = namespace.split_last() else {
+        return true;
+    };
+    context
+        .nodes_of_any(&["class", "module", "assignment"])
+        .any(|node| {
+            let Some(defined) = defined_constant(context, node) else {
+                return false;
+            };
+            let Some((last, prefix)) = defined.split_last() else {
+                return false;
+            };
+            if last != name && !matches_acronym(name, last, acronyms) {
+                return false;
+            }
+            outer.is_empty() || enclosing_names(context, node, prefix).ends_with(outer)
+        })
+}
+
+/// The constant a `class` / `module` / `Struct.new` assignment defines, as its written path.
+fn defined_constant(context: &RuleContext<'_>, node: Node<'_>) -> Option<Vec<String>> {
+    let named = match node.kind_str() {
+        "class" | "module" => node.field("name")?,
+        // `Foo = Struct.new(...)` defines `Foo` the same way.
+        "assignment" => {
+            let left = node.field("left")?;
+            let right = node.field("right")?;
+            let struct_new = right.kind_str() == "call"
+                && right
+                    .field("receiver")
+                    .is_some_and(|receiver| context.source.node_text(receiver) == "Struct")
+                && right
+                    .field("method")
+                    .is_some_and(|method| context.source.node_text(method) == "new");
+            if !struct_new {
+                return None;
+            }
+            left
+        }
+        _ => return None,
+    };
+    let text = context.source.node_text(named);
+    Some(
+        text.trim_start_matches("::")
+            .split("::")
+            .map(str::to_owned)
+            .collect(),
+    )
+}
+
+/// The names a definition is written inside, innermost last, with what its own path already spells.
+fn enclosing_names(context: &RuleContext<'_>, node: Node<'_>, prefix: &[String]) -> Vec<String> {
+    let mut names: Vec<String> = Vec::new();
+    let mut current = node.parent();
+    while let Some(ancestor) = current {
+        if matches!(ancestor.kind_str(), "class" | "module")
+            && let Some(defined) = defined_constant(context, ancestor)
+        {
+            for part in defined.into_iter().rev() {
+                names.push(part);
+            }
+        }
+        current = ancestor.parent();
+    }
+    names.reverse();
+    names.extend(prefix.iter().cloned());
+    names
+}
+
+/// `match_acronym?`: an acronym listed in `AllowedAcronyms` may be written in full caps.
+fn matches_acronym(expected: &str, name: &str, acronyms: &[String]) -> bool {
+    let folded = acronyms.iter().fold(name.to_owned(), |result, acronym| {
+        let mut capitalized = acronym.to_lowercase();
+        if let Some(first) = capitalized.get_mut(0..1) {
+            first.make_ascii_uppercase();
+        }
+        result.replace(acronym.as_str(), &capitalized)
+    });
+    expected == folded
+}
+
 /// `filename_good?`: the leading dot and the last extension are dropped, the one `+` an Action Pack
 /// variant name carries becomes an underscore, and what is left has to match the pattern.
 fn filename_good(basename: &str, pattern: &Regex) -> bool {
@@ -58,41 +227,3 @@ fn filename_good(basename: &str, pattern: &Regex) -> bool {
     let stem = stem.replacen('+', "_", 1);
     pattern.is_match(&stem)
 }
-
-/// `allowed_camel_case_file?`: a gemspec may use dashes to spell a namespace, and a file that only
-/// reaches the run through an `Include` pattern written with capitals -- `Rakefile`, `Gemfile` --
-/// is named after that pattern rather than after Ruby's conventions.
-fn allowed_camel_case_file(context: &RuleContext<'_>, path: &Path) -> bool {
-    if path
-        .extension()
-        .is_some_and(|extension| extension == "gemspec")
-    {
-        return true;
-    }
-    let Some(includes) = context.setting_of::<Vec<String>>("AllCops", "Include") else {
-        return false;
-    };
-    let candidates: Vec<String> = [
-        path.to_str().map(str::to_owned),
-        path.file_name()
-            .and_then(|name| name.to_str())
-            .map(str::to_owned),
-    ]
-    .into_iter()
-    .flatten()
-    .collect();
-    includes
-        .iter()
-        .filter(|pattern| {
-            pattern
-                .chars()
-                .any(|character| character.is_ascii_uppercase())
-        })
-        .filter_map(|pattern| Glob::new(pattern).ok())
-        .any(|glob| {
-            let matcher = glob.compile_matcher();
-            candidates
-                .iter()
-                .any(|candidate| matcher.is_match(candidate))
-        })
-}

data/src/rules/naming/method_name.rs

@@ -24,6 +24,8 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
             .setting("EnforcedStyle")
             .unwrap_or_else(|| "snake_case".to_owned()),
         forbidden: context.setting("ForbiddenIdentifiers").unwrap_or_default(),
+        // `forbidden_name?` is `forbidden_identifier? || forbidden_pattern?`.
+        forbidden_patterns: super::support::forbidden_patterns(context),
         reported: HashSet::new(),
         offenses,
     };
@@ -40,6 +42,7 @@ struct Check<'a, 'tree> {
     context: &'a RuleContext<'tree>,
     style: String,
     forbidden: Vec<String>,
+    forbidden_patterns: Vec<&'static regex::Regex>,
     /// `Base#add_offense` drops a second offense at a range it already reported, and
     /// `attr_accessor :aB, :cD` reports both names over the same range.
     reported: HashSet<Range<usize>>,
@@ -171,7 +174,7 @@ impl Check<'_, '_> {
     }
 
     fn class_emitter_method(&self, node: Node<'_>, name: &str) -> bool {
-        super::support::class_emitter_method(node, name, self.context.source)
+        super::support::class_emitter_method(node, name, self.context)
     }
 
     /// Whether the call's receiver is the bare `Struct`/`Data` constant. `(const {nil? cbase} …)`
@@ -228,6 +231,10 @@ impl Check<'_, '_> {
 
     fn is_forbidden(&self, name: &str) -> bool {
         self.forbidden.iter().any(|forbidden| forbidden == name)
+            || self
+                .forbidden_patterns
+                .iter()
+                .any(|pattern| pattern.is_match(name))
     }
 
     fn style_offense(&mut self, range: Range<usize>) {