Fix bracket/brace map corruption from Ruby 3.0+ pattern matching deconstruction

- Rename on_aptn to on_aryptn (on_aptn is not a valid Ripper event; the real
  event for array patterns is on_aryptn)
- Add on_hshptn to clean up @Map[:lbrace]/@Map[:rbrace] after braced hash
  patterns ({key: val}); bare hash patterns (key: val) are detected by the
  absence of an entry in @Map[:rbrace]
- Override on_rbrace to push closing positions to @Map[:rbrace], mirroring
  on_rbracket/@Map[:aref]; visit_event drains @Map[:rbrace] when consuming
  a lbrace node so the maps stay in sync
- Replace tests that asserted on %i[] source range (which never went through
  the bracket maps) with tests that assert on a subsequent aref/hash node,
  which is the actual observable corrupted by the bug

Author: dduugg

CHANGELOG.md

@@ -1,13 +1,15 @@
 # main
 
+- Fix garbled source ranges after Ruby 3.0+ array/hash pattern matching deconstruction (#1547)
+
 # [0.9.39] - April 8th, 2026
 
 [0.9.39]: https://github.com/lsegal/yard/compare/v0.9.38...v0.9.39
 
 - Add support for Ruby 4.0 (#1663)
 - Add changelog URI to gemspec metadata (#1641)
 - Fix issues with source ranges (#1642)
-- Fix an issue loading relative links from file list in HTML template (#1660)
+- Fix incorrect relative link resolution in class/file/method list navigation for static HTML (#1639, #1660)
 - Various test fixes (#1650, #1651)
 
 

lib/yard/parser/ruby/ruby_parser.rb

@@ -244,6 +244,7 @@ def visit_event(node)
             sstart = child_node.source_range.first
           else
             lstart, sstart = *(map ? map.pop : [lineno, @ns_charno - 1])
+            (@map[:rbrace] ||= []).shift if map && MAPPINGS[node.type] == :lbrace
           end
 
           raise "Cannot determine start of node #{node} around #{file}:#{lineno}" if lstart.nil? || sstart.nil?
@@ -432,16 +433,21 @@ def on_rbracket(tok)
           visit_ns_token(:rbracket, tok, false)
         end
 
+        def on_rbrace(tok)
+          (@map[:rbrace] ||= []) << [lineno, charno]
+          visit_ns_token(:rbrace, tok, false)
+        end
+
         # Ruby 3.0+ pattern matching: array patterns (SomeClass[a, b]) and find patterns
         # (SomeClass[*pre, val, *post]) use [...] brackets, which fire on_lbracket and
-        # on_rbracket scanner events. The corresponding parser events are on_aptn/on_fndptn
+        # on_rbracket scanner events. The corresponding parser events are on_aryptn/on_fndptn
         # (not on_aref), so we must clean up the bracket maps to prevent stale entries from
         # corrupting source ranges of later array indexing expressions.
-        def on_aptn(*args)
+        def on_aryptn(*args)
           @map[:lbracket].pop
           @map[:aref].shift
           # Source range is intentionally not set; YARD does not traverse pattern-match arms.
-          AstNode.new(:aptn, args)
+          AstNode.new(:aryptn, args)
         end
 
         def on_fndptn(*args)
@@ -451,6 +457,20 @@ def on_fndptn(*args)
           AstNode.new(:fndptn, args)
         end
 
+        # Ruby 3.0+ pattern matching: braced hash patterns ({key: val} syntax) fire
+        # on_lbrace and on_rbrace scanner events. The corresponding parser event is
+        # on_hshptn (not on_hash), so we must clean up the brace maps to prevent stale
+        # entries from corrupting source ranges of later hash literals and brace blocks.
+        # Bare hash patterns (key: val without braces) fire no brace scanner events, so
+        # we only clean up when @map[:rbrace] confirms a closing brace was scanned.
+        def on_hshptn(*args)
+          if (@map[:rbrace] ||= []).any?
+            @map[:lbrace].pop
+            @map[:rbrace].shift
+          end
+          AstNode.new(:hshptn, args)
+        end
+
         def on_dyna_symbol(sym)
           rng = if sym.source_range.to_a.size == 0 # rubocop:disable Style/ZeroLengthPredicate
                   (sym.source_range.begin - 3)...sym.source_range.end

spec/parser/ruby/ruby_parser_spec.rb

@@ -679,62 +679,82 @@ def add(x) = x + 1
       end
     end if RUBY_VERSION >= '3.'
 
-    it "provides correct source range for %i[] constant after pattern matching deconstruction" do
-      code = <<-RUBY
-class Foo
-  def check(obj)
-    case obj
-    in Bar['key', v]
-      v
-    end
-  end
+    it "provides correct source range for aref after array pattern deconstruction" do
+      code = <<~RUBY
+        class Foo
+          def check(obj)
+            case obj
+            in Bar["key", v]
+              v
+            end
+          end
 
-  SYMBOLS = %i[foo bar baz]
-end
+          def fetch(h)
+            h["result"]
+          end
+        end
       RUBY
 
       parser = YARD::Parser::Ruby::RubyParser.new(code, nil)
       ast = parser.parse.root
 
-      const_node = nil
-      ast.traverse do |node|
-        if node.type == :assign && node.children.first.source == 'SYMBOLS'
-          const_node = node
-          break
-        end
-      end
+      aref_node = nil
+      ast.traverse { |n| (aref_node = n; break) if n.type == :aref }
 
-      expect(const_node).not_to be_nil
-      expect(code[const_node.source_range]).to eq('SYMBOLS = %i[foo bar baz]')
+      expect(aref_node).not_to be_nil
+      expect(code[aref_node.source_range]).to eq('h["result"]')
     end if RUBY_VERSION >= '3.'
 
-    it "provides correct source range for %i[] constant after find pattern deconstruction" do
-      code = <<-RUBY
-class Foo
-  def check(obj)
-    case obj
-    in Bar[*, v, *]
-      v
-    end
-  end
+    it "provides correct source range for aref after find pattern deconstruction" do
+      code = <<~RUBY
+        class Foo
+          def check(obj)
+            case obj
+            in Bar[*, v, *]
+              v
+            end
+          end
 
-  SYMBOLS = %i[foo bar baz]
-end
+          def fetch(h)
+            h["result"]
+          end
+        end
       RUBY
 
       parser = YARD::Parser::Ruby::RubyParser.new(code, nil)
       ast = parser.parse.root
 
-      const_node = nil
-      ast.traverse do |node|
-        if node.type == :assign && node.children.first.source == 'SYMBOLS'
-          const_node = node
-          break
+      aref_node = nil
+      ast.traverse { |n| (aref_node = n; break) if n.type == :aref }
+
+      expect(aref_node).not_to be_nil
+      expect(code[aref_node.source_range]).to eq('h["result"]')
+    end if RUBY_VERSION >= '3.'
+
+    it "provides correct source range for hash literal after braced hash pattern deconstruction" do
+      code = <<~RUBY
+        class Foo
+          def check(obj)
+            case obj
+            in { name: String }
+              "matched"
+            end
+          end
+
+          def build
+            { name: "Alice" }
+          end
         end
-      end
+      RUBY
+
+      parser = YARD::Parser::Ruby::RubyParser.new(code, nil)
+      ast = parser.parse.root
+
+      hash_node = nil
+      ast.traverse { |n| (hash_node = n; break) if n.type == :hash }
 
-      expect(const_node).not_to be_nil
-      expect(code[const_node.source_range]).to eq('SYMBOLS = %i[foo bar baz]')
+      expect(hash_node).not_to be_nil
+      expect(code[hash_node.source_range]).to eq('{ name: "Alice" }')
     end if RUBY_VERSION >= '3.'
 
     it "provides correct range for `next` statement following `def` _symbol_" do