shirobai 2026.0713.1900 → 2026.0820.0300

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c30aa19df5a7127a9ef22225af01bb0cf954f22bf0d6b24b3a0a078f92c048a5
-  data.tar.gz: 72b8d186516eee2a565482698b6bc44d981407f1c89d8cdc4eafe9d05b7903e8
+  metadata.gz: dba7704fcfe48ea2b368a6eae1afadb52dbfaaa926c4388f9d74a038f64c8bdf
+  data.tar.gz: 17e02721945c202d5cd39487dc155b66c42180f21e6692e58c3c0a8818b2d246
 SHA512:
-  metadata.gz: 2ca531e38a5565b0b3e132baf5b5ced764ac8fe019df25fd1e5a910ef0ff871adbcdbe1fd9afd2bf76330066501548c486a69cf64482383fef9e87ed4dff67e2
-  data.tar.gz: e5831ba58f7e9e93ab79ecefe6a57d96d02a334ee8653a8c356b9dc56f3c2a558022cb509d96f97c65d422f4e6053d74a14a0e1f010a6c95ee747c1acc51ff98
+  metadata.gz: de5ec9277179462e47e99b30b209e261a6bfc3468ef63f62e49bcf3d1e88ff92ff3fa5aa20d1c1dd67b52934a5197d2b99f334f944c9e5cf9da074d38271ad97
+  data.tar.gz: 8dd4eae8d0a5f3fa820fed008736b4c0381445eab74b6ee2f665958727281e658bba766c405883f6fa4e1fac9f9ba8d443df04310435ace19c5bb779ff2de374

data/Cargo.lock

@@ -356,7 +356,7 @@ checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
 
 [[package]]
 name = "shirobai"
