Merge remote-tracking branch 'gh/master' into zjit-polymorphic-getivar

Author: XrXr

.github/workflows/dependabot_automerge.yml

@@ -17,7 +17,7 @@ jobs:
         id: metadata
 
       - name: Wait for status checks
-        uses: lewagon/wait-on-check-action@3603e826ee561ea102b58accb5ea55a1a7482343 # v1.4.1
+        uses: lewagon/wait-on-check-action@74049309dfeff245fe8009a0137eacf28136cb3c # v1.5.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           ref: ${{ github.event.pull_request.head.sha || github.sha }}

.gitignore

@@ -278,3 +278,8 @@ lcov*.info
 /bundled_gems.json
 /default_gems.json
 /gems/default_gems
+
+# AI agents
+/.claude
+/AGENTS.md
+/CLAUDE.md

array.c

@@ -8423,12 +8423,12 @@ rb_ary_deconstruct(VALUE ary)
  *
  *      [1, 'one', :one, [2, 'two', :two]]
  *
- *  - A {%w or %W string-array Literal}[rdoc-ref:syntax/literals.rdoc@25w+and+-25W-3A+String-Array+Literals]:
+ *  - A {%w or %W string-array Literal}[rdoc-ref:syntax/literals.rdoc@w-and-w-String-Array-Literals]:
  *
  *      %w[foo bar baz] # => ["foo", "bar", "baz"]
  *      %w[1 % *]       # => ["1", "%", "*"]
  *
- *  - A {%i or %I symbol-array Literal}[rdoc-ref:syntax/literals.rdoc@25i+and+-25I-3A+Symbol-Array+Literals]:
+ *  - A {%i or %I symbol-array Literal}[rdoc-ref:syntax/literals.rdoc@i+and-I-Symbol-Array+Literals]:
  *
  *      %i[foo bar baz] # => [:foo, :bar, :baz]
  *      %i[1 % *]       # => [:"1", :%, :*]
@@ -8690,8 +8690,8 @@ rb_ary_deconstruct(VALUE ary)
  *
  *  First, what's elsewhere. Class \Array:
  *
- *  - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here].
- *  - Includes {module Enumerable}[rdoc-ref:Enumerable@What-27s+Here],
+ *  - Inherits from {class Object}[rdoc-ref:Object@Whats-Here].
+ *  - Includes {module Enumerable}[rdoc-ref:Enumerable@Whats-Here],
  *    which provides dozens of additional methods.
  *
  *  Here, class \Array provides methods that are useful for:

complex.c

@@ -2645,9 +2645,9 @@ float_arg(VALUE self)
  * First, what's elsewhere:
  *
  * - Class \Complex inherits (directly or indirectly)
- *   from classes {Numeric}[rdoc-ref:Numeric@What-27s+Here]
- *   and {Object}[rdoc-ref:Object@What-27s+Here].
- * - Includes (indirectly) module {Comparable}[rdoc-ref:Comparable@What-27s+Here].
+ *   from classes {Numeric}[rdoc-ref:Numeric@Whats-Here]
+ *   and {Object}[rdoc-ref:Object@Whats-Here].
+ * - Includes (indirectly) module {Comparable}[rdoc-ref:Comparable@Whats-Here].
  *
  * Here, class \Complex has methods for:
  *

dir.rb

@@ -31,7 +31,7 @@
 # A \Dir object is in some ways array-like:
 #
 # - It has instance methods #children, #each, and #each_child.
-# - It includes {module Enumerable}[rdoc-ref:Enumerable@What-27s+Here].
+# - It includes {module Enumerable}[rdoc-ref:Enumerable@Whats+Here].
 #
 # == \Dir As Stream-Like
 #
@@ -85,8 +85,8 @@
 #
 # First, what's elsewhere. Class \Dir:
 #
-# - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here].
-# - Includes {module Enumerable}[rdoc-ref:Enumerable@What-27s+Here],
+# - Inherits from {class Object}[rdoc-ref:Object@Whats+Here].
+# - Includes {module Enumerable}[rdoc-ref:Enumerable@Whats+Here],
 #   which provides dozens of additional methods.
 #
 # Here, class \Dir provides methods that are useful for:

doc/float.rb

@@ -72,9 +72,9 @@
 # First, what's elsewhere. Class \Float:
 #
 # - Inherits from
