shirobai 2026.0620.0600 → 2026.0620.2000

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0cc3b10f1ce2bb8d770cc56e43ed3deccea614daf0c487d0eb7cf37783715c1
-  data.tar.gz: f8bd98cccca3c2a8e9505b0f6b74af94b19dbab1e4079f9c8c39c2db93b193c0
+  metadata.gz: 2da350f27fcd3ff47681028d0508eade78a0ced26a5b96007985da947ab8a292
+  data.tar.gz: 680562385119492ea485da4929b883bba60ff15129f6fd9a2e70d230245aaff4
 SHA512:
-  metadata.gz: 00ab1d29d7c85d1f155784a5138c5b7f5828360e4df62268b8106e166f4cce43491d09e8ac49e30de5b6e8f63dbec2cd664382e433dd5e5b29424e5734db6ce6
-  data.tar.gz: b5d947fc4f44f9bc600966f12fa98218dcb2f3527b6711f677a1ca44a0e870593597931fb6db204ffd98cf2ed02b10b48ac0a3ce758e47ed4d742bb1fe7e0169
+  metadata.gz: 06e8d2e281b447c0ca65762f86616575b8e4b2a9af55f135b28027479a5ddc3b95d3cf6e6e74ce0970863d4f16776e66b77a6c901e6168e3828f8eae6b5b9ade
+  data.tar.gz: a8b07df2f070dabb4c12c9f91bc88dc31483b668559e51df92d3a146deec8b2e85687d2d547f557c46f9796d9cc995512c6f6a992cdff79349bb6c7407fe5b97

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

@@ -174,12 +174,14 @@ impl<'a> Visitor<'a> {
         String::from_utf8_lossy(&slice[..e]).into_owned()
     }
 