-version = "2026.713.1900"
+version = "2026.820.300"
 dependencies = [
  "magnus",
  "shirobai-core",
@@ -364,7 +364,7 @@ dependencies = [
 
 [[package]]
 name = "shirobai-core"
-version = "2026.713.1900"
+version = "2026.820.300"
 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.713.1900"
+version = "2026.820.300"
 
 # 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/rules/ambiguous_block_association.rs

@@ -98,6 +98,16 @@ pub struct Config {
 
 #[derive(Debug, Clone)]
 pub struct AmbiguousBlockAssociationOffense {
+    /// 0 — the classic paren ambiguity (stock `on_send`): the fields read as
+    /// documented below and the offense is correctable.
+    ///
+    /// 1 — a `do...end` block binding to the outer method while an enumerable
+    /// call sits in the arguments (stock `on_block`, 1.89, rubocop#14835).
+    /// `[start, end)` is the INNER call's range (the offense highlight AND
+    /// the `AllowedPatterns` match target), `param_*` is the inner call's
+    /// method NAME range, `inner_send_*` is the OUTER call's method NAME
+    /// range, and the `ac_*` fields are zero (stock has no autocorrect).
+    pub kind: u8,
     /// Start byte of the OUTER call's source range (offense highlight).
     pub start_offset: usize,
     /// End byte of the OUTER call's source range.
@@ -299,6 +309,7 @@ impl<'s> AmbiguousBlockAssociationVisitor<'s> {
             inner_send_loc.expect("inner_send_loc set for the CallNode arm");
 
         self.offenses.push(AmbiguousBlockAssociationOffense {
+            kind: 0,
             start_offset: outer_loc.start_offset(),
             end_offset: outer_loc.end_offset(),
             param_start: last_loc.start_offset(),
@@ -310,6 +321,166 @@ impl<'s> AmbiguousBlockAssociationVisitor<'s> {
             ac_close_pos: last_loc.end_offset(),
         });
     }
+
+    /// Stock `on_block` (1.89, rubocop#14835): a `do...end` block that binds
+    /// to the outer method while the arguments end with an enumerable call
+    /// that was likely meant to receive it.
+    ///
+    /// ```ruby
+    /// def on_block(node)
+    ///   return if node.braces?
+    ///   send_node = node.send_node
+    ///   block_method_arg = find_ambiguous_block_method(node)
+    ///   return unless block_method_arg
+    ///   add_offense(block_method_arg, message: format(MSG_DO_END_BLOCK, …))
+    /// end
+    /// ```
+    ///
+    /// `find_ambiguous_block_method` requires `send_node.send_type?` (a
+    /// csend outer is excluded), arguments, and no parentheses; the candidate
+    /// search (`find_block_method_arg`) walks the last argument's subtree for
+    /// a `:call` whose source ends where the outer send's source ends
+    /// (parser's outer send excludes the block, so that end is the last
+    /// argument's end), whose name is one of `BLOCK_METHODS`, and which has
+    /// no arguments (parser counts a block-pass as an argument). A prism
+    /// CallNode carrying a literal BlockNode is a parser `:block`, not a
+    /// `:call` — never a match, but its children are still searched.
+    fn check_do_end(&mut self, call: &ruby_prism::CallNode<'_>) {
+        let Some(block) = call.block() else { return };
+        let Some(block_node) = block.as_block_node() else {
+            return;
+        };
+        // `node.braces?` — only `do...end` blocks are ambiguous this way.
+        if block_node.opening_loc().as_slice() != b"do" {
+            return;
+        }
+        // `send_node.send_type?` — parser csend is a different type.
+        if call
+            .call_operator_loc()
+            .is_some_and(|l| l.as_slice() == b"&.")
+        {
+            return;
+        }
+        let Some(args_node) = call.arguments() else { return };
+        let arg_vec: Vec<_> = args_node.arguments().iter().collect();
+        let Some(last_arg) = arg_vec.last() else { return };
+        // `send_node.parenthesized?`
+        if call.opening_loc().is_some() {
+            return;
+        }
+        let target_end = last_arg.location().end_offset();
+        let mut finder = FindBlockMethodArg {
+            target_end,
+            result: None,
+        };
+        finder.visit(last_arg);
+        let Some((start, end, name_start, name_end)) = finder.result else {
+            return;
+        };
+        // `allowed_method?(block_method_arg.method_name)`
+        if self
+            .allowed_methods
+            .iter()
+            .any(|n| n.as_slice() == &self.source[name_start..name_end])
+        {
+            return;
+        }
+        // `matches_allowed_pattern?(block_method_arg.source)` — pre-applied
+        // by the wrapper, keyed by the inner call's source bytes.
+        if self
+            .allowed_inner_sources
+            .iter()
+            .any(|s| s.as_slice() == &self.source[start..end])
+        {
+            return;
+        }
+        let Some(outer_msg) = call.message_loc() else { return };
+        self.offenses.push(AmbiguousBlockAssociationOffense {
+            kind: 1,
+            start_offset: start,
+            end_offset: end,
+            param_start: name_start,
+            param_end: name_end,
+            inner_send_start: outer_msg.start_offset(),
+            inner_send_end: outer_msg.end_offset(),
+            ac_open_start: 0,
+            ac_open_end: 0,
+            ac_close_pos: 0,
+        });
+    }
+}
+
+/// Stock `BLOCK_METHODS`: the enumerable methods a stray `do` block was
+/// probably meant for.
+fn is_block_method(name: &[u8]) -> bool {
+    matches!(
+        name,
+        b"map"
+            | b"collect"
+            | b"flat_map"
+            | b"collect_concat"
+            | b"select"
+            | b"filter"
+            | b"find_all"
+            | b"reject"
+            | b"find"
+            | b"detect"
+            | b"each"
+            | b"each_with_object"
+            | b"each_with_index"
+            | b"reduce"
+            | b"inject"
+            | b"sort_by"
+            | b"min_by"
+            | b"max_by"
+            | b"group_by"
+            | b"filter_map"
+    )
+}
+
+/// `send_node.last_argument.each_node(:call).find { … }`: the first call in
+/// the last argument's subtree whose source ends where the outer send's
+/// source ends, named like an enumerable, and taking no arguments.
+struct FindBlockMethodArg {
+    target_end: usize,
+    /// `(start, end, name_start, name_end)` of the found inner call.
+    result: Option<(usize, usize, usize, usize)>,
+}
+
+impl<'pr> Visit<'pr> for FindBlockMethodArg {
+    fn visit_call_node(&mut self, node: &ruby_prism::CallNode<'pr>) {
+        if self.result.is_some() {
+            return;
+        }
+        // A call with a literal block is a parser `:block`, not a `:call` —
+        // skip it as a match but keep searching its children.
+        let literal_block = node
+            .block()
+            .is_some_and(|b| b.as_block_node().is_some());
+        // Parser counts a block-pass (`&blk`) as an argument.
+        let has_args = node
+            .arguments()
+            .is_some_and(|a| a.arguments().iter().count() > 0)
+            || node
+                .block()
+                .is_some_and(|b| b.as_block_argument_node().is_some());
+        if !literal_block
+            && !has_args
+            && node.location().end_offset() == self.target_end
+            && is_block_method(node.name().as_slice())
+            && let Some(msg) = node.message_loc()
+        {
+            let loc = node.location();
+            self.result = Some((
+                loc.start_offset(),
+                loc.end_offset(),
+                msg.start_offset(),
+                msg.end_offset(),
+            ));
+            return;
+        }
+        ruby_prism::visit_call_node(self, node);
+    }
 }
 
 /// rubocop-ast `OPERATOR_METHODS`. Identical to the table in
@@ -350,6 +521,7 @@ fn is_operator_method(name: &[u8]) -> bool {
 impl<'pr, 's> Visit<'pr> for AmbiguousBlockAssociationVisitor<'s> {
     fn visit_call_node(&mut self, node: &ruby_prism::CallNode<'pr>) {
         self.check_call(node);
+        self.check_do_end(node);
         ruby_prism::visit_call_node(self, node);
     }
 }
@@ -361,10 +533,11 @@ impl<'s> super::dispatch::Rule for AmbiguousBlockAssociationVisitor<'s> {
             Interest::ENTER_CALL,
         )
     }
-    
+
     fn enter(&mut self, node: &Node<'_>) {
         if let Some(call) = node.as_call_node() {
             self.check_call(&call);
+            self.check_do_end(&call);
         }
     }
 
@@ -409,6 +582,47 @@ mod tests {
         assert_eq!(off.len(), 1);
     }
 
+    #[test]
+    fn do_end_binding_to_outer_method() {
+        // 1.89 (rubocop#14835): `render json: data.map do ... end` — Ruby
+        // binds the `do` block to `render`, so `map` is called without a
+        // block. Offense on the inner call, no autocorrect.
+        let off = detect("render json: data.map do |x|\n  x\nend\n");
+        assert_eq!(off.len(), 1);
+        let o = &off[0];
+        assert_eq!(o.kind, 1);
+        assert_eq!((o.start_offset, o.end_offset), (13, 21)); // `data.map`
+        assert_eq!((o.param_start, o.param_end), (18, 21)); // `map`
+        assert_eq!((o.inner_send_start, o.inner_send_end), (0, 6)); // `render`
+        assert_eq!(o.ac_open_end, 0); // not correctable
+
+        // positional argument and safe navigation on the inner call
+        assert_eq!(detect("foo bar.select do |x|\n  x\nend\n").len(), 1);
+        assert_eq!(detect("foo bar&.each do |x|\n  x\nend\n").len(), 1);
+    }
+
+    #[test]
+    fn do_end_binding_not_flagged_when_unambiguous() {
+        // braces bind to the inner call; parentheses fix the binding
+        assert!(detect("render json: data.map { |x| x }\n").is_empty());
+        assert!(detect("render(json: data.map) do |x|\n  x\nend\n").is_empty());
+        // a call chained past the enumerable was never a block candidate
+        assert!(detect("foo bar.map.to_a do |x|\n  x\nend\n").is_empty());
+        // an inner call that already has arguments or a block-pass
+        assert!(detect("foo bar.reduce(0) do |a, b|\n  a\nend\n").is_empty());
+        assert!(detect("foo bar.map(&:to_s) do |x|\n  x\nend\n").is_empty());
+        // a method outside the enumerable list
+        assert!(detect("foo bar.frobnicate do |x|\n  x\nend\n").is_empty());
+        // safe navigation on the outer call is not `send_type?`
+        assert!(detect("foo&.bar baz.map do |x|\n  x\nend\n").is_empty());
+    }
+
+    #[test]
+    fn do_end_binding_respects_allowed_methods() {
+        let off = detect_with_allowed("foo bar.map do |x|\n  x\nend\n", &["map"]);
+        assert!(off.is_empty());
+    }
+
     #[test]
     fn flags_rspec_change_default() {
         let off = detect("expect { order.expire }.to change { order.events }\n");

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

@@ -230,6 +230,7 @@ pub fn check_multiline_bundle(
 /// | 25  | arguments_forwarding RedundantRestArgumentNames |
 /// | 26  | arguments_forwarding RedundantKeywordRestArgumentNames |
 /// | 27  | arguments_forwarding RedundantBlockArgumentNames |
+/// | 28  | duplicate_methods_delegating (`Lint/DuplicateMethods` `DelegatingMethods`, 1.89) |
 ///
 /// Performance segment `nums[1]` (the shirobai-performance plugin origin):
 ///
@@ -485,7 +486,7 @@ pub const ORIGIN_RAILS: usize = 3;
 pub const N_ORIGINS: usize = 4;
 
 const CORE_NUMS_LEN: usize = 134;
-const CORE_LISTS_LEN: usize = 28;
+const CORE_LISTS_LEN: usize = 29;
 const PERF_NUMS_LEN: usize = 3;
 const PERF_LISTS_LEN: usize = 1;
 
@@ -546,7 +547,7 @@ impl BundleConfig {
         }
         let mut lists = core_lists.into_iter();
         let mut next_list = || lists.next().expect("length checked above");
-        Ok(BundleConfig {
+        let mut bundle = BundleConfig {
             debugger_methods: next_list(),
             debugger_requires: next_list(),
             block_length_max: nums[0] as usize,
@@ -802,6 +803,9 @@ impl BundleConfig {
             },
             duplicate_methods: duplicate_methods::Config {
                 active_support_extensions_enabled: nums[111] != 0,
+                // Filled after the literal: list 28 sits at the end of the
+                // packing order, after the arguments_forwarding lists.
+                delegating_methods: Vec::new(),
             },
             redundant_freeze_target_30_plus: nums[114] != 0,
             redundant_freeze_string_literals_frozen_by_default: nums[115] != 0,
@@ -856,7 +860,9 @@ impl BundleConfig {
             // The shirobai-rails origin, read from its own segment (nums and
             // list lengths are checked there).
             rails: rails_config::RailsConfig::from_segment(rails_nums, &rails_lists)?,
-        })
+        };
+        bundle.duplicate_methods.delegating_methods = next_list();
+        Ok(bundle)
     }
 }
 
@@ -2021,6 +2027,7 @@ mod tests {
             ["args", "arguments"].map(String::from).to_vec(), // af: RedundantRestArgumentNames
             ["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
         ];
         // Performance segment (origin 1): enabled, with the SafeMultiline
         // defaults and RuboCop's default preferred method for Detect