rbs 1.5.1 → 1.7.0.beta.1

data/sig/locator.rbs

@@ -37,8 +37,8 @@ module RBS
 
     def find_in_type: (Integer pos, type: Types::t, array: Array[component]) -> bool
 
-    def find_in_loc: (Integer pos, location: Location::WithChildren[untyped, untyped] | Location | nil, array: Array[component]) -> bool
+    def find_in_loc: (Integer pos, location: Location[untyped, untyped]?, array: Array[component]) -> bool
 
-    def test_loc: (Integer pos, location: Location?) -> bool
+    def test_loc: (Integer pos, location: Location[untyped, untyped]?) -> bool
   end
 end

data/sig/members.rbs

@@ -25,7 +25,7 @@ module RBS
         #          ^^^                     name
         #                            ^^^   overload
         #
-        type loc = Location::WithChildren[:keyword | :name, :kind | :overload]
+        type loc = Location[:keyword | :name, :kind | :overload]
 
         attr_reader name: Symbol
         attr_reader kind: kind
@@ -59,7 +59,7 @@ module RBS
         #      ^^^^                    name
         #          ^                   colon
         #
-        type loc = Location::WithChildren[:name | :colon, :kind]
+        type loc = Location[:name | :colon, :kind]
 
         attr_reader name: Symbol
         attr_reader type: Types::t
@@ -97,7 +97,7 @@ module RBS
         #              ^         arg_open
         #                     ^  arg_close
         #
-        type loc = Location::WithChildren[:name | :keyword, :args]
+        type loc = Location[:name | :keyword, :args]
 
         attr_reader name: TypeName
         attr_reader args: Array[Types::t]
@@ -141,7 +141,7 @@ module RBS
         #                          ^^^^             ivar_name
         #                                ^          colon
         #
-        type loc = Location::WithChildren[:keyword | :name | :colon, :kind | :ivar | :ivar_name]
+        type loc = Location[:keyword | :name | :colon, :kind | :ivar | :ivar_name]
 
         attr_reader name: Symbol
         attr_reader type: Types::t
@@ -174,9 +174,9 @@ module RBS
       end
 
       module LocationOnly
-        attr_reader location: Location?
+        attr_reader location: Location[bot, bot]?
 
-        def initialize: (location: Location?) -> void
+        def initialize: (location: Location[bot, bot]?) -> void
 
         include _HashEqual
       end
@@ -206,7 +206,7 @@ module RBS
         #                ^^^^^       old_kind
         #                     ^^^    old_name
         #
-        type loc = Location::WithChildren[:keyword | :new_name | :old_name, :new_kind | :old_kind]
+        type loc = Location[:keyword | :new_name | :old_name, :new_kind | :old_kind]
 
         attr_reader new_name: Symbol
         attr_reader old_name: Symbol

data/sig/method_types.rbs

@@ -3,9 +3,9 @@ module RBS
     attr_reader type_params: Array[Symbol]
     attr_reader type: Types::Function
     attr_reader block: Types::Block?
-    attr_reader location: Location?
+    attr_reader location: Location[untyped, untyped]?
 
-    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location?) -> void
+    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location[untyped, untyped]?) -> void
 
     def ==: (untyped other) -> bool
 
@@ -13,7 +13,7 @@ module RBS
 
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location?) -> MethodType
+    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location[untyped, untyped]?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 

data/sig/parser.rbs

@@ -1,32 +1,22 @@
 module RBS
   class Parser
-    class SyntaxError < ParsingError
-      attr_reader token_str: String
-      attr_reader error_value: untyped
-      attr_reader value_stack: untyped?
+    def self.parse_method_type: (Buffer | String, ?line: Integer, ?column: Integer, ?variables: Array[Symbol]) -> MethodType
 
-      def initialize: (token_str: String, error_value: untyped, ?value_stack: untyped?) -> void
-    end
+    def self.parse_type: (Buffer | String, ?line: Integer, ?column: Integer, ?variables: Array[Symbol]) -> Types::t
 
-    class LexerError < ParsingError
-      attr_reader input: String
-      attr_reader location: Location
+    def self.parse_signature: (Buffer | String, ?line: Integer, ?column: Integer) -> Array[AST::Declarations::t]
 
-      def initialize: (input: String, location: Location) -> void
-    end
+    private
 
-    class SemanticsError < ParsingError
-      attr_reader subject: untyped
-      attr_reader location: Location
-      attr_reader original_message: String
+    def self.buffer: (String | Buffer source) -> Buffer
 
