From 4b316b39b9eb0a13a7b9009fa5578a5a084c88d5 Mon Sep 17 00:00:00 2001
From: USAMI Kenta <tadsan@zonu.me>
Date: Sun, 11 Oct 2026 14:21:47 +0900
Subject: [PATCH] Add missing core instance methods

Add signatures for public instance methods that are defined in Ruby 4.0
but were missing from core/:

- Binding#implicit_parameter_defined?, #implicit_parameter_get,
  #implicit_parameters
- IO#external_encoding, IO#to_path, IO#wait_priority
- Process::Tms#utime, #stime, #cutime, #cstime and their setters
- Thread#set_trace_func
---
 core/binding.rbs                | 66 +++++++++++++++++++++++++++++++++
 core/io.rbs                     | 22 +++++++++++
 core/io/wait.rbs                | 11 ++++++
 core/process.rbs                | 19 ++++++++++
 core/thread.rbs                 | 13 +++++++
 test/stdlib/Binding_test.rb     | 43 +++++++++++++++++++++
 test/stdlib/IO_test.rb          | 47 +++++++++++++++++++++++
 test/stdlib/Process_Tms_test.rb | 39 +++++++++++++++++++
 test/stdlib/Thread_test.rb      | 11 ++++++
 9 files changed, 271 insertions(+)
 create mode 100644 test/stdlib/Process_Tms_test.rb

diff --git a/core/binding.rbs b/core/binding.rbs
index fea7af371a..31952d547a 100644
--- a/core/binding.rbs
+++ b/core/binding.rbs
@@ -48,6 +48,72 @@ class Binding
   #
   def eval: (string src, ?string filename, ?int lineno) -> untyped
 
+  # <!--
+  #   rdoc-file=proc.c
+  #   - binding.implicit_parameter_defined?(symbol) -> obj
+  # -->
+  # Returns `true` if the numbered parameter or "it" parameter exists.
+  #
+  #     def foo
+  #       [42].each do
+  #         it
+  #         binding.implicit_parameter_defined?(:it) #=> true
+  #         binding.implicit_parameter_defined?(:_1) #=> false
+  #       end
+  #
+  #       { k: 42 }.each do
+  #         _2
+  #         binding.implicit_parameter_defined?(:_1) #=> true
+  #         binding.implicit_parameter_defined?(:_2) #=> true
+  #         binding.implicit_parameter_defined?(:_3) #=> false
+  #         binding.implicit_parameter_defined?(:it) #=> false
+  #       end
+  #     end
+  #
+  def implicit_parameter_defined?: (interned symbol) -> bool
+
+  # <!--
+  #   rdoc-file=proc.c
+  #   - binding.implicit_parameter_get(symbol) -> obj
+  # -->
+  # Returns the value of the numbered parameter or "it" parameter.
+  #
+  #     def foo
+  #       [42].each do
+  #         it
+  #         binding.implicit_parameter_get(:it) #=> 42
+  #       end
+  #
+  #       { k: 42 }.each do
+  #         _2
+  #         binding.implicit_parameter_get(:_1) #=> :k
+  #         binding.implicit_parameter_get(:_2) #=> 42
+  #       end
+  #     end
+  #
+  def implicit_parameter_get: (interned symbol) -> untyped
+
+  # <!--
+  #   rdoc-file=proc.c
+  #   - binding.implicit_parameters -> Array
+  # -->
+  # Returns the names of numbered parameters and "it" parameter that are defined
+  # in the binding.
+  #
+  #     def foo
+  #       [42].each do
+  #         it
+  #         binding.implicit_parameters #=> [:it]
+  #       end
+  #
+  #       { k: 42 }.each do
+  #         _2
+  #         binding.implicit_parameters #=> [:_1, :_2]
+  #       end
+  #     end
+  #
+  def implicit_parameters: () -> Array[Symbol]
+
   # <!--
   #   rdoc-file=proc.c
   #   - binding.local_variable_defined?(symbol) -> obj
diff --git a/core/io.rbs b/core/io.rbs
index 34000de84c..2bd1ac7412 100644
--- a/core/io.rbs
+++ b/core/io.rbs
@@ -972,6 +972,17 @@ class IO < Object
   #
   def eof: () -> bool
 
+  # <!--
+  #   rdoc-file=io.c
+  #   - external_encoding -> encoding or nil
+  # -->
+  # Returns the Encoding object that represents the encoding of the stream, or
+  # `nil` if the stream is in write mode and no encoding is specified.
+  #
+  # See [Encodings](rdoc-ref:File@Encodings).
+  #
+  def external_encoding: () -> Encoding?
+
   # <!--
   #   rdoc-file=io.c
   #   - fcntl(integer_cmd, argument) -> integer
