Address review feedback: nil guards, undef on_rbrace, comment accuracy, bare-pattern tests

- Add `undef on_rbrace` to the undef block, consistent with every other
  explicit event override in the file
- Use `(@Map[:lbracket] ||= []).pop` and `(@Map[:aref] ||= []).shift` in
  on_aryptn/on_fndptn, matching on_hshptn's defensive nil-safe style
- Correct the comment on on_aryptn/on_fndptn: YARD does traverse these nodes
  via root.traverse; what it lacks is a registered handler, so they produce no
  documentation output
- Add explanatory comment on on_rbrace clarifying why it maintains @Map[:rbrace]
  when on_rbracket does not
- Add tests for bare array pattern (`in [a, b]`) and bare hash pattern
  (`in name: String`) to cover the unbraced branches of on_aryptn and on_hshptn

Author: dduugg

lib/yard/parser/ruby/ruby_parser.rb

@@ -337,6 +337,7 @@ def add_token(token, data)
         undef on_aref_field
         undef on_lbracket
         undef on_rbracket
+        undef on_rbrace
         undef on_string_literal
         undef on_lambda
         undef on_unary
@@ -433,6 +434,8 @@ def on_rbracket(tok)
           visit_ns_token(:rbracket, tok, false)
         end
 
+        # Maintained explicitly (unlike on_rbracket) so on_hshptn can distinguish
+        # braced from bare hash patterns in Ruby 3.0+ pattern matching.
         def on_rbrace(tok)
           (@map[:rbrace] ||= []) << [lineno, charno]
           visit_ns_token(:rbrace, tok, false)
@@ -444,16 +447,18 @@ def on_rbrace(tok)
         # (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_aryptn(*args)
-          @map[:lbracket].pop
-          @map[:aref].shift
-          # Source range is intentionally not set; YARD does not traverse pattern-match arms.
+          (@map[:lbracket] ||= []).pop
+          (@map[:aref] ||= []).shift
+          # Source range is intentionally not set; no handler is registered for
+          # pattern-match nodes, so they produce no documentation output.
           AstNode.new(:aryptn, args)
         end
 
         def on_fndptn(*args)
-          @map[:lbracket].pop
-          @map[:aref].shift
-          # Source range is intentionally not set; YARD does not traverse pattern-match arms.
+          (@map[:lbracket] ||= []).pop
+          (@map[:aref] ||= []).shift
+          # Source range is intentionally not set; no handler is registered for
+          # pattern-match nodes, so they produce no documentation output.
           AstNode.new(:fndptn, args)
         end
 

spec/parser/ruby/ruby_parser_spec.rb

@@ -751,6 +751,68 @@ def check(obj)
     end
   end
 
+  def build
+    { name: "Alice" }
+  end
+end
+      RUBY
+
+      parser = YARD::Parser::Ruby::RubyParser.new(code, nil)
+      ast = parser.parse.root
+
+      hash_node = nil
+      ast.traverse do |node|
+        if node.type == :hash
+          hash_node = node
+          break
+        end
+      end
+
+      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 source range for aref after bare array pattern deconstruction" do
+      code = <<-RUBY
+class Foo
+  def check(obj)
+    case obj
+    in [a, b]
+      a
+    end
+  end
+
+  def fetch(h)
+    h["result"]
+  end
+end
+      RUBY
+
+      parser = YARD::Parser::Ruby::RubyParser.new(code, nil)
+      ast = parser.parse.root
+
+      aref_node = nil
+      ast.traverse do |node|
+        if node.type == :aref
+          aref_node = node
+          break
+        end
+      end
+
+      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 bare hash pattern deconstruction" do
+      code = <<-RUBY
+class Foo
+  def check(obj)
+    case obj
+    in name: String
+      "matched"
+    end
+  end
+
   def build
     { name: "Alice" }
   end