-      def initialize: (String message, subject: untyped, location: Location) -> void
-    end
+    %a{no-defn}
+    def self._parse_type: (Buffer, Integer line, Integer column, Array[Symbol] variables) -> Types::t
 
-    def self.parse_method_type: (String | Buffer, ?variables: Array[Symbol], ?eof_re: Regexp?) -> MethodType
+    %a{no-defn}
+    def self._parse_method_type: (Buffer, Integer line, Integer column, Array[Symbol] variables) -> MethodType
 
-    def self.parse_type: (String | Buffer, ?variables: Array[Symbol], ?eof_re: Regexp?) -> Types::t
-
-    def self.parse_signature: (String | Buffer, ?eof_re: Regexp?) -> Array[AST::Declarations::t]
+    %a{no-defn}
+    def self._parse_signature: (Buffer, Integer line, Integer column) -> Array[AST::Declarations::t]
   end
 end

data/sig/polyfill.rbs

@@ -1,6 +1,3 @@
-module Kernel
-end
-
 module Gem
   class Specification
     attr_reader version (): Version
@@ -16,3 +13,15 @@ module Enumerable[unchecked out Elem]
               | [U] () { (Elem) -> U } -> Array[U]
               | ...
 end
+
+module Bundler
+  class LockfileParser
+    def initialize: (String) -> void
+    def specs: () -> Array[LazySpecification]
+  end
+
+  class LazySpecification
+    def name: () -> String
+    def version: () -> String
+  end
+end

data/sig/repository.rbs

@@ -57,6 +57,10 @@ module RBS
 
     attr_reader gems: Hash[String, GemRBS]
 
+    def self.default: () -> instance
+
+    def self.find_best_version: (Gem::Version? version, Array[Gem::Version] candidates) -> Gem::Version
+
     # An optional keyword argument `no_stdlib` is to skip adding directory for stdlib classes.
     # Passing truthy value will skip loading stdlib. (You can add the stdlib root by yourself.)
     #

data/sig/types.rbs

@@ -13,7 +13,7 @@ module RBS
       def sub: (Substitution) -> t
 
       # Maps type names included in the type and returns new instance of type.
-      def map_type_name: () { (TypeName, Location?, t) -> TypeName } -> t
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> t
 
       # Yields all direct sub types included in the type.
       # It doesn't yield the type itself.
@@ -58,16 +58,16 @@ module RBS
     end
 
     module NoTypeName
-      def map_type_name: () { (TypeName, Location?, t) -> TypeName } -> self
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> self
     end
 
     module Bases
       class Base
         include _TypeBase
 
-        attr_reader location: Location?
+        attr_reader location: Location[bot, bot]?
 
-        def initialize: (location: Location?) -> void
+        def initialize: (location: Location[bot, bot]?) -> void
 
         def ==: (untyped other) -> bool
 
@@ -111,6 +111,8 @@ module RBS
     end
 
     class Variable
+      type loc = Location[bot, bot]
+
       attr_reader name: Symbol
 
       @@count: Integer
@@ -119,9 +121,9 @@ module RBS
       include NoTypeName
       include EmptyEachType
 
-      def initialize: (name: Symbol, location: Location?) -> void
+      def initialize: (name: Symbol, location: loc?) -> void
 
-      attr_reader location: Location?
+      attr_reader location: loc?
 
       def ==: (untyped other) -> bool
 
@@ -144,7 +146,7 @@ module RBS
     class ClassSingleton
       # singleton(::Foo)
       #           ^^^^^  => name
-      type loc = Location::WithChildren[:name, bot]
+      type loc = Location[:name, bot]
 
       def initialize: (name: TypeName, location: loc?) -> void
 
@@ -189,7 +191,7 @@ module RBS
       # _Foo[Bar, Baz]
       # ^^^^           => name
       #     ^^^^^^^^^^ => args
-      type loc = Location::WithChildren[:name, :args]
+      type loc = Location[:name, :args]
 
       def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
 
@@ -214,7 +216,8 @@ module RBS
       # Foo[Bar, Baz]
       # ^^^           => name
       #    ^^^^^^^^^^ => args
-      type loc = Location::WithChildren[:name, :args]
+      #
+      type loc = Location[:name, :args]
 
       def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
 
@@ -226,54 +229,64 @@ module RBS
     class Alias
       attr_reader name: TypeName
 