@@ -2176,6 +2187,17 @@ class IO < Object
   #
   def to_io: () -> self
 
+  # <!-- rdoc-file=io.c -->
+  # Returns the path associated with the IO, or `nil` if there is no path
+  # associated with the IO. It is not guaranteed that the path exists on the
+  # filesystem.
+  #
+  #     $stdin.path # => "<STDIN>"
+  #
+  #     File.open("testfile") {|f| f.path} # => "testfile"
+  #
+  alias to_path path
+
   # <!-- rdoc-file=io.c -->
   # Returns `true` if the stream is associated with a terminal device (tty),
   # `false` otherwise:
diff --git a/core/io/wait.rbs b/core/io/wait.rbs
index e5a5e797d2..0f7efe1897 100644
--- a/core/io/wait.rbs
+++ b/core/io/wait.rbs
@@ -25,6 +25,17 @@ class IO
 
   type wait_mode = :read | :r | :readable | :write | :w | :writable | :read_write | :rw | :readable_writable
 
+  # <!--
+  #   rdoc-file=io.c
+  #   - io.wait_priority          -> truthy or falsy
+  #   - io.wait_priority(timeout) -> truthy or falsy
+  # -->
+  # Waits until IO is priority and returns a truthy value or a falsy value when
+  # times out. Priority data is sent and received using the Socket::MSG_OOB flag
+  # and is typically limited to streams.
+  #
+  def wait_priority: (?Time::_Timeout? timeout) -> boolish
+
   # <!--
   #   rdoc-file=io.c
   #   - io.wait_readable          -> truthy or falsy
diff --git a/core/process.rbs b/core/process.rbs
index 0b1a1adf8f..f3b50eb51f 100644
--- a/core/process.rbs
+++ b/core/process.rbs
@@ -2303,6 +2303,25 @@ end
 # Placeholder for rusage
 #
 class Process::Tms < Struct[Float]
+  # <!-- rdoc-file=process.c -->
+  # user time used in this process
+  #
+  attr_accessor utime: Float
+
+  # <!-- rdoc-file=process.c -->
+  # system time used in this process
+  #
+  attr_accessor stime: Float
+
+  # <!-- rdoc-file=process.c -->
+  # user time used in the child processes
+  #
+  attr_accessor cutime: Float
+
+  # <!-- rdoc-file=process.c -->
+  # system time used in the child processes
+  #
+  attr_accessor cstime: Float
 end
 
 class Process::Waiter < Thread
diff --git a/core/thread.rbs b/core/thread.rbs
index 4ce6bc7a6b..234a380cd8 100644
--- a/core/thread.rbs
+++ b/core/thread.rbs
@@ -647,6 +647,19 @@ class Thread < Object
   # check $SAFE.
   def safe_level: () -> Integer
 
+  # <!--
+  #   rdoc-file=vm_trace.c
+  #   - thr.set_trace_func(proc)    -> proc
+  #   - thr.set_trace_func(nil)     -> nil
+  # -->
+  # Establishes *proc* on *thr* as the handler for tracing, or disables tracing if
+  # the parameter is `nil`.
+  #
+  # See Kernel#set_trace_func.
+  #
+  def set_trace_func: (Proc proc) -> Proc
+                    | (nil) -> nil
+
   # <!--
   #   rdoc-file=thread.c
   #   - thr.status   -> string, false or nil
diff --git a/test/stdlib/Binding_test.rb b/test/stdlib/Binding_test.rb
index b048b38029..e08035a2d5 100644
--- a/test/stdlib/Binding_test.rb
+++ b/test/stdlib/Binding_test.rb
@@ -27,6 +27,49 @@ def test_eval
     end
   end
 
+  def test_implicit_parameter_defined?
+    [1].each do
+      it
+      b = binding
+
+      with_interned :it do |symbol|
+        assert_send_type  '(interned) -> bool',
+                          b, :implicit_parameter_defined?, symbol
+      end
+      assert_send_type  '(Symbol) -> bool',
+                        b, :implicit_parameter_defined?, :_1
+    end
+  end
+
+  def test_implicit_parameter_get
+    [1].each do
+      _1
+      b = binding
+
+      with_interned :_1 do |symbol|
+        assert_send_type  '(interned) -> untyped',
+                          b, :implicit_parameter_get, symbol
+      end
+    end
+  end
+
+  def test_implicit_parameters
+    assert_send_type  '() -> Array[Symbol]',
+                      binding, :implicit_parameters
+
+    [1].each do
+      it
+      assert_send_type  '() -> Array[Symbol]',
+                        binding, :implicit_parameters
+    end
+
+    [1].each do
+      _1
+      assert_send_type  '() -> Array[Symbol]',
+                        binding, :implicit_parameters
+    end
+  end
+
   def test_local_variable_defined?
     with_interned :hello do |varname|
       assert_send_type  '(interned) -> bool',
