steep 0.16.0 → 0.17.1

data/vendor/ruby-signature/stdlib/builtin/method.rbs

@@ -1,185 +0,0 @@
-class Method < Object
-  # Returns a `Proc` object corresponding to this method.
-  def to_proc: () -> Proc
-
-  # Invokes the *meth* with the specified arguments, returning the method’s
-  # return value.
-  # 
-  # ```ruby
-  # m = 12.method("+")
-  # m.call(3)    #=> 15
-  # m.call(20)   #=> 32
-  # ```
-  def call: (*untyped args) -> untyped
-
-  # Returns a proc that is the composition of this method and the given *g*
-  # . The returned proc takes a variable number of arguments, calls *g* with
-  # them then calls this method with the result.
-  # 
-  # ```ruby
-  # def f(x)
-  #   x * x
-  # end
-  # 
-  # f = self.method(:f)
-  # g = proc {|x| x + x }
-  # p (f << g).call(2) #=> 16
-  # ```
-  def <<: (Proc g) -> Proc
-
-  # Invokes the method with `obj` as the parameter like
-  # [call](Method.downloaded.ruby_doc#method-i-call). This allows a method
-  # object to be the target of a `when` clause in a case statement.
-  # 
-  # ```ruby
-  # require 'prime'
-  # 
-  # case 1373
-  # when Prime.method(:prime?)
-  #   # ...
-  # end
-  # ```
-  alias === call
-
-  # Returns a proc that is the composition of this method and the given *g*
-  # . The returned proc takes a variable number of arguments, calls *g* with
-  # them then calls this method with the result.
-  # 
-  # ```ruby
-  # def f(x)
-  #   x * x
-  # end
-  # 
-  # f = self.method(:f)
-  # g = proc {|x| x + x }
-  # p (f >> g).call(2) #=> 8
-  # ```
-  def >>: (Proc g) -> Proc
-
-  # Invokes the *meth* with the specified arguments, returning the method’s
-  # return value.
-  # 
-  # ```ruby
-  # m = 12.method("+")
-  # m.call(3)    #=> 15
-  # m.call(20)   #=> 32
-  # ```
-  alias [] call
-
-  # Returns an indication of the number of arguments accepted by a method.
-  # Returns a nonnegative integer for methods that take a fixed number of
-  # arguments. For Ruby methods that take a variable number of arguments,
-  # returns -n-1, where n is the number of required arguments. Keyword
-  # arguments will be considered as a single additional argument, that
-  # argument being mandatory if any keyword argument is mandatory. For
-  # methods written in C, returns -1 if the call takes a variable number of
-  # arguments.
-  # 
-  #     class C
-  #       def one;    end
-  #       def two(a); end
-  #       def three(*a);  end
-  #       def four(a, b); end
-  #       def five(a, b, *c);    end
-  #       def six(a, b, *c, &d); end
-  #       def seven(a, b, x:0); end
-  #       def eight(x:, y:); end
-  #       def nine(x:, y:, **z); end
-  #       def ten(*a, x:, y:); end
-  #     end
-  #     c = C.new
-  #     c.method(:one).arity     #=> 0
-  #     c.method(:two).arity     #=> 1
-  #     c.method(:three).arity   #=> -1
-  #     c.method(:four).arity    #=> 2
-  #     c.method(:five).arity    #=> -3
-  #     c.method(:six).arity     #=> -3
-  #     c.method(:seven).arity   #=> -3
-  #     c.method(:eight).arity   #=> 1
-  #     c.method(:nine).arity    #=> 1
-  #     c.method(:ten).arity     #=> -2
-  # 
-  #     "cat".method(:size).arity      #=> 0
-  #     "cat".method(:replace).arity   #=> 1
-  #     "cat".method(:squeeze).arity   #=> -1
-  #     "cat".method(:count).arity     #=> -1
-  def arity: () -> Integer
-
-  # Returns a clone of this method.
-  # 
-  # ```ruby
-  # class A
-  #   def foo
-  #     return "bar"
-  #   end
-  # end
-  # 
-  # m = A.new.method(:foo)
-  # m.call # => "bar"
-  # n = m.clone.call # => "bar"
-  # ```
-  def clone: () -> Method
-
-  def curry: (?Integer arity) -> Proc
-
-  # Returns the name of the method.
-  def name: () -> Symbol
-
-  # Returns the original name of the method.
-  # 
-  # ```ruby
-  # class C
-  #   def foo; end
-  #   alias bar foo
-  # end
-  # C.instance_method(:bar).original_name # => :foo
-  # ```
-  def original_name: () -> Symbol
-
-  # Returns the class or module that defines the method. See also receiver.
-  # 
-  # ```ruby
-  # (1..3).method(:map).owner #=> Enumerable
-  # ```
-  def owner: () -> (Class | Module)
-
-  # Returns the parameter information of this method.
-  # 
-  # ```ruby
-  # def foo(bar); end
-  # method(:foo).parameters #=> [[:req, :bar]]
-  # 
-  # def foo(bar, baz, bat, &blk); end
-  # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:req, :bat], [:block, :blk]]
-  # 
-  # def foo(bar, *args); end
-  # method(:foo).parameters #=> [[:req, :bar], [:rest, :args]]
-  # 
-  # def foo(bar, baz, *args, &blk); end
-  # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:rest, :args], [:block, :blk]]
-  # ```
-  def parameters: () -> ::Array[
-    [:req | :opt | :rest | :keyreq | :key | :keyrest | :block, Symbol] |
-    [:rest | :keyrest]
-  ]
-
-  # Returns the bound receiver of the method object.
-  # 
-  # ```ruby
-  # (1..3).method(:map).receiver # => 1..3
-  # ```
-  def receiver: () -> untyped
-
-  # Returns the Ruby source filename and line number containing this method
-  # or nil if this method was not defined in Ruby (i.e. native).
-  def source_location: () -> [String, Integer]?
-
-  # Returns a [Method](Method.downloaded.ruby_doc) of superclass which would
-  # be called when super is used or nil if there is no method on superclass.
-  def super_method: () -> Method?
-
-  # Dissociates *meth* from its current receiver. The resulting
-  # `UnboundMethod` can subsequently be bound to a new object of the same
-  # class (see `UnboundMethod` ).
-  def unbind: () -> UnboundMethod
-end

