shirobai 2026.0820.0300 → 2026.0905.1300

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dba7704fcfe48ea2b368a6eae1afadb52dbfaaa926c4388f9d74a038f64c8bdf
-  data.tar.gz: 17e02721945c202d5cd39487dc155b66c42180f21e6692e58c3c0a8818b2d246
+  metadata.gz: 1f4f98851b8d60acd4a275498959e3e6a0fca00455715bcdfa5b16a653a90015
+  data.tar.gz: 9bb15c3004bfa6415d01d2e6038dfa430cd930f260f988faf22133f445869597
 SHA512:
-  metadata.gz: de5ec9277179462e47e99b30b209e261a6bfc3468ef63f62e49bcf3d1e88ff92ff3fa5aa20d1c1dd67b52934a5197d2b99f334f944c9e5cf9da074d38271ad97
-  data.tar.gz: 8dd4eae8d0a5f3fa820fed008736b4c0381445eab74b6ee2f665958727281e658bba766c405883f6fa4e1fac9f9ba8d443df04310435ace19c5bb779ff2de374
+  metadata.gz: 7effd8214232c64b9fee9ecbe046bf102e2b24936aef4c991039bd8028acc79d936b4c6d0d42ed184a247e1e1ac0b1ea0ca268f57c6001a3d16e9913af9106a5
+  data.tar.gz: 186a7b1f6e790e78c73f85ed0000bacf40ed19dbb8c0ab426b52b31b124f81f7eb907392400732b242b8fd92026907bef51f637f117c0957e92c14f117f1f3ae

data/Cargo.lock

@@ -356,7 +356,7 @@ checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
 
 [[package]]
 name = "shirobai"