-#   {class Numeric}[rdoc-ref:Numeric@What-27s+Here]
-#   and {class Object}[rdoc-ref:Object@What-27s+Here].
-# - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here].
+#   {class Numeric}[rdoc-ref:Numeric@Whats+Here]
+#   and {class Object}[rdoc-ref:Object@Whats+Here].
+# - Includes {module Comparable}[rdoc-ref:Comparable@Whats+Here].
 #
 # Here, class \Float provides methods for:
 #

doc/string.rb

@@ -163,8 +163,8 @@
 #
 # First, what's elsewhere. Class +String+:
 #
-# - Inherits from the {Object class}[rdoc-ref:Object@What-27s+Here].
-# - Includes the {Comparable module}[rdoc-ref:Comparable@What-27s+Here].
+# - Inherits from the {Object class}[rdoc-ref:Object@Whats+Here].
+# - Includes the {Comparable module}[rdoc-ref:Comparable@Whats+Here].
 #
 # Here, class +String+ provides methods that are useful for:
 #

doc/syntax/literals.rdoc

@@ -547,6 +547,13 @@ with <tt>%w</tt> (non-interpolable) or <tt>%W</tt> (interpolable):
   # (not nested array).
   %w[foo[bar baz]qux]   # => ["foo[bar", "baz]qux"]
 
