steep 0.14.0 → 0.16.3

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

@@ -1,182 +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 <<: (untyped g) -> untyped
-
-  # 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
-  # ```
-  def ===: (*untyped obj) -> 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) #=> 8
-  # ```
-  def >>: (untyped g) -> untyped
-
-  # 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 []: (*untyped args) -> untyped
-
-  # 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: (*untyped args) -> untyped
-
-  # 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[untyped]
-
-  # 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: () -> untyped
-
-  # 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: () -> untyped
-end

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

@@ -1,248 +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` ).
-# 
-# ```ruby
-# 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.
-  # 
-  # ```ruby
-  # 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.
-  # 
-  # ```ruby
-  # module M1
-  #   module M2
-  #     $a = Module.nesting
-  #   end
-  # end
-  # $a           #=> [M1::M2, M1]
-  # $a[0].name   #=> "M1::M2"
-  # ```
-  def self.nesting: () -> ::Array[Module]
-
-  def self.used_modules: () -> ::Array[Module]
-
-  def <: (Module other) -> bool?
-
-  def <=: (Module other) -> bool?
-
-  def <=>: (Module other) -> Integer?
-
-  def ==: (untyped other) -> bool
-
-  def ===: (untyped other) -> bool
-
-  def >: (Module other) -> bool?
-
-  def >=: (Module other) -> bool?
-
-  def alias_method: (Symbol new_name, Symbol old_name) -> self
-
-  # Returns a list of modules included/prepended in *mod* (including *mod*
-  # itself).
-  # 
-  # ```ruby
-  # 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]
-
-  def append_features: (Module arg0) -> self
-
-  def `attr_accessor`: (*Symbol | String arg0) -> NilClass
-
-  def `attr_reader`: (*Symbol | String arg0) -> NilClass
-
-  def `attr_writer`: (*Symbol | String arg0) -> NilClass
-
-  def autoload: (Symbol _module, String filename) -> NilClass
-
-  def autoload?: (Symbol name) -> String?
-
-  def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                | [U] (untyped arg0) { (untyped m) -> U } -> U
-
-  def class_exec: (*untyped args) { () -> untyped } -> untyped
-
-  def class_variable_defined?: (Symbol | String arg0) -> bool
-
-  def class_variable_get: (Symbol | String arg0) -> untyped
-
-  def class_variable_set: (Symbol | String arg0, untyped arg1) -> untyped
-
-  def class_variables: (?bool inherit) -> ::Array[Symbol]
-
-  def const_defined?: (Symbol | String arg0, ?bool inherit) -> bool
-
-  def const_get: (Symbol | String arg0, ?bool inherit) -> untyped
-
-  def const_missing: (Symbol arg0) -> untyped
-
-  def const_set: (Symbol | String arg0, untyped arg1) -> untyped
-
-  def constants: (?bool inherit) -> ::Array[Symbol]
-
-  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
-
-  def extend_object: (untyped arg0) -> untyped
-
-  def extended: (Module othermod) -> untyped
-
-  # Prevents further modifications to *mod* .
-  # 
-  # This method returns self.
-  def freeze: () -> self
-
-  def `include`: (*Module arg0) -> self
-
-  def `include?`: (Module arg0) -> bool
-
-  def included: (Module othermod) -> untyped
-
-  # Returns the list of modules included in *mod* .
-  # 
-  # ```ruby
-  # module Mixin
-  # end
-  # 
-  # module Outer
-  #   include Mixin
-  # end
-  # 
-  # Mixin.included_modules   #=> []
-  # Outer.included_modules   #=> [Mixin]
-  # ```
-  def included_modules: () -> ::Array[Module]
-
-  def initialize: () -> Object
-                | () { (Module arg0) -> untyped } -> void
-
-  def instance_method: (Symbol arg0) -> UnboundMethod
-
-  def instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  def method_added: (Symbol meth) -> untyped
-
-  def method_defined?: (Symbol | String arg0) -> bool
-
-  def method_removed: (Symbol method_name) -> untyped
-
-  def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                 | [U] (untyped arg0) { (untyped m) -> U } -> U
-
-  def module_exec: (*untyped args) { () -> untyped } -> untyped
-
-  def module_function: (*Symbol | String arg0) -> self
-
-  # Returns the name of the module *mod* . Returns nil for anonymous
-  # modules.
-  def name: () -> String?
-
-  def `prepend`: (*Module arg0) -> self
-
-  def prepend_features: (Module arg0) -> self
-
-  def prepended: (Module othermod) -> untyped
-
-  def `private`: (*Symbol | String arg0) -> self
-
-  def private_class_method: (*Symbol | String arg0) -> self
-
-  def private_constant: (*Symbol arg0) -> self
-
-  def private_instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  def private_method_defined?: (Symbol | String arg0) -> bool
-
-  def protected: (*Symbol | String arg0) -> self
-
-  def protected_instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  def protected_method_defined?: (Symbol | String arg0) -> bool
-
-  def `public`: (*Symbol | String arg0) -> self
-
-  def public_class_method: (*Symbol | String arg0) -> self
-
-  def public_constant: (*Symbol arg0) -> self
-
-  def public_instance_method: (Symbol arg0) -> UnboundMethod
-
-  def public_instance_methods: (?bool include_super) -> ::Array[Symbol]
-
-  def public_method_defined?: (Symbol | String arg0) -> bool
-
-  def refine: (Class arg0) { (untyped arg0) -> untyped } -> self
-
-  def remove_class_variable: (Symbol arg0) -> untyped
-
-  def remove_const: (Symbol arg0) -> untyped
-
-  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.
-  # 
-  # ```ruby
-  # class C
-  # end
-  # C.singleton_class?                  #=> false
-  # C.singleton_class.singleton_class?  #=> true
-  # ```
-  def `singleton_class?`: () -> bool
-
-  def to_s: () -> String
-
-  def undefMethod: (Symbol | String arg0) -> self
-
-  def using: (Module arg0) -> self
-
-  # Alias for: [to\_s](Module.downloaded.ruby_doc#method-i-to_s)
-  def inspect: () -> String
-
-  def attr: (*Symbol | String arg0) -> NilClass
-end

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