-version = "2026.820.300"
+version = "2026.905.1300"
 dependencies = [
  "magnus",
  "shirobai-core",
@@ -364,7 +364,7 @@ dependencies = [
 
 [[package]]
 name = "shirobai-core"
-version = "2026.820.300"
+version = "2026.905.1300"
 dependencies = [
  "libc",
  "ruby-prism",

data/Cargo.toml

@@ -7,7 +7,7 @@ resolver = "3"
 # is crate 2026.709.0 -- cargo rejects leading zeros in numeric segments, and
 # Gem::Version normalizes to the same integers, so the two stay value-equal).
 [workspace.package]
-version = "2026.820.300"
+version = "2026.905.1300"
 
 # Release tuning. The hot path crosses crate boundaries (ext cdylib -> core
 # check_* -> ruby-prism); without LTO the cross-crate calls are not inlined and

data/crates/shirobai-core/src/bin/analysis_profile.rs

@@ -288,7 +288,7 @@ fn run_cop(cop: &str, sources: &[Vec<u8>]) -> usize {
             for s in sources {
                 sink = sink.wrapping_add(
                     rules::first_argument_indentation::check_first_argument_indentation(
-                        s, 0, 2, false,
+                        s, 0, 2, 0,
                     )
                     .len(),
                 );

data/crates/shirobai-core/src/bin/bundle_profile.rs

@@ -221,7 +221,7 @@ fn run_perrule(sources: &[Vec<u8>], cfg: &BundleConfig, iterations: usize) {
                 s,
                 cfg.first_argument_style,
                 cfg.first_argument_indent,
-                cfg.first_argument_enforce_fixed_no_line_break,
+                cfg.first_argument_fixed_mode,
             ));
         }),
         e!("redundant_self", |s: &[u8]| {

data/crates/shirobai-core/src/bin/hotspot_profile.rs

@@ -411,7 +411,7 @@ fn run_full_firstarg(sources: &[Vec<u8>]) -> usize {
     let mut sink = 0usize;
     for s in sources {
         sink = sink.wrapping_add(
-            rules::first_argument_indentation::check_first_argument_indentation(s, 0, 2, false)
+            rules::first_argument_indentation::check_first_argument_indentation(s, 0, 2, 0)
                 .len(),
         );
     }

data/crates/shirobai-core/src/rules/aligner.rs

@@ -1,12 +1,15 @@
 //! Shared alignment helper for the `AllowForAlignment` family of cops.
 //!
-//! `Layout/SpaceAroundOperators` and `Layout/SpaceBeforeFirstArg` both honour an
+//! `Layout/SpaceAroundOperators` and `Layout/ExtraSpacing` both honour an
 //! `AllowForAlignment` option that permits extra spacing used to vertically
 //! align a token with something on a preceding or following line. The logic is
 //! the `PrecedingFollowingAlignment` mixin in stock rubocop
 //! (`lib/rubocop/cop/mixin/preceding_following_alignment.rb`). This module hosts
-//! the single implementation both cops drive (copy-divergence is forbidden;
-//! equivalence is held by each cop's cargo tests).
+//! the single implementation both token-stream cops drive (copy-divergence is
+//! forbidden; equivalence is held by each cop's cargo tests).
+//! `Layout/SpaceBeforeFirstArg` runs the same search over a masked byte scan
+//! (it has no token stream); a change to the search rules here must be
+//! mirrored in `space_before_first_arg.rs`.
 //!
 //! [`Aligner`] is bound to one source + its parser-gem token list. It needs the
 //! token list, so callers build it in the walk-outer phase (the token cache
@@ -198,8 +201,18 @@ impl<'a> Aligner<'a> {
             let Some(index) = first_non_space_index(line) else {
                 continue;
             };
-            if matches!(indent, Some(ind) if ind != index) {
-                continue;
+            if let Some(ind) = indent {
+                // When searching for the nearest line with the same
+                // indentation, more deeply indented lines are nested content
+                // of the current group and are skipped, but a less deeply
+                // indented line ends the enclosing block: an alignment anchor
+                // beyond it would be coincidental (1.90).
+                if index < ind {
+                    break;
+                }
+                if index > ind {
+                    continue;
+                }
             }
             // The first line with a non-space (and matching indent, if given)
             // decides the result; stock returns the predicate value here.
@@ -220,7 +233,7 @@ impl<'a> Aligner<'a> {
 
     /// `aligned_comment_lines`: lines of full-line comments (a comment whose
     /// expression begins its line).
-    fn aligned_comment_line(&self, line: usize) -> bool {
+    pub(crate) fn aligned_comment_line(&self, line: usize) -> bool {
         self.tokens.iter().any(|t| {
             t.comment() && self.line(t.begin_pos) == line && self.begins_its_line(t.begin_pos)
         })

data/crates/shirobai-core/src/rules/bundle.rs

@@ -113,7 +113,7 @@ pub fn check_multiline_bundle(
 /// | 15-17 | multiline_operation style / indent / base |
 /// | 18-20 | multiline_method_call style / indent / base |
 /// | 21-23 | argument_alignment style / indent / incompatible |
-/// | 24-26 | first_argument_indentation style / indent / enforce_fixed_no_line_break |
+/// | 24-26 | first_argument_indentation style / indent / fixed_mode (0 off / 1 `with_fixed_indentation` with FirstMethodArgumentLineBreak off: defer all / 2 with it on: defer conflicts) |
 /// | 27-33 | indentation_width width / relative_to_receiver / access_modifier_outdent / indented_internal_methods / end_align / def_end_align_def / use_tabs |
 /// | 34  | closing_paren_indent |
 /// | 35-37 | first_array_element style / indent / enforce_fixed_indentation |
@@ -231,6 +231,7 @@ pub fn check_multiline_bundle(
 /// | 26  | arguments_forwarding RedundantKeywordRestArgumentNames |
 /// | 27  | arguments_forwarding RedundantBlockArgumentNames |
 /// | 28  | duplicate_methods_delegating (`Lint/DuplicateMethods` `DelegatingMethods`, 1.89) |
+/// | 29  | method_name_forbidden (`Naming/MethodName` `ForbiddenIdentifiers`: valid-style names the filtered flavor keeps) |
 ///
 /// Performance segment `nums[1]` (the shirobai-performance plugin origin):
 ///
@@ -319,6 +320,9 @@ pub struct BundleConfig {
     pub variable_number_flags: u8,
     pub variable_number_allowed_identifiers: Vec<String>,
     pub method_name_style: u8,
+    /// `Naming/MethodName` `ForbiddenIdentifiers`: names the filtered flavor
+    /// returns even when their style is fine (list 29).
+    pub method_name_forbidden: Vec<String>,
     pub safe_navigation_nil_methods: Vec<String>,
     pub dot_position_style: u8,
     pub line_length_max: usize,
@@ -333,7 +337,7 @@ pub struct BundleConfig {
     pub array_alignment_indent: usize,
     pub first_argument_style: u8,
     pub first_argument_indent: usize,
-    pub first_argument_enforce_fixed_no_line_break: bool,
+    pub first_argument_fixed_mode: u8,
     pub indentation_width: indentation_width::Config,
     pub closing_paren_indent: usize,
     pub first_array_element_style: u8,
@@ -486,7 +490,7 @@ pub const ORIGIN_RAILS: usize = 3;
 pub const N_ORIGINS: usize = 4;
 
 const CORE_NUMS_LEN: usize = 134;
-const CORE_LISTS_LEN: usize = 29;
+const CORE_LISTS_LEN: usize = 30;
 const PERF_NUMS_LEN: usize = 3;
 const PERF_LISTS_LEN: usize = 1;
 
@@ -564,6 +568,8 @@ impl BundleConfig {
             variable_number_flags: nums[9] as u8,
             variable_number_allowed_identifiers: next_list(),
             method_name_style: nums[10] as u8,
+            // Filled after the literal: list 29 follows the DuplicateMethods list.
+            method_name_forbidden: Vec::new(),
             safe_navigation_nil_methods: next_list(),
             dot_position_style: nums[11] as u8,
             line_length_max: nums[12] as usize,
@@ -579,7 +585,7 @@ impl BundleConfig {
             frozen_string_literal_comment_style: nums[116] as u8,
             first_argument_style: nums[24] as u8,
             first_argument_indent: nums[25] as usize,
-            first_argument_enforce_fixed_no_line_break: nums[26] != 0,
+            first_argument_fixed_mode: nums[26] as u8,
             indentation_width: indentation_width::Config {
                 width: nums[27] as usize,
                 relative_to_receiver: nums[28] != 0,
@@ -862,6 +868,7 @@ impl BundleConfig {
             rails: rails_config::RailsConfig::from_segment(rails_nums, &rails_lists)?,
         };
         bundle.duplicate_methods.delegating_methods = next_list();
+        bundle.method_name_forbidden = next_list();
         Ok(bundle)
     }
 }
@@ -1216,7 +1223,7 @@ pub fn check_all_bundle(source: &[u8], cfg: &BundleConfig) -> BundleResult {
         source,
         cfg.first_argument_style,
         cfg.first_argument_indent,
-        cfg.first_argument_enforce_fixed_no_line_break,
+        cfg.first_argument_fixed_mode,
     );
     let mut snc_rule = safe_navigation_chain::build_rule(source, &cfg.safe_navigation_nil_methods);
     let mut iw_rule = indentation_width::build_rule(source, cfg.indentation_width, &[], &[]);
@@ -1588,7 +1595,7 @@ pub fn check_all_bundle(source: &[u8], cfg: &BundleConfig) -> BundleResult {
     };
     // `Layout/ExtraSpacing` is a token-scan cop with an AST side input: it walks
     // the token stream collected up front as adjacent pairs, and its own
-    // `with_parsed` (`collect_def_equals`, sharing the cached parse) supplies the
+    // `with_parsed` (`collect_def_info`, sharing the cached parse) supplies the
     // `remove_equals_in_def` positions the alignment / assignment logic needs.
     let extra_spacing = match &bundle_tokens {
         Some(tokens) if cfg.extra_spacing_enabled => {
@@ -1720,9 +1727,15 @@ pub fn check_all_bundle(source: &[u8], cfg: &BundleConfig) -> BundleResult {
         );
 
     // --- Cops off the shared walk (see the doc comment above). ---
-    // The bundle always computes the filtered flavor; a `MethodName` whose
-    // config needs the unfiltered one takes the fallback path on the Ruby side.
-    let method_name = method_name::check_method_name_filtered(source, cfg.method_name_style, true);
+    // The bundle always computes the filtered flavor (keeping the forbidden
+    // identifiers); a `MethodName` whose config needs the unfiltered one
+    // (pattern lists) takes the fallback path on the Ruby side.
+    let method_name = method_name::check_method_name_filtered_keeping(
+        source,
+        cfg.method_name_style,
+        true,
+        &cfg.method_name_forbidden,
+    );
     let line_length = line_length::check_line_length_with_heredocs(
         source,
         cfg.line_length_max,
@@ -2028,6 +2041,7 @@ mod tests {
             ["kwargs", "options", "opts"].map(String::from).to_vec(), // af: RedundantKeywordRestArgumentNames
             ["blk", "block", "proc"].map(String::from).to_vec(), // af: RedundantBlockArgumentNames
             vec!["delegate".to_string()], // duplicate_methods: DelegatingMethods
+            vec![],                       // method_name: ForbiddenIdentifiers
         ];
         // Performance segment (origin 1): enabled, with the SafeMultiline
         // defaults and RuboCop's default preferred method for Detect
@@ -2585,7 +2599,7 @@ mod tests {
             src.as_bytes(),
             0,
             2,
-            false,
+            0,
         );
         assert!(!fa_alone.is_empty());
         assert_eq!(bundle.first_argument_indentation.len(), fa_alone.len());

data/crates/shirobai-core/src/rules/duplicate_methods.rs

@@ -105,9 +105,10 @@ pub struct DupMethodEvent {
     /// 1.89 the suffix is `"@#{path}:#{line}:#{begin_pos}"`
     /// (`anon_block_identity`), distinguishing blocks that share a line.
     pub scope_begin: i64,
-    /// A `track_self_alias` event (1.89): `name` carries the humanized
-    /// method name; the wrapper records it and skips the bookkeeping.
-    pub self_alias: bool,
+    /// A `track_intentional_redefinition` event (1.89 self-alias trick, 1.90
+    /// Active Support markers): `name` carries the humanized method name;
+    /// the wrapper records it and skips the bookkeeping.
+    pub intentional_redefinition: bool,
     /// The key carries a scope id (`scope_id` non-nil in stock) — gates the
     /// project-index cross-file check in the wrapper.
     pub scoped: bool,
@@ -116,6 +117,8 @@ pub struct DupMethodEvent {
 }
 
 const RESTRICT_ON_SEND: &[&[u8]] = &[
+    b"silence_redefinition_of_method",
+    b"redefine_method",
     b"alias_method",
     b"attr_reader",
     b"attr_writer",
@@ -727,17 +730,19 @@ impl<'s> DuplicateMethodsRule<'s> {
             line,
             rescue_scope,
             scope_begin,
-            self_alias: false,
+            intentional_redefinition: false,
             scoped,
             inside_def,
         });
     }
 
-    /// Stock `track_self_alias` (1.89): `alias foo foo` /
-    /// `alias_method :foo, :foo` marks an intentional redefinition of a
-    /// method defined in another file. Only tracked when
+    /// Stock `track_intentional_redefinition`: `alias foo foo` /
+    /// `alias_method :foo, :foo` (1.89) and, with
+    /// `ActiveSupportExtensionsEnabled`, `silence_redefinition_of_method
+    /// :foo` / `redefine_method(:foo)` (1.90) mark an intentional
+    /// redefinition of a method defined in another file. Only tracked when
     /// `parent_module_name` resolves, like stock.
-    fn track_self_alias(&mut self, name: &str) {
+    fn track_intentional_redefinition(&mut self, name: &str) {
         let Some(scope) = self.pmn(self.frames.len()) else {
             return;
         };
@@ -753,7 +758,7 @@ impl<'s> DuplicateMethodsRule<'s> {
             line: 0,
             rescue_scope: 0,
             scope_begin: -1,
-            self_alias: true,
+            intentional_redefinition: true,
             scoped: false,
             inside_def: false,
         });
@@ -930,7 +935,7 @@ impl<'s> DuplicateMethodsRule<'s> {
             return;
         };
         if new == old {
-            self.track_self_alias(&new);
+            self.track_intentional_redefinition(&new);
             return;
         }
         if self.if_depth > 0 {
@@ -1016,7 +1021,7 @@ impl<'s> DuplicateMethodsRule<'s> {
                     return;
                 };
                 if new == old {
-                    self.track_self_alias(&new);
+                    self.track_intentional_redefinition(&new);
                     return;
                 }
                 if self.if_depth > 0 {
@@ -1078,6 +1083,20 @@ impl<'s> DuplicateMethodsRule<'s> {
                 let defined = values.last().unwrap().clone().unwrap();
                 self.found_instance_method(&defined, off, node_start);
             }
+            // `active_support_redefinition_marker` (1.90): `(send nil?
+            // {:silence_redefinition_of_method :redefine_method} ({sym str}
+            // $_) ...)`. Scope resolution starts from the call node itself —
+            // stock passes `node.block_node || node` because parser hangs
+            // the block above the send, prism below it.
+            b"silence_redefinition_of_method" | b"redefine_method" => {
+                if !self.cfg.active_support_extensions_enabled {
+                    return;
+                }
+                let Some(marked) = args.first().and_then(sym_or_str_value) else {
+                    return;
+                };
+                self.track_intentional_redefinition(&marked);
+            }
             b"def_delegators" | b"def_instance_delegators" => {
                 if args.len() < 2 {
                     return;
@@ -1450,7 +1469,7 @@ mod tests {
     fn events(src: &str) -> Vec<(String, String, i64, i64, u8)> {
         all_events(src)
             .into_iter()
-            .filter(|e| !e.self_alias)
+            .filter(|e| !e.intentional_redefinition)
             .map(|e| (e.key, e.name, e.scope_line, e.sexp_start, e.rescue_scope))
             .collect()
     }
@@ -1667,11 +1686,11 @@ mod tests {
     fn alias_forms() {
         assert_eq!(keys("class A\n  alias foo bar\nend\n"), vec!["A#foo"]);
         assert_eq!(keys("class A\n  alias foo foo\nend\n"), Vec::<String>::new());
-        // ...but 1.89 tracks it as a self-alias event (the intentional
+        // ...but 1.89 tracks it as an intentional-redefinition event (the
         // cross-file redefinition marker).
         let sa: Vec<DupMethodEvent> = all_events("class A\n  alias foo foo\nend\n")
             .into_iter()
-            .filter(|e| e.self_alias)
+            .filter(|e| e.intentional_redefinition)
             .collect();
         assert_eq!(sa.len(), 1);
         assert_eq!(sa[0].name, "A#foo");
@@ -1721,6 +1740,30 @@ mod tests {
         assert_eq!(evts[0].key, "A#foo");
     }
 
+    // Active Support redefinition markers (1.90): tracked like the
+    // self-alias trick, only with `ActiveSupportExtensionsEnabled`. The
+    // `redefine_method` block hangs off the call in prism, so the scope
+    // still resolves to the enclosing class.
+    #[test]
+    fn active_support_redefinition_markers() {
+        let src = "class A\n  silence_redefinition_of_method :foo\n  redefine_method('bar') do\n    1\n  end\nend\n";
+        let marked = |enabled: bool| {
+            check_duplicate_methods(
+                src.as_bytes(),
+                &Config {
+                    active_support_extensions_enabled: enabled,
+                    delegating_methods: vec!["delegate".to_string()],
+                },
+            )
+            .into_iter()
+            .filter(|e| e.intentional_redefinition)
+            .map(|e| e.name)
+            .collect::<Vec<_>>()
+        };
+        assert_eq!(marked(true), vec!["A#foo", "A#bar"]);
+        assert!(marked(false).is_empty());
+    }
+
     // delegate prefix handling.
     #[test]
     fn delegate_prefix() {