+The interpolated string is treated as a single word even if it contains
+whitespace.
+
+  s = "bar baz"
+  %W[foo #{s} zot] #=> ["foo", "bar baz", "zot"]
+  %W[foo #{"bar baz  zot"} qux] # => ["foo", "bar baz  zot", "qux"]
+
 The following characters are considered as white spaces to separate words:
 
 * space, ASCII 20h (SPC)

eval.c

@@ -329,17 +329,24 @@ ruby_exec_node(void *n)
 
 /*
  *  call-seq:
- *     Module.nesting    -> array
- *
- *  Returns the list of +Modules+ nested at the point of call.
+ *     Module.nesting -> array
+ *
+ *  Returns nested module as an array of Module objects:
+ *
+ *    module M0
+ *      def self.speak = Module.nesting
+ *      module M1
+ *        def self.speak = Module.nesting
+ *        module M2
+ *          def self.speak = Module.nesting
+ *        end
+ *      end
+ *    end
+ *    M0.speak             # => [M0]
+ *    M0.speak.first.class # => Module
+ *    M0::M1.speak         # => [M0::M1, M0]
+ *    M0::M1::M2.speak     # => [M0::M1::M2, M0::M1, M0]
  *
- *     module M1
- *       module M2
- *         $a = Module.nesting
- *       end
- *     end
- *     $a           #=> [M1::M2, M1]
- *     $a[0].name   #=> "M1::M2"
  */
 
 static VALUE

ext/coverage/coverage.c

@@ -480,137 +480,139 @@ rb_coverage_running(VALUE klass)
 }
 
 /* \Coverage provides coverage measurement feature for Ruby.
- * This feature is experimental, so these APIs may be changed in future.
  *
- * Caveat: Currently, only process-global coverage measurement is supported.
- * You cannot measure per-thread coverage.
+ * Only process-global coverage measurement is supported, meaning
+ * that coverage cannot be measure on a per-thread basis.
  *
- * = Usage
+ * = Quick Start
  *
- * 1. require "coverage"
- * 2. do Coverage.start
- * 3. require or load Ruby source file
- * 4. Coverage.result will return a hash that contains filename as key and
- *    coverage array as value. A coverage array gives, for each line, the
- *    number of line execution by the interpreter. A +nil+ value means
- *    coverage is disabled for this line (lines like +else+ and +end+).
+ * 1. Load coverage using <tt>require "coverage"</tt>.
+ * 2. Call Coverage.start to set up and begin coverage measurement.
+ * 3. All Ruby code loaded following the call to Coverage.start will have
+ *    coverage measurement.
+ * 4. Coverage results can be fetched by calling Coverage.result, which returns a
+ *    hash that contains filenames as the keys and coverage arrays as the values.
+ *    Each element of the coverage array gives the number of times each line was
+ *    executed. A +nil+ value means coverage was disabled for that line (e.g.
+ *    lines like +else+ and +end+).
  *
  * = Examples
  *
- *   [foo.rb]
- *   s = 0
- *   10.times do |x|
- *     s += x
- *   end
+ * In file +fib.rb+:
  *
- *   if s == 45
- *     p :ok
- *   else
- *     p :ng
+ *   def fibonacci(n)
+ *     if n == 0
+ *       0
+ *     elsif n == 1
+ *       1
+ *     else
+ *       fibonacci(n - 1) + fibonacci(n - 2)
+ *     end
  *   end
- *   [EOF]
+ *
+ *   puts fibonacci(10)
+ *
+ * In another file, coverage can be measured:
  *
  *   require "coverage"
  *   Coverage.start
- *   require "foo.rb"
- *   p Coverage.result  #=> {"foo.rb"=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}
+ *   require "fib.rb"
+ *   Coverage.result # => {"fib.rb" => [1, 177, 34, 143, 55, nil, 88, nil, nil, nil, 1]}
  *
  * == Lines \Coverage
  *
- * If a coverage mode is not explicitly specified when starting coverage, lines
- * coverage is what will run. It reports the number of line executions for each
- * line.
+ * Lines coverage reports the number of line executions for each line.
+ * If the coverage mode is not explicitly specified when starting coverage,
+ * lines coverage is used as the default.
  *
  *   require "coverage"
  *   Coverage.start(lines: true)
- *   require "foo.rb"
- *   p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}}
+ *   require "fib"
+ *   Coverage.result # => {"fib.rb" => {lines: [1, 177, 34, 143, 55, nil, 88, nil, nil, nil, 1]}}
  *
- * The value of the lines coverage result is an array containing how many times
- * each line was executed. Order in this array is important. For example, the
- * first item in this array, at index 0, reports how many times line 1 of this
- * file was executed while coverage was run (which, in this example, is one
- * time).
+ * The returned hash differs depending on how Coverage.setup or Coverage.start
+ * was executed.
+ *
+ * If Coverage.start or Coverage.setup was called with no arguments, it returns a
+ * hash which contains filenames as the keys and coverage arrays as the values.
  *
- * A +nil+ value means coverage is disabled for this line (lines like +else+
- * and +end+).
+ * If Coverage.start or Coverage.setup was called with <tt>line: true</tt>, it
+ * returns a hash which contains filenames as the keys and hashes as the values.
+ * The value hash has a key +:lines+ where the value is a coverage array.
+ *
+ * Each element of the coverage array gives the number of times the line was
+ * executed. A +nil+ value in the coverage array means coverage was disabled
+ * for that line (e.g. lines like +else+ and +end+).
  *
  * == Oneshot Lines \Coverage
  *
- * Oneshot lines coverage tracks and reports on the executed lines while
- * coverage is running. It will not report how many times a line was executed,
- * only that it was executed.
+ * Oneshot lines coverage is similar to lines coverage, but instead of reporting
+ * the number of times a line was executed, it only reports the lines that were
+ * executed.
  *
  *   require "coverage"
  *   Coverage.start(oneshot_lines: true)
- *   require "foo.rb"
- *   p Coverage.result #=> {"foo.rb"=>{:oneshot_lines=>[1, 2, 3, 6, 7]}}
+ *   require "fib"
+ *   Coverage.result # => {"fib.rb" => {oneshot_lines: [1, 11, 2, 4, 7, 5, 3]}}
  *
  * The value of the oneshot lines coverage result is an array containing the
  * line numbers that were executed.
  *
  * == Branches \Coverage
  *
- * Branches coverage reports how many times each branch within each conditional
+ * Branches coverage reports the number of times each branch within each conditional
  * was executed.
  *
  *   require "coverage"
  *   Coverage.start(branches: true)
- *   require "foo.rb"
- *   p Coverage.result #=> {"foo.rb"=>{:branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}}}
+ *   require "fib"
+ *   Coverage.result
+ *   # => {"fib.rb" => {
+ *   #      branches: {
+ *   #        [:if, 0, 2, 2, 8, 5] => {
+ *   #          [:then, 1, 3, 4, 3, 5] => 34,
+ *   #          [:else, 2, 4, 2, 8, 5] => 143},
+ *   #        [:if, 3, 4, 2, 8, 5] => {
+ *   #          [:then, 4, 5, 4, 5, 5] => 55,
+ *   #          [:else, 5, 7, 4, 7, 39] => 88}}}}
  *
  * Each entry within the branches hash is a conditional, the value of which is
- * another hash where each entry is a branch in that conditional. The values
- * are the number of times the method was executed, and the keys are identifying
- * information about the branch.
+ * another hash where each entry is a branch in that conditional. The keys are
+ * arrays containing information about the branch and the values are the number
+ * of times the branch was executed.
  *
- * The information that makes up each key identifying branches or conditionals
- * is the following, from left to right:
+ * The information that makes up the array that are the keys for conditional or
+ * branches are the following, from left to right:
  *
- * 1. A label for the type of branch or conditional.
+ * 1. A label for the type of branch or conditional (e.g. +:if+, +:then+, +:else+).
  * 2. A unique identifier.
- * 3. The starting line number it appears on in the file.
- * 4. The starting column number it appears on in the file.
- * 5. The ending line number it appears on in the file.
- * 6. The ending column number it appears on in the file.
+ * 3. Starting line number.
+ * 4. Starting column number.
+ * 5. Ending line number.
+ * 6. Ending column number.
  *
  * == Methods \Coverage
  *
  * Methods coverage reports how many times each method was executed.
  *
- *   [foo_method.rb]
- *   class Greeter
- *     def greet
- *       "welcome!"
- *     end
- *   end
- *
- *   def hello
- *     "Hi"
- *   end
- *
- *   hello()
- *   Greeter.new.greet()
- *   [EOF]
- *
  *   require "coverage"
  *   Coverage.start(methods: true)
- *   require "foo_method.rb"
- *   p Coverage.result #=> {"foo_method.rb"=>{:methods=>{[Object, :hello, 7, 0, 9, 3]=>1, [Greeter, :greet, 2, 2, 4, 5]=>1}}}
+ *   require "fib"
+ *   p Coverage.result #=> {"fib.rb" => {methods: {[Object, :fibonacci, 1, 0, 9, 3] => 177}}}
  *
- * Each entry within the methods hash represents a method. The values in this
- * hash are the number of times the method was executed, and the keys are
+ * Each entry within the methods hash represents a method. The keys are arrays
+ * containing hash are the number of times the method was executed, and the keys are
  * identifying information about the method.
  *
  * The information that makes up each key identifying a method is the following,
  * from left to right:
  *
- * 1. The class.
- * 2. The method name.
- * 3. The starting line number the method appears on in the file.
- * 4. The starting column number the method appears on in the file.
- * 5. The ending line number the method appears on in the file.
- * 6. The ending column number the method appears on in the file.
+ * 1. Class that the method was defined in.
+ * 2. Method name as a Symbol.
+ * 3. Starting line number of the method.
+ * 4. Starting column number of the method.
+ * 5. Ending line number of the method.
+ * 6. Ending column number of the method.
  *
  * == Eval \Coverage
  *
@@ -670,16 +672,24 @@ rb_coverage_running(VALUE klass)
  *
  * == All \Coverage Modes
  *
- * You can also run all modes of coverage simultaneously with this shortcut.
- * Note that running all coverage modes does not run both lines and oneshot
- * lines. Those modes cannot be run simultaneously. Lines coverage is run in
- * this case, because you can still use it to determine whether or not a line
- * was executed.
+ * All modes of coverage can be enabled simultaneously using the Symbol +:all+.
+ * However, note that this mode runs lines coverage and not oneshot lines since
+ * they cannot be ran simultaneously.
  *
  *   require "coverage"
  *   Coverage.start(:all)
- *   require "foo.rb"
- *   p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil], :branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}, :methods=>{}}}
+ *   require "fib"
+ *   Coverage.result
+ *   # => {"fib.rb" => {
+ *   #      lines: [1, 177, 34, 143, 55, nil, 88, nil, nil, nil, 1],
+ *   #      branches: {
+ *   #        [:if, 0, 2, 2, 8, 5] => {
+ *   #          [:then, 1, 3, 4, 3, 5] => 34,
+ *   #          [:else, 2, 4, 2, 8, 5] => 143},
+ *   #        [:if, 3, 4, 2, 8, 5] => {
+ *   #          [:then, 4, 5, 4, 5, 5] => 55,
+ *   #          [:else, 5, 7, 4, 7, 39] => 88}}}},
+ *   #      methods: {[Object, :fibonacci, 1, 0, 9, 3] => 177}}}
  */
 void
 Init_coverage(void)