diff --git a/test/stdlib/IO_test.rb b/test/stdlib/IO_test.rb
index 453256ddc7..7c50348010 100644
--- a/test/stdlib/IO_test.rb
+++ b/test/stdlib/IO_test.rb
@@ -311,6 +311,22 @@ def test_each_line
     end
   end
 
+  def test_external_encoding
+    File.open(File.expand_path(__FILE__)) do |io|
+      assert_send_type(
+        "() -> Encoding",
+        io, :external_encoding
+      )
+    end
+
+    File.open(IO::NULL, "w") do |io|
+      assert_send_type(
+        "() -> nil",
+        io, :external_encoding
+      )
+    end
+  end
+
   def test_path
     IO.open(IO.sysopen(File.expand_path(__FILE__)), path: "foo") do |io|
       assert_send_type(
@@ -327,6 +343,22 @@ def test_path
     end
   end
 
+  def test_to_path
+    IO.open(IO.sysopen(File.expand_path(__FILE__)), path: "foo") do |io|
+      assert_send_type(
+        "() -> String",
+        io, :to_path
+      )
+    end
+
+    IO.open(IO.sysopen(File.expand_path(__FILE__)), path: nil) do |io|
+      assert_send_type(
+        "() -> nil",
+        io, :to_path
+      )
+    end
+  end
+
   def test_read
     IO.open(IO.sysopen(File.expand_path(__FILE__))) do |io|
       assert_send_type "() -> String",
@@ -593,6 +625,21 @@ def test_wait_readable
     end
   end
 
+  def test_wait_priority
+    IO.pipe do |r, w|
+      assert_send_type(
+        "(Integer) -> nil",
+        r, :wait_priority, 0
+      )
+
+      r.ungetc("a")
+      assert_send_type(
+        "() -> true",
+        r, :wait_priority
+      )
+    end
+  end
+
   def test_wait_writable
     if_ruby "3.0.0"..."3.2.0" do
       IO.pipe.tap do |r, w|
diff --git a/test/stdlib/Process_Tms_test.rb b/test/stdlib/Process_Tms_test.rb
new file mode 100644
index 0000000000..c3ca73866e
--- /dev/null
+++ b/test/stdlib/Process_Tms_test.rb
@@ -0,0 +1,39 @@
+require_relative "test_helper"
+
+class Process_TmsInstanceTest < Test::Unit::TestCase
+  include TestHelper
+
+  testing "::Process::Tms"
+
+  def test_utime
+    assert_send_type "() -> Float", Process.times, :utime
+  end
+
+  def test_utime=
+    assert_send_type "(Float) -> Float", Process.times, :utime=, 1.0
+  end
+
+  def test_stime
+    assert_send_type "() -> Float", Process.times, :stime
+  end
+
+  def test_stime=
+    assert_send_type "(Float) -> Float", Process.times, :stime=, 1.0
+  end
+
+  def test_cutime
+    assert_send_type "() -> Float", Process.times, :cutime
+  end
+
+  def test_cutime=
+    assert_send_type "(Float) -> Float", Process.times, :cutime=, 1.0
+  end
+
+  def test_cstime
+    assert_send_type "() -> Float", Process.times, :cstime
+  end
+
+  def test_cstime=
+    assert_send_type "(Float) -> Float", Process.times, :cstime=, 1.0
+  end
+end
diff --git a/test/stdlib/Thread_test.rb b/test/stdlib/Thread_test.rb
index 5a814143d6..cf87922c36 100644
--- a/test/stdlib/Thread_test.rb
+++ b/test/stdlib/Thread_test.rb
@@ -206,4 +206,15 @@ def test_run
   def test_wakeup
     assert_send_type "() -> ThreadTest::Sub", Sub.new{}, :wakeup
   end
+
+  def test_set_trace_func
+    th = Thread.new { sleep }
+    trace = proc { }
+
+    assert_send_type "(Proc) -> Proc", th, :set_trace_func, trace
+    assert_send_type "(nil) -> nil", th, :set_trace_func, nil
+  ensure
+    th&.set_trace_func(nil)
+    th&.kill&.join
+  end
 end