data/vendor/ruby-signature/stdlib/builtin/module.rbs

@@ -1,1104 +0,0 @@
-# A Module is a collection of methods and constants. The methods in a module may
-# be instance methods or module methods. Instance methods appear as methods in a
-# class when the module is included, module methods do not. Conversely, module
-# methods may be called without creating an encapsulating object, while instance
-# methods may not. (See Module#module_function.)
-#
-# In the descriptions that follow, the parameter *sym* refers to a symbol, which
-# is either a quoted string or a Symbol (such as `:name`).
-#
-#     module Mod
-#       include Math
-#       CONST = 1
-#       def meth
-#         #  ...
-#       end
-#     end
-#     Mod.class              #=> Module
-#     Mod.constants          #=> [:CONST, :PI, :E]
-#     Mod.instance_methods   #=> [:meth]
-#
-class Module < Object
-  # In the first form, returns an array of the names of all constants accessible
-  # from the point of call. This list includes the names of all modules and
-  # classes defined in the global scope.
-  #
-  #     Module.constants.first(4)
-  #        # => [:ARGF, :ARGV, :ArgumentError, :Array]
-  #
-  #     Module.constants.include?(:SEEK_SET)   # => false
-  #
-  #     class IO
-  #       Module.constants.include?(:SEEK_SET) # => true
-  #     end
-  #
-  # The second form calls the instance method `constants`.
-  #
-  def self.constants: () -> ::Array[Integer]
-
-  # Returns the list of `Modules` nested at the point of call.
-  #
-  #     module M1
-  #       module M2
-  #         $a = Module.nesting
-  #       end
-  #     end
-  #     $a           #=> [M1::M2, M1]
-  #     $a[0].name   #=> "M1::M2"
-  #
-  def self.nesting: () -> ::Array[Module]
-
-  # Returns an array of all modules used in the current scope. The ordering of
-  # modules in the resulting array is not defined.
-  #
-  #     module A
-  #       refine Object do
-  #       end
-  #     end
-  #
-  #     module B
-  #       refine Object do
-  #       end
-  #     end
-  #
-  #     using A
-  #     using B
-  #     p Module.used_modules
-  #
-  # *produces:*
-  #
-  #     [B, A]
-  #
-  def self.used_modules: () -> ::Array[Module]
-
-  # Returns true if *mod* is a subclass of *other*. Returns `nil` if there's no
-  # relationship between the two. (Think of the relationship in terms of the class
-  # definition: "class A < B" implies "A < B".)
-  #
-  def <: (Module other) -> bool?
-
-  # Returns true if *mod* is a subclass of *other* or is the same as *other*.
-  # Returns `nil` if there's no relationship between the two. (Think of the
-  # relationship in terms of the class definition: "class A < B" implies "A < B".)
-  #
-  def <=: (Module other) -> bool?
-
-  # Comparison---Returns -1, 0, +1 or nil depending on whether `module` includes
-  # `other_module`, they are the same, or if `module` is included by
-  # `other_module`.
-  #
-  # Returns `nil` if `module` has no relationship with `other_module`, if
-  # `other_module` is not a module, or if the two values are incomparable.
-  #
-  def <=>: (Module other) -> Integer?
-
-  # Equality --- At the Object level, #== returns `true` only if `obj` and `other`
-  # are the same object.  Typically, this method is overridden in descendant
-  # classes to provide class-specific meaning.
-  #
-  # Unlike #==, the #equal? method should never be overridden by subclasses as it
-  # is used to determine object identity (that is, `a.equal?(b)` if and only if
-  # `a` is the same object as `b`):
-  #
-  #     obj = "a"
-  #     other = obj.dup
-  #
-  #     obj == other      #=> true
-  #     obj.equal? other  #=> false
-  #     obj.equal? obj    #=> true
-  #
-  # The #eql? method returns `true` if `obj` and `other` refer to the same hash
-  # key.  This is used by Hash to test members for equality.  For any pair of
-  # objects where #eql? returns `true`, the #hash value of both objects must be
-  # equal. So any subclass that overrides #eql? should also override #hash
-  # appropriately.
-  #
-  # For objects of class Object, #eql?  is synonymous with #==.  Subclasses
-  # normally continue this tradition by aliasing #eql? to their overridden #==
-  # method, but there are exceptions. Numeric types, for example, perform type
-  # conversion across #==, but not across #eql?, so:
-  #
-  #     1 == 1.0     #=> true
-  #     1.eql? 1.0   #=> false
-  #
-  def ==: (untyped other) -> bool
-
-  # Case Equality---Returns `true` if *obj* is an instance of *mod* or an instance
-  # of one of *mod*'s descendants. Of limited use for modules, but can be used in
-  # `case` statements to classify objects by class.
-  #
-  def ===: (untyped other) -> bool
-
-  # Returns true if *mod* is an ancestor of *other*. Returns `nil` if there's no
-  # relationship between the two. (Think of the relationship in terms of the class
-  # definition: "class A < B" implies "B > A".)
-  #
-  def >: (Module other) -> bool?
-
-  # Returns true if *mod* is an ancestor of *other*, or the two modules are the
-  # same. Returns `nil` if there's no relationship between the two. (Think of the
-  # relationship in terms of the class definition: "class A < B" implies "B > A".)
-  #
-  def >=: (Module other) -> bool?
-
-  # Makes *new_name* a new copy of the method *old_name*. This can be used to
-  # retain access to methods that are overridden.
-  #
-  #     module Mod
-  #       alias_method :orig_exit, :exit
-  #       def exit(code=0)
-  #         puts "Exiting with code #{code}"
-  #         orig_exit(code)
-  #       end
-  #     end
-  #     include Mod
-  #     exit(99)
-  #
-  # *produces:*
-  #
-  #     Exiting with code 99
-  #
-  def alias_method: (Symbol new_name, Symbol old_name) -> self
-
-  # Returns a list of modules included/prepended in *mod* (including *mod*
-  # itself).
-  #
-  #     module Mod
-  #       include Math
-  #       include Comparable
-  #       prepend Enumerable
-  #     end
-  #
-  #     Mod.ancestors        #=> [Enumerable, Mod, Comparable, Math]
-  #     Math.ancestors       #=> [Math]
-  #     Enumerable.ancestors #=> [Enumerable]
-  #
-  def ancestors: () -> ::Array[Module]
-
-  # When this module is included in another, Ruby calls #append_features in this
-  # module, passing it the receiving module in *mod*. Ruby's default
-  # implementation is to add the constants, methods, and module variables of this
-  # module to *mod* if this module has not already been added to *mod* or one of
-  # its ancestors. See also Module#include.
-  #
-  def append_features: (Module arg0) -> self
-
-  # Defines a named attribute for this module, where the name is
-  # *symbol.*`id2name`, creating an instance variable (`@name`) and a
-  # corresponding access method to read it. Also creates a method called `name=`
-  # to set the attribute. String arguments are converted to symbols.
-  #
-  #     module Mod
-  #       attr_accessor(:one, :two)
-  #     end
-  #     Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]
-  #
-  def `attr_accessor`: (*Symbol | String arg0) -> NilClass
-
-  # Creates instance variables and corresponding methods that return the value of
-  # each instance variable. Equivalent to calling ```attr`*:name*'' on each name
-  # in turn. String arguments are converted to symbols.
-  #
-  def `attr_reader`: (*Symbol | String arg0) -> NilClass
-
-  # Creates an accessor method to allow assignment to the attribute
-  # *symbol*`.id2name`. String arguments are converted to symbols.
-  #
-  def `attr_writer`: (*Symbol | String arg0) -> NilClass
-
-  # Registers *filename* to be loaded (using Kernel::require) the first time that
-  # *module* (which may be a String or a symbol) is accessed in the namespace of
-  # *mod*.
-  #
-  #     module A
-  #     end
-  #     A.autoload(:B, "b")
-  #     A::B.doit            # autoloads "b"
-  #
-  def autoload: (Symbol _module, String filename) -> NilClass
-
-  # Returns *filename* to be loaded if *name* is registered as `autoload` in the
-  # namespace of *mod* or one of its ancestors.
-  #
-  #     module A
-  #     end
-  #     A.autoload(:B, "b")
-  #     A.autoload?(:B)            #=> "b"
-  #
-  # If `inherit` is false, the lookup only checks the autoloads in the receiver:
-  #
-  #     class A
-  #       autoload :CONST, "const.rb"
-  #     end
-  #
-  #     class B < A
-  #     end
-  #
-  #     B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
-  #     B.autoload?(:CONST, false)   #=> nil, not found in B itself
-  #
-  def autoload?: (Symbol name, ?bool inherit) -> String?
-
-  # Evaluates the string or block in the context of *mod*, except that when a
-  # block is given, constant/class variable lookup is not affected. This can be
-  # used to add methods to a class. `module_eval` returns the result of evaluating
-  # its argument. The optional *filename* and *lineno* parameters set the text for
-  # error messages.
-  #
-  #     class Thing
-  #     end
-  #     a = %q{def hello() "Hello there!" end}
-  #     Thing.module_eval(a)
-  #     puts Thing.new.hello()
-  #     Thing.module_eval("invalid code", "dummy", 123)
-  #
-  # *produces:*
-  #
-  #     Hello there!
-  #     dummy:123:in `module_eval': undefined local variable
-  #         or method `code' for Thing:Class
-  #
-  def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                | [U] (untyped arg0) { (untyped m) -> U } -> U
-
-  # Evaluates the given block in the context of the class/module. The method
-  # defined in the block will belong to the receiver. Any arguments passed to the
-  # method will be passed to the block. This can be used if the block needs to
-  # access instance variables.
-  #
-  #     class Thing
-  #     end
-  #     Thing.class_exec{
-  #       def hello() "Hello there!" end
-  #     }
-  #     puts Thing.new.hello()
-  #
-  # *produces:*
-  #
-  #     Hello there!
-  #
-  def class_exec: (*untyped args) { () -> untyped } -> untyped
-
-  # Returns `true` if the given class variable is defined in *obj*. String
-  # arguments are converted to symbols.
-  #
-  #     class Fred
-  #       @@foo = 99
-  #     end
-  #     Fred.class_variable_defined?(:@@foo)    #=> true
-  #     Fred.class_variable_defined?(:@@bar)    #=> false
-  #
-  def class_variable_defined?: (Symbol | String arg0) -> bool
-
-  # Returns the value of the given class variable (or throws a NameError
-  # exception). The `@@` part of the variable name should be included for regular
-  # class variables. String arguments are converted to symbols.
-  #
-  #     class Fred
-  #       @@foo = 99
-  #     end
-  #     Fred.class_variable_get(:@@foo)     #=> 99
-  #
-  def class_variable_get: (Symbol | String arg0) -> untyped
-
-  # Sets the class variable named by *symbol* to the given object. If the class
-  # variable name is passed as a string, that string is converted to a symbol.
-  #
-  #     class Fred
-  #       @@foo = 99
-  #       def foo
-  #         @@foo
-  #       end
-  #     end
-  #     Fred.class_variable_set(:@@foo, 101)     #=> 101
-  #     Fred.new.foo                             #=> 101
-  #
-  def class_variable_set: (Symbol | String arg0, untyped arg1) -> untyped
-
-  # Returns an array of the names of class variables in *mod*. This includes the
-  # names of class variables in any included modules, unless the *inherit*
-  # parameter is set to `false`.
-  #
-  #     class One
-  #       @@var1 = 1
-  #     end
-  #     class Two < One
-  #       @@var2 = 2
-  #     end
-  #     One.class_variables          #=> [:@@var1]
-  #     Two.class_variables          #=> [:@@var2, :@@var1]
-  #     Two.class_variables(false)   #=> [:@@var2]
-  #
-  def class_variables: (?bool inherit) -> ::Array[Symbol]
-
-  # Says whether *mod* or its ancestors have a constant with the given name:
-  #
-  #     Float.const_defined?(:EPSILON)      #=> true, found in Float itself
-  #     Float.const_defined?("String")      #=> true, found in Object (ancestor)
-  #     BasicObject.const_defined?(:Hash)   #=> false
-  #
-  # If *mod* is a `Module`, additionally `Object` and its ancestors are checked:
-  #
-  #     Math.const_defined?(:String)   #=> true, found in Object
-  #
-  # In each of the checked classes or modules, if the constant is not present but
-  # there is an autoload for it, `true` is returned directly without autoloading:
-  #
-  #     module Admin
-  #       autoload :User, 'admin/user'
-  #     end
-  #     Admin.const_defined?(:User)   #=> true
-  #
-  # If the constant is not found the callback `const_missing` is **not** called
-  # and the method returns `false`.
-  #
-  # If `inherit` is false, the lookup only checks the constants in the receiver:
-  #
-  #     IO.const_defined?(:SYNC)          #=> true, found in File::Constants (ancestor)
-  #     IO.const_defined?(:SYNC, false)   #=> false, not found in IO itself
-  #
-  # In this case, the same logic for autoloading applies.
-  #
-  # If the argument is not a valid constant name a `NameError` is raised with the
-  # message "wrong constant name *name*":
-  #
-  #     Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar
-  #
-  def const_defined?: (Symbol | String arg0, ?bool inherit) -> bool
-
-  # Checks for a constant with the given name in *mod*. If `inherit` is set, the
-  # lookup will also search the ancestors (and `Object` if *mod* is a `Module`).
-  #
-  # The value of the constant is returned if a definition is found, otherwise a
-  # `NameError` is raised.
-  #
-  #     Math.const_get(:PI)   #=> 3.14159265358979
-  #
-  # This method will recursively look up constant names if a namespaced class name
-  # is provided.  For example:
-  #
-  #     module Foo; class Bar; end end
-  #     Object.const_get 'Foo::Bar'
-  #
-  # The `inherit` flag is respected on each lookup.  For example:
-  #
-  #     module Foo
-  #       class Bar
-  #         VAL = 10
-  #       end
-  #
-  #       class Baz < Bar; end
-  #     end
-  #
-  #     Object.const_get 'Foo::Baz::VAL'         # => 10
-  #     Object.const_get 'Foo::Baz::VAL', false  # => NameError
-  #
-  # If the argument is not a valid constant name a `NameError` will be raised with
-  # a warning "wrong constant name".
-  #
-  #     Object.const_get 'foobar' #=> NameError: wrong constant name foobar
-  #
-  def const_get: (Symbol | String arg0, ?bool inherit) -> untyped
-
-  # Invoked when a reference is made to an undefined constant in *mod*. It is
-  # passed a symbol for the undefined constant, and returns a value to be used for
-  # that constant. The following code is an example of the same:
-  #
-  #     def Foo.const_missing(name)
-  #       name # return the constant name as Symbol
-  #     end
-  #
-  #     Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST: symbol returned
-  #
-  # In the next example when a reference is made to an undefined constant, it
-  # attempts to load a file whose name is the lowercase version of the constant
-  # (thus class `Fred` is assumed to be in file `fred.rb`).  If found, it returns
-  # the loaded class. It therefore implements an autoload feature similar to
-  # Kernel#autoload and Module#autoload.
-  #
-  #     def Object.const_missing(name)
-  #       @looked_for ||= {}
-  #       str_name = name.to_s
-  #       raise "Class not found: #{name}" if @looked_for[str_name]
-  #       @looked_for[str_name] = 1
-  #       file = str_name.downcase
-  #       require file
-  #       klass = const_get(name)
-  #       return klass if klass
-  #       raise "Class not found: #{name}"
-  #     end
-  #
-  def const_missing: (Symbol arg0) -> untyped
-
-  # Sets the named constant to the given object, returning that object. Creates a
-  # new constant if no constant with the given name previously existed.
-  #
-  #     Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0)   #=> 3.14285714285714
-  #     Math::HIGH_SCHOOL_PI - Math::PI              #=> 0.00126448926734968
-  #
-  # If `sym` or `str` is not a valid constant name a `NameError` will be raised
-  # with a warning "wrong constant name".
-  #
-  #     Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar
-  #
-  def const_set: (Symbol | String arg0, untyped arg1) -> untyped
-
-  # Returns an array of the names of the constants accessible in *mod*. This
-  # includes the names of constants in any included modules (example at start of
-  # section), unless the *inherit* parameter is set to `false`.
-  #
-  # The implementation makes no guarantees about the order in which the constants
-  # are yielded.
-  #
-  #     IO.constants.include?(:SYNC)        #=> true
-  #     IO.constants(false).include?(:SYNC) #=> false
-  #
-  # Also see Module#const_defined?.
-  #
-  def constants: (?bool inherit) -> ::Array[Symbol]
-
-  # Defines an instance method in the receiver. The *method* parameter can be a
-  # `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it
-  # is used as the method body. If a block or the *method* parameter has
-  # parameters, they're used as method parameters. This block is evaluated using
-  # #instance_eval.
-  #
-  #     class A
-  #       def fred
-  #         puts "In Fred"
-  #       end
-  #       def create_method(name, &block)
-  #         self.class.define_method(name, &block)
-  #       end
-  #       define_method(:wilma) { puts "Charge it!" }
-  #       define_method(:flint) {|name| puts "I'm #{name}!"}
-  #     end
-  #     class B < A
-  #       define_method(:barney, instance_method(:fred))
-  #     end
-  #     a = B.new
-  #     a.barney
-  #     a.wilma
-  #     a.flint('Dino')
-  #     a.create_method(:betty) { p self }
-  #     a.betty
-  #
-  # *produces:*
-  #
-  #     In Fred
-  #     Charge it!
-  #     I'm Dino!
-  #     #<B:0x401b39e8>
-  #
-  def define_method: (Symbol | String arg0, ?Proc | Method | UnboundMethod arg1) -> Symbol
-                   | (Symbol | String arg0) { () -> untyped } -> Symbol
-
-  def eql?: (untyped other) -> bool
-
-  def equal?: (untyped other) -> bool
-
-  # Extends the specified object by adding this module's constants and methods
-  # (which are added as singleton methods). This is the callback method used by
-  # Object#extend.
-  #
-  #     module Picky
-  #       def Picky.extend_object(o)
-  #         if String === o
-  #           puts "Can't add Picky to a String"
-  #         else
-  #           puts "Picky added to #{o.class}"
-  #           super
-  #         end
-  #       end
-  #     end
-  #     (s = Array.new).extend Picky  # Call Object.extend
-  #     (s = "quick brown fox").extend Picky
-  #
-  # *produces:*
-  #
-  #     Picky added to Array
-  #     Can't add Picky to a String
-  #
-  def extend_object: (untyped arg0) -> untyped
-
-  # The equivalent of `included`, but for extended modules.
-  #
-  #     module A
-  #       def self.extended(mod)
-  #         puts "#{self} extended in #{mod}"
-  #       end
-  #     end
-  #     module Enumerable
-  #       extend A
-  #     end
-  #      # => prints "A extended in Enumerable"
-  #
-  def extended: (Module othermod) -> untyped
-
-  # Prevents further modifications to *mod*.
-  #
-  # This method returns self.
-  #
-  def freeze: () -> self
-
-  # Invokes Module.append_features on each parameter in reverse order.
-  #
-  def `include`: (*Module arg0) -> self
-
-  # Returns `true` if *module* is included in *mod* or one of *mod*'s ancestors.
-  #
-  #     module A
-  #     end
-  #     class B
-  #       include A
-  #     end
-  #     class C < B
-  #     end
-  #     B.include?(A)   #=> true
-  #     C.include?(A)   #=> true
-  #     A.include?(A)   #=> false
-  #
-  def include?: (Module arg0) -> bool
-
-  # Callback invoked whenever the receiver is included in another module or class.
-  # This should be used in preference to `Module.append_features` if your code
-  # wants to perform some action when a module is included in another.
-  #
-  #     module A
-  #       def A.included(mod)
-  #         puts "#{self} included in #{mod}"
-  #       end
-  #     end
-  #     module Enumerable
-  #       include A
-  #     end
-  #      # => prints "A included in Enumerable"
-  #
-  def included: (Module othermod) -> untyped
-
-  # Returns the list of modules included in *mod*.
-  #
-  #     module Mixin
-  #     end
-  #
-  #     module Outer
-  #       include Mixin
-  #     end
-  #
-  #     Mixin.included_modules   #=> []
-  #     Outer.included_modules   #=> [Mixin]
-  #
-  def included_modules: () -> ::Array[Module]
-
-  # Creates a new anonymous module. If a block is given, it is passed the module
-  # object, and the block is evaluated in the context of this module like
-  # #module_eval.
-  #
-  #     fred = Module.new do
-  #       def meth1
-  #         "hello"
-  #       end
-  #       def meth2
-  #         "bye"
-  #       end
-  #     end
-  #     a = "my string"
-  #     a.extend(fred)   #=> "my string"
-  #     a.meth1          #=> "hello"
-  #     a.meth2          #=> "bye"
-  #
-  # Assign the module to a constant (name starting uppercase) if you want to treat
-  # it like a regular module.
-  #
-  def initialize: () -> Object
-                | () { (Module arg0) -> untyped } -> void
-
-  # Returns an `UnboundMethod` representing the given instance method in *mod*.
-  #
-  #     class Interpreter
-  #       def do_a() print "there, "; end
-  #       def do_d() print "Hello ";  end
-  #       def do_e() print "!\n";     end
-  #       def do_v() print "Dave";    end
-  #       Dispatcher = {
-  #         "a" => instance_method(:do_a),
-  #         "d" => instance_method(:do_d),
-  #         "e" => instance_method(:do_e),
-  #         "v" => instance_method(:do_v)
-  #       }
-  #       def interpret(string)
-  #         string.each_char {|b| Dispatcher[b].bind(self).call }
-  #       end
-  #     end
-  #
-  #     interpreter = Interpreter.new
-  #     interpreter.interpret('dave')
-  #
-  # *produces:*
-  #
-  #     Hello there, Dave!
-  #
-  def instance_method: (Symbol arg0) -> UnboundMethod
-
-  # Returns an array containing the names of the public and protected instance
-  # methods in the receiver. For a module, these are the public and protected
-  # methods; for a class, they are the instance (not singleton) methods. If the
-  # optional parameter is `false`, the methods of any ancestors are not included.
-  #
-  #     module A
-  #       def method1()  end
-  #     end
-  #     class B
-  #       include A
-  #       def method2()  end
-  #     end
-  #     class C < B
-  #       def method3()  end
-  #     end
-  #
-  #     A.instance_methods(false)                   #=> [:method1]
-  #     B.instance_methods(false)                   #=> [:method2]
-  #     B.instance_methods(true).include?(:method1) #=> true
-  #     C.instance_methods(false)                   #=> [:method3]
-  #     C.instance_methods.include?(:method2)       #=> true
-  #
-  def instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  # Invoked as a callback whenever an instance method is added to the receiver.
-  #
-  #     module Chatty
-  #       def self.method_added(method_name)
-  #         puts "Adding #{method_name.inspect}"
-  #       end
-  #       def self.some_class_method() end
-  #       def some_instance_method() end
-  #     end
-  #
-  # *produces:*
-  #
-  #     Adding :some_instance_method
-  #
-  def method_added: (Symbol meth) -> untyped
-
-  # Returns `true` if the named method is defined by *mod*.  If *inherit* is set,
-  # the lookup will also search *mod*'s ancestors. Public and protected methods
-  # are matched. String arguments are converted to symbols.
-  #
-  #     module A
-  #       def method1()  end
-  #       def protected_method1()  end
-  #       protected :protected_method1
-  #     end
-  #     class B
-  #       def method2()  end
-  #       def private_method2()  end
-  #       private :private_method2
-  #     end
-  #     class C < B
-  #       include A
-  #       def method3()  end
-  #     end
-  #
-  #     A.method_defined? :method1              #=> true
-  #     C.method_defined? "method1"             #=> true
-  #     C.method_defined? "method2"             #=> true
-  #     C.method_defined? "method2", true       #=> true
-  #     C.method_defined? "method2", false      #=> false
-  #     C.method_defined? "method3"             #=> true
-  #     C.method_defined? "protected_method1"   #=> true
-  #     C.method_defined? "method4"             #=> false
-  #     C.method_defined? "private_method2"     #=> false
-  #
-  def method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
-
-  # Invoked as a callback whenever an instance method is removed from the
-  # receiver.
-  #
-  #     module Chatty
-  #       def self.method_removed(method_name)
-  #         puts "Removing #{method_name.inspect}"
-  #       end
-  #       def self.some_class_method() end
-  #       def some_instance_method() end
-  #       class << self
-  #         remove_method :some_class_method
-  #       end
-  #       remove_method :some_instance_method
-  #     end
-  #
-  # *produces:*
-  #
-  #     Removing :some_instance_method
-  #
-  def method_removed: (Symbol method_name) -> untyped
-
-  # Evaluates the string or block in the context of *mod*, except that when a
-  # block is given, constant/class variable lookup is not affected. This can be
-  # used to add methods to a class. `module_eval` returns the result of evaluating
-  # its argument. The optional *filename* and *lineno* parameters set the text for
-  # error messages.
-  #
-  #     class Thing
-  #     end
-  #     a = %q{def hello() "Hello there!" end}
-  #     Thing.module_eval(a)
-  #     puts Thing.new.hello()
-  #     Thing.module_eval("invalid code", "dummy", 123)
-  #
-  # *produces:*
-  #
-  #     Hello there!
-  #     dummy:123:in `module_eval': undefined local variable
-  #         or method `code' for Thing:Class
-  #
-  def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                 | [U] (untyped arg0) { (untyped m) -> U } -> U
-
-  # Evaluates the given block in the context of the class/module. The method
-  # defined in the block will belong to the receiver. Any arguments passed to the
-  # method will be passed to the block. This can be used if the block needs to
-  # access instance variables.
-  #
-  #     class Thing
-  #     end
-  #     Thing.class_exec{
-  #       def hello() "Hello there!" end
-  #     }
-  #     puts Thing.new.hello()
-  #
-  # *produces:*
-  #
-  #     Hello there!
-  #
-  def module_exec: (*untyped args) { () -> untyped } -> untyped
-
-  # Creates module functions for the named methods. These functions may be called
-  # with the module as a receiver, and also become available as instance methods
-  # to classes that mix in the module. Module functions are copies of the
-  # original, and so may be changed independently. The instance-method versions
-  # are made private. If used with no arguments, subsequently defined methods
-  # become module functions. String arguments are converted to symbols.
-  #
-  #     module Mod
-  #       def one
-  #         "This is one"
-  #       end
-  #       module_function :one
-  #     end
-  #     class Cls
-  #       include Mod
-  #       def call_one
-  #         one
-  #       end
-  #     end
-  #     Mod.one     #=> "This is one"
-  #     c = Cls.new
-  #     c.call_one  #=> "This is one"
-  #     module Mod
-  #       def one
-  #         "This is the new one"
-  #       end
-  #     end
-  #     Mod.one     #=> "This is one"
-  #     c.call_one  #=> "This is the new one"
-  #
-  def module_function: (*Symbol | String arg0) -> self
-
-  # Returns the name of the module *mod*.  Returns nil for anonymous modules.
-  #
-  def name: () -> String?
-
-  # Invokes Module.prepend_features on each parameter in reverse order.
-  #
-  def `prepend`: (*Module arg0) -> self
-
-  # When this module is prepended in another, Ruby calls #prepend_features in this
-  # module, passing it the receiving module in *mod*. Ruby's default
-  # implementation is to overlay the constants, methods, and module variables of
-  # this module to *mod* if this module has not already been added to *mod* or one
-  # of its ancestors. See also Module#prepend.
-  #
-  def prepend_features: (Module arg0) -> self
-
-  # The equivalent of `included`, but for prepended modules.
-  #
-  #     module A
-  #       def self.prepended(mod)
-  #         puts "#{self} prepended to #{mod}"
-  #       end
-  #     end
-  #     module Enumerable
-  #       prepend A
-  #     end
-  #      # => prints "A prepended to Enumerable"
-  #
-  def prepended: (Module othermod) -> untyped
-
-  # With no arguments, sets the default visibility for subsequently defined
-  # methods to private. With arguments, sets the named methods to have private
-  # visibility. String arguments are converted to symbols.
-  #
-  #     module Mod
-  #       def a()  end
-  #       def b()  end
-  #       private
-  #       def c()  end
-  #       private :a
-  #     end
-  #     Mod.private_instance_methods   #=> [:a, :c]
-  #
-  # Note that to show a private method on RDoc, use `:doc:`.
-  #
-  def `private`: (*Symbol | String arg0) -> self
-
-  # Makes existing class methods private. Often used to hide the default
-  # constructor `new`.
-  #
-  # String arguments are converted to symbols.
-  #
-  #     class SimpleSingleton  # Not thread safe
-  #       private_class_method :new
-  #       def SimpleSingleton.create(*args, &block)
-  #         @me = new(*args, &block) if ! @me
-  #         @me
-  #       end
-  #     end
-  #
-  def private_class_method: (*Symbol | String arg0) -> self
-
-  # Makes a list of existing constants private.
-  #
-  def private_constant: (*Symbol arg0) -> self
-
-  # Returns a list of the private instance methods defined in *mod*. If the
-  # optional parameter is `false`, the methods of any ancestors are not included.
-  #
-  #     module Mod
-  #       def method1()  end
-  #       private :method1
-  #       def method2()  end
-  #     end
-  #     Mod.instance_methods           #=> [:method2]
-  #     Mod.private_instance_methods   #=> [:method1]
-  #
-  def private_instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  # Returns `true` if the named private method is defined by *mod*.  If *inherit*
-  # is set, the lookup will also search *mod*'s ancestors. String arguments are
-  # converted to symbols.
-  #
-  #     module A
-  #       def method1()  end
-  #     end
-  #     class B
-  #       private
-  #       def method2()  end
-  #     end
-  #     class C < B
-  #       include A
-  #       def method3()  end
-  #     end
-  #
-  #     A.method_defined? :method1                   #=> true
-  #     C.private_method_defined? "method1"          #=> false
-  #     C.private_method_defined? "method2"          #=> true
-  #     C.private_method_defined? "method2", true    #=> true
-  #     C.private_method_defined? "method2", false   #=> false
-  #     C.method_defined? "method2"                  #=> false
-  #
-  def private_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
-
-  # With no arguments, sets the default visibility for subsequently defined
-  # methods to protected. With arguments, sets the named methods to have protected
-  # visibility. String arguments are converted to symbols.
-  #
-  # If a method has protected visibility, it is callable only where `self` of the
-  # context is the same as the method. (method definition or instance_eval). This
-  # behavior is different from Java's protected method. Usually `private` should
-  # be used.
-  #
-  # Note that a protected method is slow because it can't use inline cache.
-  #
-  # To show a private method on RDoc, use `:doc:` instead of this.
-  #
-  def protected: (*Symbol | String arg0) -> self
-
-  # Returns a list of the protected instance methods defined in *mod*. If the
-  # optional parameter is `false`, the methods of any ancestors are not included.
-  #
-  def protected_instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  # Returns `true` if the named protected method is defined *mod*.  If *inherit*
-  # is set, the lookup will also search *mod*'s ancestors. String arguments are
-  # converted to symbols.
-  #
-  #     module A
-  #       def method1()  end
-  #     end
-  #     class B
-  #       protected
-  #       def method2()  end
-  #     end
-  #     class C < B
-  #       include A
-  #       def method3()  end
-  #     end
-  #
-  #     A.method_defined? :method1                    #=> true
-  #     C.protected_method_defined? "method1"         #=> false
-  #     C.protected_method_defined? "method2"         #=> true
-  #     C.protected_method_defined? "method2", true   #=> true
-  #     C.protected_method_defined? "method2", false  #=> false
-  #     C.method_defined? "method2"                   #=> true
-  #
-  def protected_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
-
-  # With no arguments, sets the default visibility for subsequently defined
-  # methods to public. With arguments, sets the named methods to have public
-  # visibility. String arguments are converted to symbols.
-  #
-  def `public`: (*Symbol | String arg0) -> self
-
-  # Makes a list of existing class methods public.
-  #
-  # String arguments are converted to symbols.
-  #
-  def public_class_method: (*Symbol | String arg0) -> self
-
-  # Makes a list of existing constants public.
-  #
-  def public_constant: (*Symbol arg0) -> self
-
-  # Similar to *instance_method*, searches public method only.
-  #
-  def public_instance_method: (Symbol arg0) -> UnboundMethod
-
-  # Returns a list of the public instance methods defined in *mod*. If the
-  # optional parameter is `false`, the methods of any ancestors are not included.
-  #
-  def public_instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  # Returns `true` if the named public method is defined by *mod*.  If *inherit*
-  # is set, the lookup will also search *mod*'s ancestors. String arguments are
-  # converted to symbols.
-  #
-  #     module A
-  #       def method1()  end
-  #     end
-  #     class B
-  #       protected
-  #       def method2()  end
-  #     end
-  #     class C < B
-  #       include A
-  #       def method3()  end
-  #     end
-  #
-  #     A.method_defined? :method1                 #=> true
-  #     C.public_method_defined? "method1"         #=> true
-  #     C.public_method_defined? "method1", true   #=> true
-  #     C.public_method_defined? "method1", false  #=> true
-  #     C.public_method_defined? "method2"         #=> false
-  #     C.method_defined? "method2"                #=> true
-  #
-  def public_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
-
-  # Refine *mod* in the receiver.
-  #
-  # Returns a module, where refined methods are defined.
-  #
-  def refine: (Class arg0) { (untyped arg0) -> untyped } -> self
-
-  # Removes the definition of the *sym*, returning that constant's value.
-  #
-  #     class Dummy
-  #       @@var = 99
-  #       puts @@var
-  #       remove_class_variable(:@@var)
-  #       p(defined? @@var)
-  #     end
-  #
-  # *produces:*
-  #
-  #     99
-  #     nil
-  #
-  def remove_class_variable: (Symbol arg0) -> untyped
-
-  # Removes the definition of the given constant, returning that constant's
-  # previous value.  If that constant referred to a module, this will not change
-  # that module's name and can lead to confusion.
-  #
-  def remove_const: (Symbol arg0) -> untyped
-
-  # Removes the method identified by *symbol* from the current class. For an
-  # example, see Module#undef_method. String arguments are converted to symbols.
-  #
-  def remove_method: (*Symbol | String arg0) -> self
-
-  # Returns `true` if *mod* is a singleton class or `false` if it is an ordinary
-  # class or module.
-  #
-  #     class C
-  #     end
-  #     C.singleton_class?                  #=> false
-  #     C.singleton_class.singleton_class?  #=> true
-  #
-  def singleton_class?: () -> bool
-
-  # Returns a string representing this module or class. For basic classes and
-  # modules, this is the name. For singletons, we show information on the thing
-  # we're attached to as well.
-  #
-  def to_s: () -> String
-
-  # Prevents the current class from responding to calls to the named method.
-  # Contrast this with `remove_method`, which deletes the method from the
-  # particular class; Ruby will still search superclasses and mixed-in modules for
-  # a possible receiver. String arguments are converted to symbols.
-  #
-  #     class Parent
-  #       def hello
-  #         puts "In parent"
-  #       end
-  #     end
-  #     class Child < Parent
-  #       def hello
-  #         puts "In child"
-  #       end
-  #     end
-  #
-  #     c = Child.new
-  #     c.hello
-  #
-  #     class Child
-  #       remove_method :hello  # remove from child, still in parent
-  #     end
-  #     c.hello
-  #
-  #     class Child
-  #       undef_method :hello   # prevent any calls to 'hello'
-  #     end
-  #     c.hello
-  #
-  # *produces:*
-  #
-  #     In child
-  #     In parent
-  #     prog.rb:23: undefined method `hello' for #<Child:0x401b3bb4> (NoMethodError)
-  #
-  def undef_method: (*Symbol | String arg0) -> self
-
-  # Import class refinements from *module* into the current class or module
-  # definition.
-  #
-  def using: (Module arg0) -> self
-
-  def inspect: () -> String
-
-  # The first form is equivalent to #attr_reader. The second form is equivalent to
-  # `attr_accessor(name)` but deprecated. The last form is equivalent to
-  # `attr_reader(name)` but deprecated.
-  #
-  def attr: (*Symbol | String arg0) -> NilClass
-end