@@ -1,82 +0,0 @@
-# The class of the singleton object `nil`.
-# 
-class NilClass
-  public
-
-  # And---Returns `false`. *obj* is always evaluated as it is the argument to a
-  # method call---there is no short-circuit evaluation in this case.
-  # 
-  def &: (untyped obj) -> bool
-
-  # Case Equality -- For class Object, effectively the same as calling `#==`, but
-  # typically overridden by descendants to provide meaningful semantics in `case`
-  # statements.
-  # 
-  def ===: (nil) -> true
-         | (untyped obj) -> bool
-
-  # Dummy pattern matching -- always returns nil.
-  # 
-  def =~: (untyped obj) -> nil
-
-  # Exclusive Or---If *obj* is `nil` or `false`, returns `false`; otherwise,
-  # returns `true`.
-  # 
-  def ^: (nil) -> false
-       | (false) -> false
-       | (untyped obj) -> bool
-
-  # Always returns the string "nil".
-  # 
-  def inspect: () -> "nil"
-
-  # Only the object *nil* responds `true` to `nil?`.
-  # 
-  def nil?: () -> bool
-
-  # Returns zero as a rational.  The optional argument `eps` is always ignored.
-  # 
-  def rationalize: (?untyped eps) -> Rational
-
-  # Always returns an empty array.
-  # 
-  #     nil.to_a   #=> []
-  # 
-  def to_a: () -> [ ]
-
-  # Returns zero as a complex.
-  # 
-  def to_c: () -> Complex
-
-  # Always returns zero.
-  # 
-  #     nil.to_f   #=> 0.0
-  # 
-  def to_f: () -> Float
-
-  # Always returns an empty hash.
-  # 
-  #     nil.to_h   #=> {}
-  # 
-  def to_h: () -> ::Hash[untyped, untyped]
-
-  # Always returns zero.
-  # 
-  #     nil.to_i   #=> 0
-  # 
-  def to_i: () -> 0
-
-  # Returns zero as a rational.
-  # 
-  def to_r: () -> Rational
-
-  # Always returns the empty string.
-  # 
-  def to_s: () -> ""
-
-  # Or---Returns `false` if *obj* is `nil` or `false`; `true` otherwise.
-  # 
-  def |: (nil) -> false
-       | (false) -> false
-       | (untyped obj) -> bool
-end