-      def initialize: (name: TypeName, location: Location?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (name: TypeName, location: loc?) -> void
 
       include _TypeBase
       include NoFreeVariables
       include NoSubst
       include EmptyEachType
 
-      attr_reader location: Location?
+      attr_reader location: loc?
     end
 
     class Tuple
       attr_reader types: Array[t]
 
-      def initialize: (types: Array[t], location: Location?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (types: Array[t], location: loc?) -> void
 
       include _TypeBase
 
-      attr_reader location: Location?
+      attr_reader location: loc?
     end
 
     class Record
       attr_reader fields: Hash[Symbol, t]
 
-      def initialize: (fields: Hash[Symbol, t], location: Location?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (fields: Hash[Symbol, t], location: loc?) -> void
 
       include _TypeBase
 
-      attr_reader location: Location?
+      attr_reader location: loc?
     end
 
     class Optional
       attr_reader type: t
 
-      def initialize: (type: t, location: Location?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (type: t, location: loc?) -> void
 
       include _TypeBase
 
-      attr_reader location: Location?
+      attr_reader location: loc?
     end
 
     class Union
       attr_reader types: Array[t]
 
-      def initialize: (types: Array[t], location: Location?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (types: Array[t], location: loc?) -> void
 
       include _TypeBase
 
-      attr_reader location: Location?
+      attr_reader location: loc?
 
       def map_type: () { (t) -> t } -> Union
                   | () -> Enumerator[t, Union]
@@ -282,11 +295,13 @@ module RBS
     class Intersection
       attr_reader types: Array[t]
 
-      def initialize: (types: Array[t], location: Location?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (types: Array[t], location: loc?) -> void
 
       include _TypeBase
 
-      attr_reader location: Location?
+      attr_reader location: loc?
 
       def map_type: () { (t) -> t } -> Intersection
                   | () -> Enumerator[t, Intersection]
@@ -294,7 +309,7 @@ module RBS
 
     class Function
       class Param
-        type loc = Location::WithChildren[bot, :name]
+        type loc = Location[bot, :name]
 
         attr_reader type: t
         attr_reader name: Symbol?
@@ -329,7 +344,7 @@ module RBS
       def map_type: { (t) -> t } -> Function
                   | -> Enumerator[t, Function]
 
-      def map_type_name: () { (TypeName, Location?, t) -> TypeName } -> Function
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> Function
 
       def each_type: () { (t) -> void } -> void
                    | -> Enumerator[t, void]
@@ -384,19 +399,22 @@ module RBS
       attr_reader type: Function
       attr_reader block: Block?
 
-      def initialize: (location: Location?, type: Function, block: Block?) -> void
+      type loc = Location[bot, bot]
+
+      def initialize: (location: loc?, type: Function, block: Block?) -> void
 
       include _TypeBase
 
-      attr_reader location: Location?
+      attr_reader location: loc?
     end
 
     class Literal
       type literal = String | Integer | Symbol | TrueClass | FalseClass
+      type loc = Location[bot, bot]
 
       attr_reader literal: literal
 
-      def initialize: (literal: literal, location: Location?) -> void
+      def initialize: (literal: literal, location: loc?) -> void
 
       include _TypeBase
       include NoFreeVariables
@@ -404,7 +422,7 @@ module RBS
       include EmptyEachType
       include NoTypeName
 
-      attr_reader location: Location?
+      attr_reader location: loc?
     end
   end
 end

data/sig/writer.rbs

@@ -38,7 +38,7 @@ module RBS
     def attribute: (:reader | :writer | :accessor, AST::Members::Attribute) -> void
 
     interface _Located
-      def location: () -> Location?
+      def location: () -> Location[untyped, untyped]?
     end
 
     def preserve_empty_line: (_Located?, _Located) -> void

data/stdlib/json/0/json.rbs

@@ -512,7 +512,7 @@ class Range[out Elem]
   # Deserializes JSON string by constructing new Range object with arguments `a`
   # serialized by `to_json`.
   #
-  def self.json_create: (Hash[String, String | [Elem, Elem, bool]] object) -> instance
+  def self.json_create: [A] (Hash[String, String | [A, A, bool]] object) -> Range[A]
 
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.
@@ -565,7 +565,7 @@ class Set[A]
   #
   # method used for JSON marshalling support.
   #
-  def self.json_create: (Hash[String, String | Array[A]] object) -> instance
+  def self.json_create: [A] (Hash[String, String | Array[A]] object) -> Set[A]
 
   # Marshal the object to JSON.
   #
@@ -582,7 +582,7 @@ class Struct[Elem]
   # Deserializes JSON string by constructing new Struct object with values `v`
   # serialized by `to_json`.
   #
-  def self.json_create: (Hash[String, String | Array[Elem]] object) -> instance
+  def self.json_create: [Elem] (Hash[String, String | Array[Elem]] object) -> Struct[Elem]
 
   # Returns a hash, that will be turned into a JSON object and represent this
   # object.

data/stdlib/objspace/0/objspace.rbs

@@ -0,0 +1,406 @@
+# The objspace library extends the ObjectSpace module and adds several methods
+# to get internal statistic information about object/memory management.
+#
+# You need to `require 'objspace'` to use this extension module.
+#
+# Generally, you *SHOULD NOT* use this library if you do not know about the MRI
+# implementation.  Mainly, this library is for (memory) profiler developers and
+# MRI developers who need to know about MRI memory usage.
+# The ObjectSpace module contains a number of routines that interact with the
+# garbage collection facility and allow you to traverse all living objects with
+# an iterator.
+#
+# ObjectSpace also provides support for object finalizers, procs that will be
+# called when a specific object is about to be destroyed by garbage collection.
+# See the documentation for `ObjectSpace.define_finalizer` for important
+# information on how to use this method correctly.
+#
+#     a = "A"
+#     b = "B"
+#
+#     ObjectSpace.define_finalizer(a, proc {|id| puts "Finalizer one on #{id}" })
+#     ObjectSpace.define_finalizer(b, proc {|id| puts "Finalizer two on #{id}" })
+#
+#     a = nil
+#     b = nil
+#
+# *produces:*
+#
+#     Finalizer two on 537763470
+#     Finalizer one on 537763480
+module ObjectSpace
+  # Returns the class for the given `object`.
+  #
+  #     class A
+  #       def foo
+  #         ObjectSpace::trace_object_allocations do
+  #           obj = Object.new
+  #           p "#{ObjectSpace::allocation_class_path(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     A.new.foo #=> "Class"
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_class_path: (untyped) -> String
+
+  # Returns garbage collector generation for the given `object`.
+  #
+  #     class B
+  #       include ObjectSpace
+  #
+  #       def foo
+  #         trace_object_allocations do
+  #           obj = Object.new
+  #           p "Generation is #{allocation_generation(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     B.new.foo #=> "Generation is 3"
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_generation: (untyped) -> (Integer | nil)
+
+  # Returns the method identifier for the given `object`.
+  #
+  #     class A
+  #       include ObjectSpace
+  #
+  #       def foo
+  #         trace_object_allocations do
+  #           obj = Object.new
+  #           p "#{allocation_class_path(obj)}##{allocation_method_id(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     A.new.foo #=> "Class#new"
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_method_id: (untyped) -> Symbol
+
+  # Returns the source file origin from the given `object`.
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_sourcefile: (untyped) -> String
+
+  # Returns the original line from source for from the given `object`.
+  #
+  # See ::trace_object_allocations for more information and examples.
+  #
+  def self.allocation_sourceline: (untyped) -> Integer
+
+  # Counts objects for each `T_IMEMO` type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # It returns a hash as:
+  #
+  #     {:imemo_ifunc=>8,
+  #      :imemo_svar=>7,
+  #      :imemo_cref=>509,
+  #      :imemo_memo=>1,
+  #      :imemo_throw_data=>1}
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # The contents of the returned hash is implementation specific and may change in
+  # the future.
+  #
+  # In this version, keys are symbol objects.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_imemo_objects: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts nodes for each node type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # It returns a hash as:
+  #
+  #     {:NODE_METHOD=>2027, :NODE_FBODY=>1927, :NODE_CFUNC=>1798, ...}
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # Note: The contents of the returned hash is implementation defined. It may be
+  # changed in future.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_nodes: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts objects size (in bytes) for each type.
+  #
+  # Note that this information is incomplete.  You need to deal with this
+  # information as only a **HINT**.  Especially, total size of T_DATA may be
+  # wrong.
+  #
+  # It returns a hash as:
+  #     {:TOTAL=>1461154, :T_CLASS=>158280, :T_MODULE=>20672, :T_STRING=>527249, ...}
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # The contents of the returned hash is implementation defined. It may be changed
+  # in future.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_objects_size: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts symbols for each Symbol type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # Note: The contents of the returned hash is implementation defined. It may be
+  # changed in future.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  # On this version of MRI, they have 3 types of Symbols (and 1 total counts).
+  #
+  #     * mortal_dynamic_symbol: GC target symbols (collected by GC)
+  #     * immortal_dynamic_symbol: Immortal symbols promoted from dynamic symbols (do not collected by GC)
+  #     * immortal_static_symbol: Immortal symbols (do not collected by GC)
+  #     * immortal_symbol: total immortal symbols (immortal_dynamic_symbol+immortal_static_symbol)
+  #
+  def self.count_symbols: (?Hash[Symbol, Integer] result_hash) -> Hash[Symbol, Integer]
+
+  # Counts objects for each `T_DATA` type.
+  #
+  # This method is only for MRI developers interested in performance and memory
+  # usage of Ruby programs.
+  #
+  # It returns a hash as:
+  #
+  #     {RubyVM::InstructionSequence=>504, :parser=>5, :barrier=>6,
+  #      :mutex=>6, Proc=>60, RubyVM::Env=>57, Mutex=>1, Encoding=>99,
+  #      ThreadGroup=>1, Binding=>1, Thread=>1, RubyVM=>1, :iseq=>1,
+  #      Random=>1, ARGF.class=>1, Data=>1, :autoload=>3, Time=>2}
+  #     # T_DATA objects existing at startup on r32276.
+  #
+  # If the optional argument, result_hash, is given, it is overwritten and
+  # returned. This is intended to avoid probe effect.
+  #
+  # The contents of the returned hash is implementation specific and may change in
+  # the future.
+  #
+  # In this version, keys are Class object or Symbol object.
+  #
+  # If object is kind of normal (accessible) object, the key is Class object. If
+  # object is not a kind of normal (internal) object, the key is symbol name,
+  # registered by rb_data_type_struct.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.count_tdata_objects: (?Hash[untyped, Integer] result_hash) -> Hash[untyped, Integer]
+
+  def self.dump: (untyped obj, ?output: Symbol) -> (String | File | nil)
+
+  def self.dump_all: (?since: (Integer|nil), ?full: boolish, ?output: Symbol) -> (String | File | nil)
+
+  # MRI specific feature
+  # :   Return internal class of obj.
+  #
+  # obj can be an instance of InternalObjectWrapper.
+  #
+  # Note that you should not use this method in your application.
+  #
+  def self.internal_class_of: (untyped) -> Class
+
+  # MRI specific feature
+  # :   Return internal super class of cls (Class or Module).
+  #
+  # obj can be an instance of InternalObjectWrapper.
+  #
+  # Note that you should not use this method in your application.
+  #
+  def self.internal_super_of: (untyped) -> untyped
+
+  # Return consuming memory size of obj in bytes.
+  #
+  # Note that the return size is incomplete.  You need to deal with this
+  # information as only a **HINT**. Especially, the size of `T_DATA` may not be
+  # correct.
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  # From Ruby 2.2, memsize_of(obj) returns a memory size includes sizeof(RVALUE).
+  #
+  def self.memsize_of: (untyped) -> Integer
+
+  # Return consuming memory size of all living objects in bytes.
+  #
+  # If `klass` (should be Class object) is given, return the total memory size of
+  # instances of the given class.
+  #
+  # Note that the returned size is incomplete. You need to deal with this
+  # information as only a **HINT**. Especially, the size of `T_DATA` may not be
+  # correct.
+  #
+  # Note that this method does **NOT** return total malloc'ed memory size.
+  #
+  # This method can be defined by the following Ruby code:
+  #
+  #     def memsize_of_all klass = false
+  #       total = 0
+  #       ObjectSpace.each_object{|e|
+  #         total += ObjectSpace.memsize_of(e) if klass == false || e.kind_of?(klass)
+  #       }
+  #       total
+  #     end
+  #
+  # This method is only expected to work with C Ruby.
+  #
+  def self.memsize_of_all: (?Class) -> Integer
+
+  # MRI specific feature
+  # :   Return all reachable objects from `obj'.
+  #
+  #
+  # This method returns all reachable objects from `obj'.
+  #
+  # If `obj' has two or more references to the same object `x', then returned
+  # array only includes one `x' object.
+  #
+  # If `obj' is a non-markable (non-heap management) object such as true, false,
+  # nil, symbols and Fixnums (and Flonum) then it simply returns nil.
+  #
+  # If `obj' has references to an internal object, then it returns instances of
+  # ObjectSpace::InternalObjectWrapper class. This object contains a reference to
+  # an internal object and you can check the type of internal object with `type'
+  # method.
+  #
+  # If `obj' is instance of ObjectSpace::InternalObjectWrapper class, then this
+  # method returns all reachable object from an internal object, which is pointed
+  # by `obj'.
+  #
+  # With this method, you can find memory leaks.
+  #
+  # This method is only expected to work except with C Ruby.
+  #
+  # Example:
+  #     ObjectSpace.reachable_objects_from(['a', 'b', 'c'])
+  #     #=> [Array, 'a', 'b', 'c']
+  #
+  #     ObjectSpace.reachable_objects_from(['a', 'a', 'a'])
+  #     #=> [Array, 'a', 'a', 'a'] # all 'a' strings have different object id
+  #
+  #     ObjectSpace.reachable_objects_from([v = 'a', v, v])
+  #     #=> [Array, 'a']
+  #
+  #     ObjectSpace.reachable_objects_from(1)
+  #     #=> nil # 1 is not markable (heap managed) object
+  #
+  def self.reachable_objects_from: (untyped) -> ([ untyped ] | nil)
+
+  # MRI specific feature
+  # :   Return all reachable objects from root.
+  #
+  #
+  def self.reachable_objects_from_root: () -> Hash[String, untyped]
+
+  # Starts tracing object allocations from the ObjectSpace extension module.
+  #
+  # For example:
+  #
+  #     require 'objspace'
+  #
+  #     class C
+  #       include ObjectSpace
+  #
+  #       def foo
+  #         trace_object_allocations do
+  #           obj = Object.new
+  #           p "#{allocation_sourcefile(obj)}:#{allocation_sourceline(obj)}"
+  #         end
+  #       end
+  #     end
+  #
+  #     C.new.foo #=> "objtrace.rb:8"
+  #
+  # This example has included the ObjectSpace module to make it easier to read,
+  # but you can also use the ::trace_object_allocations notation (recommended).
+  #
+  # Note that this feature introduces a huge performance decrease and huge memory
+  # consumption.
+  #
+  def self.trace_object_allocations: () { (untyped) -> untyped } -> untyped
+
+  # Clear recorded tracing information.
+  #
+  def self.trace_object_allocations_clear: () -> void
+
+  def self.trace_object_allocations_debug_start: () -> void
+
+  # Starts tracing object allocations.
+  #
+  def self.trace_object_allocations_start: () -> void
+
+  # Stop tracing object allocations.
+  #
+  # Note that if ::trace_object_allocations_start is called n-times, then tracing
+  # will stop after calling ::trace_object_allocations_stop n-times.
+  #
+  def self.trace_object_allocations_stop: () -> void
+
+  private
+
+  # Dump the contents of a ruby object as JSON.
+  #
+  # This method is only expected to work with C Ruby. This is an experimental
+  # method and is subject to change. In particular, the function signature and
+  # output format are not guaranteed to be compatible in future versions of ruby.
+  #
+  def dump: (untyped obj, ?output: Symbol) -> (String|File|nil)
+
+  # Dump the contents of the ruby heap as JSON.
+  #
+  # *since* must be a non-negative integer or `nil`.
+  #
+  # If *since* is a positive integer, only objects of that generation and newer
+  # generations are dumped. The current generation can be accessed using
+  # GC::count.
+  #
+  # Objects that were allocated without object allocation tracing enabled are
+  # ignored. See ::trace_object_allocations for more information and examples.
+  #
+  # If *since* is omitted or is `nil`, all objects are dumped.
+  #
+  # This method is only expected to work with C Ruby. This is an experimental
+  # method and is subject to change. In particular, the function signature and
+  # output format are not guaranteed to be compatible in future versions of ruby.
+  #
+  def dump_all: (?since: (Integer|nil), ?full: boolish, ?output: Symbol) -> (String|File|nil)
+
+  def memsize_of: (untyped) -> Integer
+
+  def memsize_of_all: (?class) -> Integer
+
+  def reachable_objects_from: (untyped) -> ([ untyped ] | nil)
+
+  def reachable_objects_from_root: () -> Hash[String, untyped]
+
+  def trace_object_allocations_clear: () -> void
+
+  def trace_object_allocations_debug_start: () -> void
+
+  def trace_object_allocations_start: () -> void
+
+  def trace_object_allocations_stop: () -> void
+end