-    /// `match = /\S.*/.match(do_loc.source_line)`: the do/`{` line's content
-    /// from its first non-space char, and that column. Returns `(source, line,
-    /// column)`.
-    fn do_source_line(&self, do_start: usize) -> (String, usize, usize) {
-        let line = self.line_of(do_start);
-        let ls = self.line_index.line_start(do_start);
+    /// `match = /\S.*/.match(anchor_loc.source_line)`: returns `(source, line,
+    /// column)` from the anchor line's first non-space char. The anchor is
+    /// normally the `do`/`{` line, but shifts to the method dispatch line
+    /// when the `do` line is a continuation of multiline arguments.
+    fn do_source_line(&self, do_start: usize, anchor_start: Option<usize>) -> (String, usize, usize) {
+        let ref_offset = anchor_start.unwrap_or(do_start);
+        let line = self.line_of(ref_offset);
+        let ls = self.line_index.line_start(ref_offset);
         let starts = self.line_index.line_starts();
         let le = if line < starts.len() {
             let mut e = starts[line] - 1;
@@ -193,12 +195,26 @@ impl<'a> Visitor<'a> {
         let first_non_space = (ls..le)
             .find(|&i| !is_space_byte(self.source[i]))
             .unwrap_or(ls);
-        // column == number of chars from line start to first non-space.
         let column = self.column(first_non_space);
-        // `match[0]` is `\S.*` — from the first non-space to end of line.
         let text = String::from_utf8_lossy(&self.source[first_non_space..le]).into_owned();
         (text, line, column)
     }
+
+    /// The indentation of the original `do`/`{` line (not the anchor).
+    fn do_line_indentation(&self, do_start: usize) -> usize {
+        let ls = self.line_index.line_start(do_start);
+        let starts = self.line_index.line_starts();
+        let line = self.line_of(do_start);
+        let le = if line < starts.len() {
+            starts[line] - 1
+        } else {
+            self.source.len()
+        };
+        let first_non_space = (ls..le)
+            .find(|&i| !is_space_byte(self.source[i]))
+            .unwrap_or(ls);
+        self.column(first_non_space)
+    }
 }
 
 fn is_space_byte(b: u8) -> bool {
@@ -226,6 +242,9 @@ struct BlockLoc {
     open_start: usize,
     close_start: usize,
     close_end: usize,
+    /// When the `do`/`{` line starts inside a multiline method argument,
+    /// anchor on the method dispatch line instead of the do line.
+    anchor_start: Option<usize>,
 }
 
 impl<'a> Visitor<'a> {
@@ -233,20 +252,37 @@ impl<'a> Visitor<'a> {
         // call / super / forwarding-super with a literal BlockNode.
         if let Some(call) = node.as_call_node() {
             if let Some(bn) = call.block().and_then(|b| b.as_block_node()) {
-                return self.block_node_loc(&bn);
+                let mut arg_ranges: Vec<(usize, usize)> = Vec::new();
+                if let Some(args) = call.arguments() {
+                    for arg in args.arguments().iter() {
+                        arg_ranges.push(loc(&arg.location()));
+                    }
+                }
+                let selector = call
+                    .message_loc()
+                    .map(|l| l.start_offset())
+                    .unwrap_or(call.location().start_offset());
+                return self.block_node_loc_with_anchor(&bn, &arg_ranges, selector);
             }
             return None;
         }
         if let Some(sup) = node.as_super_node() {
             if let Some(bn) = sup.block().and_then(|b| b.as_block_node()) {
-                return self.block_node_loc(&bn);
+                let mut arg_ranges: Vec<(usize, usize)> = Vec::new();
+                if let Some(args) = sup.arguments() {
+                    for arg in args.arguments().iter() {
+                        arg_ranges.push(loc(&arg.location()));
+                    }
+                }
+                let selector = sup.keyword_loc().start_offset();
+                return self.block_node_loc_with_anchor(&bn, &arg_ranges, selector);
             }
             return None;
         }
         if let Some(fsup) = node.as_forwarding_super_node() {
-            // `ForwardingSuperNode::block()` returns the `BlockNode` directly.
             if let Some(bn) = fsup.block() {
-                return self.block_node_loc(&bn);
+                let selector = node.location().start_offset();
+                return self.block_node_loc_with_anchor(&bn, &[], selector);
             }
             return None;
         }
@@ -254,24 +290,72 @@ impl<'a> Visitor<'a> {
         if let Some(lam) = node.as_lambda_node() {
             let (open_start, _) = loc(&lam.opening_loc());
             let (close_start, close_end) = loc(&lam.closing_loc());
+            // Lambda parameters are the "arguments" for the anchor check.
+            let mut arg_ranges: Vec<(usize, usize)> = Vec::new();
+            if let Some(params) = lam.parameters() {
+                let ploc = params.location();
+                arg_ranges.push(loc(&ploc));
+            }
+            let selector = lam.operator_loc().start_offset();
+            let anchor_start = self.do_line_anchor(open_start, &arg_ranges, &[], selector);
             return Some(BlockLoc {
                 open_start,
                 close_start,
                 close_end,
+                anchor_start,
             });
         }
         None
     }
 
-    fn block_node_loc(&self, bn: &ruby_prism::BlockNode<'_>) -> Option<BlockLoc> {
+    fn block_node_loc_with_anchor(
+        &self,
+        bn: &ruby_prism::BlockNode<'_>,
+        send_arg_ranges: &[(usize, usize)],
+        selector_start: usize,
+    ) -> Option<BlockLoc> {
         let (open_start, _) = loc(&bn.opening_loc());
         let (close_start, close_end) = loc(&bn.closing_loc());
+        let mut block_param_ranges: Vec<(usize, usize)> = Vec::new();
+        if let Some(params) = bn.parameters() {
+            let ploc = params.location();
+            block_param_ranges.push(loc(&ploc));
+        }
+        let anchor_start = self.do_line_anchor(open_start, send_arg_ranges, &block_param_ranges, selector_start);
         Some(BlockLoc {
             open_start,
             close_start,
             close_end,
+            anchor_start,
         })
     }
+
+    /// When the `do`/`{` line begins inside one of the call's arguments or the
+    /// block's parameters, return the method selector start offset as the
+    /// alignment anchor.
+    fn do_line_anchor(
+        &self,
+        open_start: usize,
+        send_arg_ranges: &[(usize, usize)],
+        block_param_ranges: &[(usize, usize)],
+        selector_start: usize,
+    ) -> Option<usize> {
+        let ls = self.line_index.line_start(open_start);
+        let first_char_pos = (ls..open_start)
+            .find(|&i| !is_space_byte(self.source[i]))
+            .unwrap_or(open_start);
+
+        let inside = send_arg_ranges
+            .iter()
+            .chain(block_param_ranges.iter())
+            .any(|&(s, e)| s <= first_char_pos && first_char_pos < e);
+
+        if inside {
+            Some(selector_start)
+        } else {
+            None
+        }
+    }
 }
 
 // --- Lineage / alignment-target selection. ---
@@ -429,6 +513,11 @@ impl<'a> Visitor<'a> {
     fn on_block(&mut self, block_range: (usize, usize), bl: &BlockLoc) {
         let block_first_line = self.first_line_of(block_range.0);
         let start = self.start_for_block_node(block_range, block_first_line);
+        let start = if self.style == STYLE_START_OF_LINE {
+            self.start_for_line_node(start)
+        } else {
+            start
+        };
         self.check_block_alignment(start, block_range, bl);
     }
 
@@ -447,9 +536,15 @@ impl<'a> Visitor<'a> {
         if start_col == end_col && self.style != STYLE_START_OF_BLOCK {
             return;
         }
-        // compute_do_source_line_column.
-        let (do_text, do_line, do_col) = self.do_source_line(bl.open_start);
-        if end_col == do_col && self.style != STYLE_START_OF_LINE {
+        // compute_do_source_line_column (using anchor if available).
+        let (do_text, do_line, do_col) = self.do_source_line(bl.open_start, bl.anchor_start);
+        // permitted_do_line_columns: under `either`, both the anchor line's
+        // indentation and the original do line's indentation are accepted.
+        let mut permitted = vec![do_col];
+        if self.style == STYLE_EITHER && bl.anchor_start.is_some() {
+            permitted.push(self.do_line_indentation(bl.open_start));
+        }
+        if permitted.contains(&end_col) && self.style != STYLE_START_OF_LINE {
             return;
         }
         self.register_offense(start, block_range, bl, (do_text, do_line, do_col));

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

@@ -24,7 +24,7 @@
 //! `move_comment_before_block` and the `begin`/`end` wrapping of multiline
 //! rescue/ensure bodies.
 
-use ruby_prism::{CallNode, Node, StatementsNode, Visit};
+use ruby_prism::{CallNode, Node, StatementsNode};
 
 type Range = (usize, usize);
 
@@ -328,7 +328,7 @@ impl<'a> Visitor<'a> {
         opening: Range,
         closing: Range,
         method_name: &str,
-        node: &Node<'_>,
+        _node: &Node<'_>,
         body: Option<&Node<'_>>,
         send_arguments: bool,
         send_parenthesized: bool,
@@ -336,7 +336,7 @@ impl<'a> Visitor<'a> {
         let braces = self.source[opening.0] == b'{';
         // `BlockNode#multiline?` compares the delimiter lines.
         let multiline = self.source[opening.0..closing.0].contains(&b'\n');
-        if self.proper_block_style(braces, multiline, block_range, method_name, node) {
+        if self.proper_block_style(braces, multiline, block_range, method_name, body) {
             return;
         }
         let message = self.message(braces, multiline, block_range, method_name);
@@ -366,9 +366,9 @@ impl<'a> Visitor<'a> {
         multiline: bool,
         block_range: Range,
         method_name: &str,
-        node: &Node<'_>,
+        body: Option<&Node<'_>>,
     ) -> bool {
-        if self.require_do_end(braces, multiline, node) {
+        if self.require_do_end(braces, multiline, body) {
             return true;
         }
         if self.list_in(method_name, &self.cfg.allowed_methods) {
@@ -391,15 +391,42 @@ impl<'a> Visitor<'a> {
         }
     }
 
-    /// `require_do_end?`: a single-line `do`..`end` whose first descendant
-    /// `resbody` carries an exception class list cannot use braces.
-    fn require_do_end(&self, braces: bool, multiline: bool, node: &Node<'_>) -> bool {
+    /// `require_do_end?`: a single-line `do`..`end` block cannot use braces
+    /// when it contains `ensure` or a block-level `rescue` (as opposed to a
+    /// bare modifier rescue `expr rescue expr`).
+    fn require_do_end(&self, braces: bool, multiline: bool, body: Option<&Node<'_>>) -> bool {
         if braces || multiline {
             return false;
         }
-        let mut finder = ResbodyFinder { found: None };
-        finder.visit_children_of(node);
-        finder.found.unwrap_or(false)
+        let Some(body) = body else { return false };
+        // Prism wraps block-level rescue/ensure in a BeginNode (implicit
+        // begin). Modifier rescue stays as a RescueModifierNode inside a
+        // StatementsNode.
+        if let Some(begin) = body.as_begin_node() {
+            if begin.ensure_clause().is_some() {
+                return true;
+            }
+            if let Some(rescue) = begin.rescue_clause() {
+                let has_protected_body = begin.statements().is_some();
+                return !is_modifier_rescue(&rescue, has_protected_body);
+            }
+        }
+        // Walk into StatementsNode: the body of a block is often a
+        // StatementsNode wrapping the actual content.
+        if let Some(stmts) = body.as_statements_node() {
+            for stmt in stmts.body().iter() {
+                if let Some(begin) = stmt.as_begin_node() {
+                    if begin.ensure_clause().is_some() {
+                        return true;
+                    }
+                    if let Some(rescue) = begin.rescue_clause() {
+                        let has_protected_body = begin.statements().is_some();
+                        return !is_modifier_rescue(&rescue, has_protected_body);
+                    }
+                }
+            }
+        }
+        false
     }
 
     fn semantic_block_style(
@@ -1178,44 +1205,39 @@ fn parser_body_range(begin: &ruby_prism::BeginNode<'_>) -> Range {
     (start, end)
 }
 
-/// `each_descendant(:resbody).first`, then `children.first&.array_type?`:
-/// finds the first rescue clause (or rescue modifier) in parser preorder and
-/// reports whether it carries an exception class list.
-struct ResbodyFinder {
-    found: Option<bool>,
-}
-
-impl ResbodyFinder {
-    /// Visit the children of the block wrapper without treating the wrapper
-    /// itself as a result.
-    fn visit_children_of(&mut self, node: &Node<'_>) {
-        if let Some(call) = node.as_call_node() {
-            ruby_prism::visit_call_node(self, &call);
-        } else if let Some(sup) = node.as_super_node() {
-            ruby_prism::visit_super_node(self, &sup);
-        } else if let Some(fsup) = node.as_forwarding_super_node() {
-            ruby_prism::visit_forwarding_super_node(self, &fsup);
-        } else if let Some(lambda) = node.as_lambda_node() {
-            ruby_prism::visit_lambda_node(self, &lambda);
-        }
+/// A bare modifier rescue: `expr rescue expr` — single branch, no
+/// exceptions list, no exception variable, no else. This form CAN be
+/// written with braces, unlike a block-level rescue.
+///
+/// In Prism, block-level rescue creates a `BeginNode` containing a
+/// `RescueNode` chain. The `RescueNode` here is the first (and possibly
+/// only) rescue clause. Stock checks on the parser-gem `:rescue` wrapper:
+///   - `body.nil?` → no protected expression before the rescue keyword
+///   - `else_branch` → has an else
+///   - `resbody_branches.one?` → exactly one rescue clause
+///   - `resbody.exceptions.empty?` → no exception class list
+///   - `resbody.exception_variable.nil?` → no `=> e`
+///
+/// A block-level `rescue` (even bare) always has the protected body at the
+/// `BeginNode` level (in `begin.statements()`), and the `RescueNode` itself
+/// has no `statements()` (only `exceptions`, `exception`, and `subsequent`).
+/// So a modifier rescue in this context is one with no exceptions, no
+/// exception variable, and no subsequent clause.
+fn is_modifier_rescue(rescue: &ruby_prism::RescueNode<'_>, has_protected_body: bool) -> bool {
+    if !has_protected_body {
+        return false;
     }
-}
-
-impl<'pr> Visit<'pr> for ResbodyFinder {
-    fn visit_rescue_node(&mut self, node: &ruby_prism::RescueNode<'pr>) {
-        if self.found.is_none() {
-            self.found = Some(node.exceptions().iter().next().is_some());
-        }
+    if rescue.subsequent().is_some() {
+        return false;
     }
-
-    fn visit_rescue_modifier_node(&mut self, node: &ruby_prism::RescueModifierNode<'pr>) {
-        // Parser order: the rescued expression subtree precedes the
-        // modifier's own (class-less) resbody.
-        self.visit(&node.expression());
-        if self.found.is_none() {
-            self.found = Some(false);
-        }
+    let exceptions: Vec<_> = rescue.exceptions().iter().collect();
+    if !exceptions.is_empty() {
+        return false;
+    }
+    if rescue.reference().is_some() {
+        return false;
     }
+    true
 }
 
 impl super::dispatch::Rule for Visitor<'_> {

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

@@ -11,14 +11,11 @@
 //!   That's the `Tip::Top(arg)` constructor-style call which looks like a
 //!   constant reference at the call site (`Top(...)` would be `Integer(x)` /
 //!   `String(x)`).
-//! - Skip when `java_type_node?(node)` — stock pattern
-//!   `(send (const nil? :Java) _)`: the receiver is a top-level
-//!   `ConstantReadNode` named `Java`. The pattern's `nil?` matches a nil
-//!   receiver on the `const`, NOT a `cbase` receiver (`::Java::int` is FLAGGED
-//!   by stock; verified by probe). So in prism the gate is
-//!   `receiver.as_constant_read_node()` whose `name() == "Java"`. A
-//!   `ConstantPathNode` (`::Java`) is a different prism node and structurally
-//!   excluded.
+//! - Skip when `java_interop?(node)` — walks the receiver chain to its root
+//!   and checks `java_root?` (= `(const nil? :Java)`). This excludes not just
+//!   `Java::int` but the entire chain `Java::com::something_method`.
+//!   The `cbase` form `::Java::int` is still FLAGGED because the root is a
+//!   `ConstantPathNode`, not a bare `ConstantReadNode`.
 //!
 //! Offense range = `node.loc.dot` = the prism `call_operator_loc()` range
 //! (`::`, two bytes). Autocorrect replaces those two bytes with `.`.
@@ -103,15 +100,11 @@ impl ColonMethodCallVisitor {
             return;
         }
 
-        // `java_type_node?(node)` — stock pattern `(send (const nil? :Java) _)`.
-        // The receiver is a top-level `ConstantReadNode` whose name is `Java`.
-        // `ConstantPathNode` (the `cbase` form `::Java`) is a different node
-        // kind and is correctly NOT excluded — `::Java::int` is flagged by
-        // stock.
-        let receiver = call.receiver().expect("receiver presence checked above");
-        if let Some(const_read) = receiver.as_constant_read_node()
-            && const_read.name().as_slice() == b"Java"
-        {
+        // `java_interop?(node)` — walk the receiver chain to its root and
+        // check `java_root?` (= `(const nil? :Java)`). This excludes the
+        // entire `Java::com::something_method` chain, not just the first
+        // `Java::com` call.
+        if Self::java_interop(call) {
             return;
         }
 
@@ -120,6 +113,23 @@ impl ColonMethodCallVisitor {
             dot_end: op_end,
         });
     }
+
+    fn java_interop(call: &ruby_prism::CallNode<'_>) -> bool {
+        let mut node = call.receiver().expect("receiver presence checked by caller");
+        loop {
+            if let Some(const_read) = node.as_constant_read_node() {
+                return const_read.name().as_slice() == b"Java";
+            }
+            if let Some(inner_call) = node.as_call_node() {
+                match inner_call.receiver() {
+                    Some(r) => node = r,
+                    None => return false,
+                }
+            } else {
+                return false;
+            }
+        }
+    }
 }
 
 impl<'pr> Visit<'pr> for ColonMethodCallVisitor {
@@ -235,12 +245,9 @@ mod tests {
     }
 
     #[test]
-    fn flags_after_java_then_user_call() {
-        // `Java::foo::bar` — inner `Java::foo` is java-typed (excluded), but
-        // outer `bar` (receiver = `Java::foo` CallNode) is flagged. `::` at
-        // 9..11.
-        let off = detect("Java::foo::bar\n");
-        assert_eq!(off, vec![(9, 11)]);
+    fn accepts_java_interop_chain() {
+        // `Java::foo::bar` — root receiver is `Java`, entire chain excluded.
+        assert!(detect("Java::foo::bar\n").is_empty());
     }
 
     #[test]

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

@@ -85,6 +85,22 @@ impl<'a> Visitor<'a> {
         node.as_call_node().is_some_and(|c| c.is_safe_navigation())
     }
 
+    fn is_csend_or_parenthesized_csend(node: &Node<'_>) -> bool {
+        if Self::is_csend(node) {
+            return true;
+        }
+        if let Some(paren) = node.as_parentheses_node()
+            && let Some(body) = paren.body()
+            && let Some(stmts) = body.as_statements_node()
+        {
+            let children: Vec<_> = stmts.body().iter().collect();
+            if children.len() == 1 {
+                return Self::is_csend(&children[0]);
+            }
+        }
+        false
+    }
+
     fn is_comparison(call: &CallNode<'_>) -> bool {
         COMPARISON_OPERATORS.contains(&call.name().as_slice())
     }
@@ -220,7 +236,7 @@ impl<'a> Visitor<'a> {
         let Some(receiver) = call.receiver() else {
             return;
         };
-        if !Self::is_csend(&receiver) {
+        if !Self::is_csend_or_parenthesized_csend(&receiver) {
             return;
         }
         let method = call.name().as_slice();

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

@@ -14,8 +14,12 @@
 //! path zero-cost on the Ruby side. See `lib/shirobai/cop/lint/self_assignment.rb`.
 
 use ruby_prism::{
-    CallNode, ClassVariableWriteNode, ConstantPathNode, ConstantPathWriteNode, ConstantWriteNode,
-    GlobalVariableWriteNode, InstanceVariableWriteNode, LocalVariableAndWriteNode,
+    CallAndWriteNode, CallNode, CallOrWriteNode, ClassVariableAndWriteNode,
+    ClassVariableOrWriteNode, ClassVariableWriteNode, ConstantAndWriteNode,
+    ConstantOrWriteNode, ConstantPathNode, ConstantPathWriteNode, ConstantWriteNode,
+    GlobalVariableAndWriteNode, GlobalVariableOrWriteNode, GlobalVariableWriteNode,
+    IndexAndWriteNode, IndexOrWriteNode, InstanceVariableAndWriteNode,
+    InstanceVariableOrWriteNode, InstanceVariableWriteNode, LocalVariableAndWriteNode,
     LocalVariableOrWriteNode, LocalVariableWriteNode, MultiWriteNode, Node, Visit,
 };
 
@@ -214,6 +218,177 @@ impl<'s> SelfAssignmentVisitor<'s> {
         self.push(loc.start_offset(), loc.end_offset(), anchor);
     }
 
+    fn check_ivar_or_asgn(&mut self, node: &InstanceVariableOrWriteNode<'_>) {
+        let value = node.value();
+        let Some(rhs) = value.as_instance_variable_read_node() else { return };
+        if rhs.name().as_slice() != node.name().as_slice() {
+            return;
+        }
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.push(loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_ivar_and_asgn(&mut self, node: &InstanceVariableAndWriteNode<'_>) {
+        let value = node.value();
+        let Some(rhs) = value.as_instance_variable_read_node() else { return };
+        if rhs.name().as_slice() != node.name().as_slice() {
+            return;
+        }
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.push(loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_cvar_or_asgn(&mut self, node: &ClassVariableOrWriteNode<'_>) {
+        let value = node.value();
+        let Some(rhs) = value.as_class_variable_read_node() else { return };
+        if rhs.name().as_slice() != node.name().as_slice() {
+            return;
+        }
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.push(loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_cvar_and_asgn(&mut self, node: &ClassVariableAndWriteNode<'_>) {
+        let value = node.value();
+        let Some(rhs) = value.as_class_variable_read_node() else { return };
+        if rhs.name().as_slice() != node.name().as_slice() {
+            return;
+        }
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.push(loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_gvar_or_asgn(&mut self, node: &GlobalVariableOrWriteNode<'_>) {
+        let value = node.value();
+        let Some(rhs) = value.as_global_variable_read_node() else { return };
+        if rhs.name().as_slice() != node.name().as_slice() {
+            return;
+        }
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.push(loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_gvar_and_asgn(&mut self, node: &GlobalVariableAndWriteNode<'_>) {
+        let value = node.value();
+        let Some(rhs) = value.as_global_variable_read_node() else { return };
+        if rhs.name().as_slice() != node.name().as_slice() {
+            return;
+        }
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.push(loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_const_or_and_asgn(&mut self, name: &[u8], value: &Node<'_>, loc_start: usize, loc_end: usize, anchor: usize) {
+        let (rhs_ns, rhs_short) = match resolve_const_rhs(value) {
+            Some(p) => p,
+            None => return,
+        };
+        if name != rhs_short {
+            return;
+        }
+        if !namespaces_equal(None, rhs_ns.as_ref()) {
+            return;
+        }
+        self.push(loc_start, loc_end, anchor);
+    }
+
+    fn check_const_or_asgn(&mut self, node: &ConstantOrWriteNode<'_>) {
+        let value = node.value();
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.check_const_or_and_asgn(node.name().as_slice(), &value, loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_const_and_asgn(&mut self, node: &ConstantAndWriteNode<'_>) {
+        let value = node.value();
+        let loc = node.location();
+        let anchor = node.name_loc().end_offset();
+        self.check_const_or_and_asgn(node.name().as_slice(), &value, loc.start_offset(), loc.end_offset(), anchor);
+    }
+
+    fn check_call_or_and_asgn_common(&mut self, receiver: Option<Node<'_>>, read_name: &[u8], value: &Node<'_>, loc_start: usize, loc_end: usize) {
+        let Some(rhs_call) = value.as_call_node() else { return };
+        let rhs_args: Vec<Node<'_>> = rhs_call
+            .arguments()
+            .map(|a| a.arguments().iter().collect())
+            .unwrap_or_default();
+        if !rhs_args.is_empty() {
+            return;
+        }
+        if rhs_call.name().as_slice() != read_name {
+            return;
+        }
+        let anchor = receiver
+            .as_ref()
+            .map(|r| r.location().end_offset())
+            .unwrap_or(loc_start);
+        if !ast_equal(receiver, rhs_call.receiver(), self.source) {
+            return;
+        }
+        self.push(loc_start, loc_end, anchor);
+    }
+
+    fn check_call_or_asgn(&mut self, node: &CallOrWriteNode<'_>) {
+        let loc = node.location();
+        self.check_call_or_and_asgn_common(node.receiver(), node.read_name().as_slice(), &node.value(), loc.start_offset(), loc.end_offset());
+    }
+
+    fn check_call_and_asgn(&mut self, node: &CallAndWriteNode<'_>) {
+        let loc = node.location();
+        self.check_call_or_and_asgn_common(node.receiver(), node.read_name().as_slice(), &node.value(), loc.start_offset(), loc.end_offset());
+    }
+
+    fn check_index_or_and_asgn_common(&mut self, receiver: Option<Node<'_>>, arguments: Option<ruby_prism::ArgumentsNode<'_>>, value: &Node<'_>, loc_start: usize, loc_end: usize) {
+        let Some(rhs_call) = value.as_call_node() else { return };
+        if rhs_call.name().as_slice() != b"[]" {
+            return;
+        }
+        let anchor = receiver
+            .as_ref()
+            .map(|r| r.location().end_offset())
+            .unwrap_or(loc_start);
+        if !ast_equal(receiver, rhs_call.receiver(), self.source) {
+            return;
+        }
+        let lhs_args: Vec<Node<'_>> = arguments
+            .map(|a| a.arguments().iter().collect())
+            .unwrap_or_default();
+        if lhs_args.iter().any(|n| is_call_node(n)) {
+            return;
+        }
+        let rhs_args: Vec<Node<'_>> = rhs_call
+            .arguments()
+            .map(|a| a.arguments().iter().collect())
+            .unwrap_or_default();
+        if lhs_args.len() != rhs_args.len() {
+            return;
+        }
+        if !lhs_args
+            .iter()
+            .zip(&rhs_args)
+            .all(|(a, b)| ast_equal_node(a, b, self.source))
+        {
+            return;
+        }
+        self.push(loc_start, loc_end, anchor);
+    }
+
+    fn check_index_or_asgn(&mut self, node: &IndexOrWriteNode<'_>) {
+        let loc = node.location();
+        self.check_index_or_and_asgn_common(node.receiver(), node.arguments(), &node.value(), loc.start_offset(), loc.end_offset());
+    }
+
+    fn check_index_and_asgn(&mut self, node: &IndexAndWriteNode<'_>) {
+        let loc = node.location();
+        self.check_index_or_and_asgn_common(node.receiver(), node.arguments(), &node.value(), loc.start_offset(), loc.end_offset());
+    }
+
     fn check_send(&mut self, call: &CallNode<'_>) {
         // `on_send` covers `[]=` (key assignment) and `assignment_method?`
         // (attribute setters whose name ends with `=`).
@@ -484,6 +659,54 @@ impl<'pr, 's> Visit<'pr> for SelfAssignmentVisitor<'s> {
         self.check_and_asgn(node);
         ruby_prism::visit_local_variable_and_write_node(self, node);
     }
+    fn visit_instance_variable_or_write_node(&mut self, node: &InstanceVariableOrWriteNode<'pr>) {
+        self.check_ivar_or_asgn(node);
+        ruby_prism::visit_instance_variable_or_write_node(self, node);
+    }
+    fn visit_instance_variable_and_write_node(&mut self, node: &InstanceVariableAndWriteNode<'pr>) {
+        self.check_ivar_and_asgn(node);
+        ruby_prism::visit_instance_variable_and_write_node(self, node);
+    }
+    fn visit_class_variable_or_write_node(&mut self, node: &ClassVariableOrWriteNode<'pr>) {
+        self.check_cvar_or_asgn(node);
+        ruby_prism::visit_class_variable_or_write_node(self, node);
+    }
+    fn visit_class_variable_and_write_node(&mut self, node: &ClassVariableAndWriteNode<'pr>) {
+        self.check_cvar_and_asgn(node);
+        ruby_prism::visit_class_variable_and_write_node(self, node);
+    }
+    fn visit_global_variable_or_write_node(&mut self, node: &GlobalVariableOrWriteNode<'pr>) {
+        self.check_gvar_or_asgn(node);
+        ruby_prism::visit_global_variable_or_write_node(self, node);
+    }
+    fn visit_global_variable_and_write_node(&mut self, node: &GlobalVariableAndWriteNode<'pr>) {
+        self.check_gvar_and_asgn(node);
+        ruby_prism::visit_global_variable_and_write_node(self, node);
+    }
+    fn visit_constant_or_write_node(&mut self, node: &ConstantOrWriteNode<'pr>) {
+        self.check_const_or_asgn(node);
+        ruby_prism::visit_constant_or_write_node(self, node);
+    }
+    fn visit_constant_and_write_node(&mut self, node: &ConstantAndWriteNode<'pr>) {
+        self.check_const_and_asgn(node);
+        ruby_prism::visit_constant_and_write_node(self, node);
+    }
+    fn visit_call_or_write_node(&mut self, node: &CallOrWriteNode<'pr>) {
+        self.check_call_or_asgn(node);
+        ruby_prism::visit_call_or_write_node(self, node);
+    }
+    fn visit_call_and_write_node(&mut self, node: &CallAndWriteNode<'pr>) {
+        self.check_call_and_asgn(node);
+        ruby_prism::visit_call_and_write_node(self, node);
+    }
+    fn visit_index_or_write_node(&mut self, node: &IndexOrWriteNode<'pr>) {
+        self.check_index_or_asgn(node);
+        ruby_prism::visit_index_or_write_node(self, node);
+    }
+    fn visit_index_and_write_node(&mut self, node: &IndexAndWriteNode<'pr>) {
+        self.check_index_and_asgn(node);
+        ruby_prism::visit_index_and_write_node(self, node);
+    }
     fn visit_call_node(&mut self, node: &CallNode<'pr>) {
         self.check_send(node);
         ruby_prism::visit_call_node(self, node);
@@ -510,6 +733,30 @@ impl<'s> super::dispatch::Rule for SelfAssignmentVisitor<'s> {
             self.check_or_asgn(&n);
         } else if let Some(n) = node.as_local_variable_and_write_node() {
             self.check_and_asgn(&n);
+        } else if let Some(n) = node.as_instance_variable_or_write_node() {
+            self.check_ivar_or_asgn(&n);
+        } else if let Some(n) = node.as_instance_variable_and_write_node() {
+            self.check_ivar_and_asgn(&n);
+        } else if let Some(n) = node.as_class_variable_or_write_node() {
+            self.check_cvar_or_asgn(&n);
+        } else if let Some(n) = node.as_class_variable_and_write_node() {
+            self.check_cvar_and_asgn(&n);
+        } else if let Some(n) = node.as_global_variable_or_write_node() {
+            self.check_gvar_or_asgn(&n);
+        } else if let Some(n) = node.as_global_variable_and_write_node() {
+            self.check_gvar_and_asgn(&n);
+        } else if let Some(n) = node.as_constant_or_write_node() {
+            self.check_const_or_asgn(&n);
+        } else if let Some(n) = node.as_constant_and_write_node() {
+            self.check_const_and_asgn(&n);
+        } else if let Some(n) = node.as_call_or_write_node() {
+            self.check_call_or_asgn(&n);
+        } else if let Some(n) = node.as_call_and_write_node() {
+            self.check_call_and_asgn(&n);
+        } else if let Some(n) = node.as_index_or_write_node() {
+            self.check_index_or_asgn(&n);
+        } else if let Some(n) = node.as_index_and_write_node() {
+            self.check_index_and_asgn(&n);
         } else if let Some(call) = node.as_call_node() {
             self.check_send(&call);
         }

data/lib/shirobai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shirobai
-  VERSION = "2026.0620.0600"
+  VERSION = "2026.0620.2000"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shirobai
 version: !ruby/object:Gem::Version
-  version: 2026.0620.0600
+  version: 2026.0620.2000
 platform: ruby
 authors:
 - fusagiko / takayamaki
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.87.0
+        version: 1.88.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.87.0
+        version: 1.88.0
 executables: []
 extensions:
 - ext/shirobai/Cargo.toml